@pascal-app/core 1.0.6 → 1.1.0

package/dist/systems/elevator/elevator-service.js

@@ -1,4 +1,5 @@
 import { getLevelElevations } from '../../services/storey.js';
+import { resolveElevatorDimensions } from './elevator-geometry.js';
 function getBuildingLevels(elevator, nodes) {
     const parent = elevator.parentId ? nodes[elevator.parentId] : undefined;
     // Older saves attach elevators to a level. Opening queries must agree before
@@ -54,7 +55,11 @@ export function resolveElevatorServiceLevels(elevator, nodes) {
     const maxIndex = Math.max(fromIndex, resolvedToIndex);
     return levels.slice(minIndex, maxIndex + 1);
 }
-export function resolveElevatorLevels(elevator, nodes) {
+function computeElevatorLevels(elevator, nodes) {
+    const dimensions = resolveElevatorDimensions(elevator);
+    const cabHeight = dimensions.cabHeight;
+    // Keep the cab below the cap even when a thick shaft wall also makes a thick cap.
+    const topClearance = Math.max(0.3, dimensions.shaftWallThickness + 0.01);
     const allLevels = resolveElevatorBuildingLevels(elevator, nodes);
     const levelElevations = getLevelElevations(nodes);
     const serviceLevels = resolveElevatorServiceLevels(elevator, nodes);
@@ -84,16 +89,31 @@ export function resolveElevatorLevels(elevator, nodes) {
             continue;
         stackTopY = Math.max(stackTopY, elevation.baseY + elevation.height);
     }
-    const shaftTopY = nextLevel
+    const configuredTopY = nextLevel
         ? (levelElevations.get(nextLevel.id)?.baseY ?? stackTopY)
         : lastServedLevel
             ? stackTopY
-            : elevator.cabHeight + 0.3;
+            : cabHeight + topClearance;
+    const shaftTopY = Math.max(configuredTopY, shaftBaseY + cabHeight + topClearance, ...entries.map((entry) => entry.baseY + cabHeight + topClearance));
     return {
         entries,
         defaultEntry,
         shaftBaseY,
         shaftTopY,
-        totalHeight: Math.max(shaftTopY - shaftBaseY, elevator.cabHeight + 0.3),
+        totalHeight: Math.max(shaftTopY - shaftBaseY, cabHeight + topClearance),
     };
 }
+const levelCache = new WeakMap();
+export function resolveElevatorLevels(elevator, nodes) {
+    let cache = levelCache.get(nodes);
+    if (!cache) {
+        cache = new WeakMap();
+        levelCache.set(nodes, cache);
+    }
+    let resolved = cache.get(elevator);
+    if (!resolved) {
+        resolved = computeElevatorLevels(elevator, nodes);
+        cache.set(elevator, resolved);
+    }
+    return resolved;
+}

package/dist/systems/fence/guard-layout.d.ts

@@ -0,0 +1,69 @@
+import type { FenceNode } from '../../schema/index.js';
+/** A box standing on the fence's base: its centre, the turn about the vertical axis, its size along its own axes. */
+export type GuardPost = {
+    position: [number, number, number];
+    rotationY: number;
+    scale: [number, number, number];
+    /** A 4-sided cone, square base aligned to the box. */
+    shape?: 'pyramid';
+};
+/**
+ * A run along the centreline between two fractions of its length, `depth` across it, `height` tall
+ * round `centerY`. `split` runs are cut into short segments so a curved fence bends them.
+ */
+export type GuardBlock = {
+    startT: number;
+    endT: number;
+    centerY: number;
+    height: number;
+    depth: number;
+    split: boolean;
+};
+export type GuardLayout = {
+    posts: GuardPost[];
+    /** The cap rail flat over the posts and the top rail on edge under it. */
+    rail: GuardBlock[];
+    /** The bottom rail the balusters stand on (balusters only). */
+    base: GuardBlock[];
+    /** Balusters, cables or boards. */
+    infill: GuardBlock[];
+};
+/**
+ * A deck guard the way the AWC Deck Construction Guide (DCA 6) draws one: 4x4 posts (`postSize`) no
+ * more than `postSpacing` apart, the two ends counted as posts whether drawn or not (`startPost` /
+ * `endPost` false: the rails die into a post already standing there), a 2x6 cap rail flat over the
+ * posts, a 2x4 top rail on edge under it, and the infill: balusters (2x2 on a 2x4 bottom rail
+ * `groundClearance` over the deck, `slatGap` clear), cable (½ in runs `slatGap` apart from
+ * `groundClearance` up), or boards (`thickness` x 5½ in, `slatGap` apart from `groundClearance`
+ * up). `postThrough` runs the posts 3 in past the cap under a cap of their own (`postCap`).
+ *
+ * The pure layout the guard renderer builds its meshes from and the usage field reads its
+ * obstacles from, so the two cannot disagree.
+ */
+export declare function layoutGuardFence(fence: FenceNode): GuardLayout;
+/**
+ * The fractions a run between `startT` and `endT` is cut at: segments no longer than
+ * `maxSegmentLength`, so a curved fence bends them.
+ */
+export declare function fenceBlockSegments(fence: FenceNode, startT: number, endT: number, maxSegmentLength: number): [number, number][];
+type Corner = [number, number];
+/**
+ * The four plan corners of a run between `startT` and `endT`, `depth` across the centreline and
+ * shifted `lateralOffset` to the side the frame's normal points: the outer then the inner corner at
+ * the start, then at the end.
+ */
+export declare function fenceBlockCorners(fence: FenceNode, startT: number, endT: number, depth: number, lateralOffset?: number): [Corner, Corner, Corner, Corner];
+/**
+ * Where a run's end moves to when its fence meets `neighbor` at a corner: the two end corners slide
+ * along the fence so the run meets the neighbour's in a mitre. `side` is -1 for the inner corner and
+ * 1 for the outer, `reach` the metres along the unit vector `(ux, uz)`; null where the two run
+ * nearly straight on, or the mitre would reach absurdly far.
+ */
+export declare function fenceMiter(fence: FenceNode, endpoint: 'start' | 'end', neighbor: FenceNode, depth: number, lateralOffset?: number): {
+    side: -1 | 1;
+    reach: number;
+    ux: number;
+    uz: number;
+}[] | null;
+export {};
+//# sourceMappingURL=guard-layout.d.ts.map

package/dist/systems/fence/guard-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard-layout.d.ts","sourceRoot":"","sources":["../../../src/systems/fence/guard-layout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAe7C,qHAAqH;AACrH,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,sDAAsD;IACtD,KAAK,CAAC,EAAE,SAAS,CAAA;CAClB,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,SAAS,EAAE,CAAA;IAClB,0EAA0E;IAC1E,IAAI,EAAE,UAAU,EAAE,CAAA;IAClB,+DAA+D;IAC/D,IAAI,EAAE,UAAU,EAAE,CAAA;IAClB,mCAAmC;IACnC,MAAM,EAAE,UAAU,EAAE,CAAA;CACrB,CAAA;AASD;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,GAAG,WAAW,CAgG9D;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,gBAAgB,EAAE,MAAM,GACvB,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAOpB;AAED,KAAK,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE9B;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,aAAa,SAAI,GAChB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAclC;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,OAAO,GAAG,KAAK,EACzB,QAAQ,EAAE,SAAS,EACnB,KAAK,EAAE,MAAM,EACb,aAAa,SAAI,GAChB;IAAE,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,EAAE,GAAG,IAAI,CA2BlE"}

package/dist/systems/fence/guard-layout.js

@@ -0,0 +1,194 @@
+import { getFenceCenterlineFrameAt, getFenceCenterlineLength } from './fence-centerline.js';
+/** Dressed lumber the guard is built from, metres. */
+const IN = 0.0254;
+const GUARD_CAP_T = 1.5 * IN;
+const GUARD_CAP_W = 5.5 * IN;
+const GUARD_RAIL_T = 1.5 * IN;
+const GUARD_RAIL_D = 3.5 * IN;
+const GUARD_BALUSTER = 1.5 * IN;
+const GUARD_BOARD_D = 5.5 * IN;
+const GUARD_CABLE = 0.5 * IN;
+const GUARD_POST_ABOVE_CAP = 3 * IN;
+const GUARD_POST_CAP_T = 1 * IN;
+function frameAt(fence, t) {
+    const { point, tangent } = getFenceCenterlineFrameAt(fence, t);
+    return { x: point.x, z: point.y, angle: Math.atan2(tangent.y, tangent.x) };
+}
+/**
+ * A deck guard the way the AWC Deck Construction Guide (DCA 6) draws one: 4x4 posts (`postSize`) no
+ * more than `postSpacing` apart, the two ends counted as posts whether drawn or not (`startPost` /
+ * `endPost` false: the rails die into a post already standing there), a 2x6 cap rail flat over the
+ * posts, a 2x4 top rail on edge under it, and the infill: balusters (2x2 on a 2x4 bottom rail
+ * `groundClearance` over the deck, `slatGap` clear), cable (½ in runs `slatGap` apart from
+ * `groundClearance` up), or boards (`thickness` x 5½ in, `slatGap` apart from `groundClearance`
+ * up). `postThrough` runs the posts 3 in past the cap under a cap of their own (`postCap`).
+ *
+ * The pure layout the guard renderer builds its meshes from and the usage field reads its
+ * obstacles from, so the two cannot disagree.
+ */
+export function layoutGuardFence(fence) {
+    const posts = [];
+    const infill = [];
+    const base = [];
+    const rail = [];
+    const length = Math.max(getFenceCenterlineLength(fence), 0.01);
+    const H = Math.max(fence.height, 0.4);
+    const postW = Math.max(fence.postSize, 0.02);
+    const clearance = Math.max(fence.groundClearance, 0);
+    const gap = Math.max(fence.slatGap ?? 0.09, 0.01);
+    const infillKind = fence.guardInfill ?? 'balusters';
+    const through = fence.postThrough === true;
+    const capTop = H;
+    const capBottom = H - GUARD_CAP_T;
+    const topRailBottom = capBottom - GUARD_RAIL_D;
+    const bays = Math.max(1, Math.ceil(length / Math.max(fence.postSpacing, postW * 2)));
+    const stations = [];
+    for (let i = 0; i <= bays; i++)
+        stations.push(i / bays);
+    // posts: to the cap's underside, or through it with a cap
+    const postH = through ? capTop + GUARD_POST_ABOVE_CAP : capBottom;
+    for (const [i, t] of stations.entries()) {
+        if (i === 0 && fence.startPost === false)
+            continue;
+        if (i === stations.length - 1 && fence.endPost === false)
+            continue;
+        const frame = frameAt(fence, t);
+        posts.push({
+            position: [frame.x, postH / 2, frame.z],
+            rotationY: -frame.angle,
+            scale: [postW, postH, postW],
+        });
+        if (through && (fence.postCap ?? 'flat') !== 'none') {
+            const cap = fence.postCap ?? 'flat';
+            if (cap === 'pyramid') {
+                posts.push({
+                    position: [frame.x, postH + postW * 0.45, frame.z],
+                    rotationY: -frame.angle,
+                    scale: [postW * 1.18, postW * 0.9, postW * 1.18],
+                    shape: 'pyramid',
+                });
+            }
+            else {
+                posts.push({
+                    position: [frame.x, postH + GUARD_POST_CAP_T / 2, frame.z],
+                    rotationY: -frame.angle,
+                    scale: [postW + 2 * IN, GUARD_POST_CAP_T, postW + 2 * IN],
+                });
+            }
+        }
+    }
+    const run = (centerY, height, depth) => ({
+        startT: 0,
+        endT: 1,
+        centerY,
+        height,
+        depth,
+        split: true,
+    });
+    rail.push(run(capBottom + GUARD_CAP_T / 2, GUARD_CAP_T, GUARD_CAP_W));
+    rail.push(run(topRailBottom + GUARD_RAIL_D / 2, GUARD_RAIL_D, GUARD_RAIL_T));
+    const postHalfT = postW / 2 / length;
+    const clearOfPosts = (t, halfT) => !stations.some((s) => Math.abs(s - t) < postHalfT + halfT);
+    if (infillKind === 'balusters') {
+        // the 2x4 bottom rail `clearance` over the deck, the balusters on it
+        const bottomRailTop = clearance + GUARD_RAIL_D;
+        base.push(run(clearance + GUARD_RAIL_D / 2, GUARD_RAIL_D, GUARD_RAIL_T));
+        const balH = Math.max(topRailBottom - bottomRailTop, 0.05);
+        const pitch = GUARD_BALUSTER + gap;
+        const halfT = GUARD_BALUSTER / 2 / length;
+        for (let s = pitch; s < length - GUARD_BALUSTER; s += pitch) {
+            const t = s / length;
+            if (!clearOfPosts(t, halfT))
+                continue;
+            if (2 * halfT <= 1e-5)
+                continue;
+            infill.push({
+                startT: t - halfT,
+                endT: t + halfT,
+                centerY: bottomRailTop + balH / 2,
+                height: balH,
+                depth: GUARD_BALUSTER,
+                split: false,
+            });
+        }
+    }
+    else if (infillKind === 'cable') {
+        // ½ in cables `gap` apart from `clearance` up to under the top rail
+        for (let y = clearance; y < topRailBottom - GUARD_CABLE; y += gap)
+            infill.push(run(y + GUARD_CABLE / 2, GUARD_CABLE, GUARD_CABLE));
+    }
+    else {
+        // boards `gap` apart from `clearance` up to under the top rail
+        const boardT = Math.max(fence.thickness, 0.012);
+        for (let y = clearance; y + GUARD_BOARD_D <= topRailBottom + 1e-6; y += GUARD_BOARD_D + gap)
+            infill.push(run(y + GUARD_BOARD_D / 2, GUARD_BOARD_D, boardT));
+    }
+    return { posts, infill, base, rail };
+}
+/**
+ * The fractions a run between `startT` and `endT` is cut at: segments no longer than
+ * `maxSegmentLength`, so a curved fence bends them.
+ */
+export function fenceBlockSegments(fence, startT, endT, maxSegmentLength) {
+    const length = getFenceCenterlineLength(fence) * Math.max(1e-4, endT - startT);
+    const count = Math.max(1, Math.ceil(length / Math.max(1e-4, maxSegmentLength)));
+    return Array.from({ length: count }, (_, index) => [
+        startT + (endT - startT) * (index / count),
+        startT + (endT - startT) * ((index + 1) / count),
+    ]);
+}
+/**
+ * The four plan corners of a run between `startT` and `endT`, `depth` across the centreline and
+ * shifted `lateralOffset` to the side the frame's normal points: the outer then the inner corner at
+ * the start, then at the end.
+ */
+export function fenceBlockCorners(fence, startT, endT, depth, lateralOffset = 0) {
+    const half = depth / 2;
+    const at = (t) => {
+        const frame = frameAt(fence, t);
+        const nx = -Math.sin(frame.angle);
+        const nz = Math.cos(frame.angle);
+        return [
+            [frame.x + nx * (half + lateralOffset), frame.z + nz * (half + lateralOffset)],
+            [frame.x - nx * (half - lateralOffset), frame.z - nz * (half - lateralOffset)],
+        ];
+    };
+    const [startOuter, startInner] = at(startT);
+    const [endOuter, endInner] = at(endT);
+    return [startOuter, startInner, endOuter, endInner];
+}
+/**
+ * Where a run's end moves to when its fence meets `neighbor` at a corner: the two end corners slide
+ * along the fence so the run meets the neighbour's in a mitre. `side` is -1 for the inner corner and
+ * 1 for the outer, `reach` the metres along the unit vector `(ux, uz)`; null where the two run
+ * nearly straight on, or the mitre would reach absurdly far.
+ */
+export function fenceMiter(fence, endpoint, neighbor, depth, lateralOffset = 0) {
+    const point = fence[endpoint];
+    const frame = getFenceCenterlineFrameAt(fence, endpoint === 'start' ? 0 : 1);
+    const sign = endpoint === 'start' ? 1 : -1;
+    const ux = frame.tangent.x * sign;
+    const uz = frame.tangent.y * sign;
+    const neighborAtStart = Math.hypot(neighbor.start[0] - point[0], neighbor.start[1] - point[1]) < 0.001;
+    const other = getFenceCenterlineFrameAt(neighbor, neighborAtStart ? 0 : 1);
+    const vx = other.tangent.x * (neighborAtStart ? 1 : -1);
+    const vz = other.tangent.y * (neighborAtStart ? 1 : -1);
+    const cross = ux * vz - uz * vx;
+    if (Math.abs(cross) < 0.15)
+        return null;
+    const ratio = Math.max(neighbor.thickness, 0.03) / Math.max(fence.thickness, 0.03);
+    const out = [];
+    for (const side of [-1, 1]) {
+        const offset = lateralOffset + (side * depth) / 2;
+        const neighborOffset = -offset * sign * ratio;
+        const nx = -uz * offset * sign;
+        const nz = ux * offset * sign;
+        const mx = -vz * neighborOffset;
+        const mz = vx * neighborOffset;
+        const reach = ((mx - nx) * vz - (mz - nz) * vx) / cross;
+        if (Math.abs(reach) > Math.max(depth, depth * ratio) * 4)
+            continue;
+        out.push({ side, reach, ux, uz });
+    }
+    return out;
+}

package/dist/systems/owned-floor-openings.d.ts

@@ -1,5 +1,17 @@
 import type { NodePatch } from '../lib/structure-kernel.js';
-import type { AnyNode } from '../schema/index.js';
+import type { AnyNode, AnyNodeId, FloorOpeningNode } from '../schema/index.js';
+/**
+ * A stair opening reshaped by hand: the floor cut and the ceiling cut below it (the stair's openings
+ * on its own two levels) take `polygon` and become openings the stair owns as drawn, so the plate
+ * and ceiling are cut by that shape (not the derived rectangle) and keep it when the stair is
+ * reselected or re-synced. The stair's current pose is recorded so they still follow it when it
+ * moves or resizes. Returns the patches; empty when `openingId` is not a stair opening that can be
+ * authored this way (an opening on a level between two the stair joins keeps following it).
+ */
+export declare function authorStairOpeningPatches(nodes: Record<string, AnyNode>, openingId: string, polygon: [number, number][]): Array<{
+    id: AnyNodeId;
+    data: Partial<FloorOpeningNode>;
+}>;
 export declare function planOwnedFloorOpenings(nodes: Record<string, AnyNode>, options?: {
     ownerIds?: ReadonlySet<string>;
     skipExistingSurfaces?: boolean;

package/dist/systems/owned-floor-openings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"owned-floor-openings.d.ts","sourceRoot":"","sources":["../../src/systems/owned-floor-openings.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,EAAE,OAAO,EAAoD,MAAM,WAAW,CAAA;AA8H1F,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,GAAE;IACP,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAC9B,oBAAoB,CAAC,EAAE,OAAO,CAAA;IAC9B,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACvC,GACL,SAAS,EAAE,CAyRb"}
+{"version":3,"file":"owned-floor-openings.d.ts","sourceRoot":"","sources":["../../src/systems/owned-floor-openings.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAExD,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAuB,MAAM,WAAW,CAAA;AAwI1F;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAC1B,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAA;CAAE,CAAC,CAuC3D;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,GAAE;IACP,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAC9B,oBAAoB,CAAC,EAAE,OAAO,CAAA;IAC9B,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACvC,GACL,SAAS,EAAE,CA2Rb"}

package/dist/systems/owned-floor-openings.js

@@ -1,4 +1,5 @@
 import { canonicalOpeningRing } from '../lib/canonical-opening-ring.js';
+import { queryNodes } from '../runtime/node-queries.js';
 import { FloorOpeningNode as FloorOpeningSchema } from '../schema/nodes/floor-opening.js';
 import { resolveCeilingHeight } from '../services/level-height.js';
 import { getLevelElevations } from '../services/storey.js';
@@ -99,12 +100,67 @@ function cutsFromSurfaces(surfaces, owners) {
     }
     return cuts;
 }
+/** The level an authored stair opening is kept on: its source level for a ceiling cut, else its destination. */
+function authoredOpeningTarget(opening, owner) {
+    return opening.metadata.ownerOpeningTarget === 'source' || opening.drawnOn === 'ceiling'
+        ? owner.fromLevelId
+        : owner.toLevelId;
+}
+/**
+ * A stair opening reshaped by hand: the floor cut and the ceiling cut below it (the stair's openings
+ * on its own two levels) take `polygon` and become openings the stair owns as drawn, so the plate
+ * and ceiling are cut by that shape (not the derived rectangle) and keep it when the stair is
+ * reselected or re-synced. The stair's current pose is recorded so they still follow it when it
+ * moves or resizes. Returns the patches; empty when `openingId` is not a stair opening that can be
+ * authored this way (an opening on a level between two the stair joins keeps following it).
+ */
+export function authorStairOpeningPatches(nodes, openingId, polygon) {
+    const opening = nodes[openingId];
+    if (opening?.type !== 'floor-opening' || opening.source !== 'stair' || !opening.ownerId)
+        return [];
+    const owner = nodes[opening.ownerId];
+    if (owner?.type !== 'stair' || authoredOpeningTarget(opening, owner) !== opening.parentId)
+        return [];
+    const segment = owner.children
+        .map((id) => nodes[id])
+        .find((node) => node?.type === 'stair-segment');
+    const footprint = stairFootprintAABB({ ...owner, position: [0, 0, 0], rotation: 0 }, nodes);
+    const pose = {
+        position: owner.position,
+        rotation: owner.rotation,
+        width: owner.width,
+        runLength: segment?.type === 'stair-segment' ? segment.length : 1,
+        ...(isBox(footprint) ? { footprint } : {}),
+    };
+    const ring = canonicalOpeningRing(polygon);
+    return Object.values(nodes).flatMap((node) => node.type === 'floor-opening' &&
+        node.source === 'stair' &&
+        node.ownerId === owner.id &&
+        authoredOpeningTarget(node, owner) === node.parentId
+        ? [
+            {
+                id: node.id,
+                data: {
+                    polygon: ring,
+                    surfaceId: undefined,
+                    legacyPlateCuts: undefined,
+                    legacyCeilingCuts: undefined,
+                    cutsPrimary: true,
+                    cutsAdjacent: false,
+                    metadata: { ...node.metadata, ownerPose: pose },
+                },
+            },
+        ]
+        : []);
+}
 export function planOwnedFloorOpenings(nodes, options = {}) {
-    const values = Object.values(nodes);
-    if (!values.some((node) => node.type === 'stair' ||
+    // Owners and their openings first: a scene with none has nothing to plan.
+    const owned = queryNodes(nodes, { type: ['stair', 'elevator', 'floor-opening'] });
+    if (!owned.some((node) => node.type === 'stair' ||
         node.type === 'elevator' ||
         (node.type === 'floor-opening' && (node.source === 'stair' || node.source === 'elevator'))))
         return [];
+    const values = Object.values(nodes);
     const existing = values.filter((node) => node.type === 'floor-opening' &&
         (node.source === 'stair' || node.source === 'elevator') &&
         !!node.ownerId &&

package/dist/systems/reconcile-owned-floor-openings.d.ts

@@ -1,3 +1,5 @@
 import type { NodePatch, SceneNodes } from '../lib/structure-kernel.js';
-export declare function reconcileOwnedFloorOpeningChanges(before: SceneNodes, changes: NodePatch[]): void;
+import type { SceneStore } from '../store/use-scene.js';
+/** Re-derives the structure of every level an owned opening change cut into or out of. */
+export declare function reconcileOwnedFloorOpeningChanges(store: Pick<SceneStore, 'getState'>, before: SceneNodes, changes: NodePatch[]): void;
 //# sourceMappingURL=reconcile-owned-floor-openings.d.ts.map

package/dist/systems/reconcile-owned-floor-openings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reconcile-owned-floor-openings.d.ts","sourceRoot":"","sources":["../../src/systems/reconcile-owned-floor-openings.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAKpE,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,SAAS,EAAE,QAkBzF"}
+{"version":3,"file":"reconcile-owned-floor-openings.d.ts","sourceRoot":"","sources":["../../src/systems/reconcile-owned-floor-openings.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAGpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAEpD,0FAA0F;AAC1F,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,EACnC,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,SAAS,EAAE,QAmBrB"}

package/dist/systems/reconcile-owned-floor-openings.js

@@ -1,9 +1,9 @@
 import { createFloorOpeningIndex, floorOpeningTargets } from '../lib/floor-opening-intent.js';
 import { applyStructureReconciliation } from '../lib/structure-commit.js';
 import { generateId } from '../schema/base.js';
-import useScene from '../store/use-scene.js';
-export function reconcileOwnedFloorOpeningChanges(before, changes) {
-    const after = useScene.getState().nodes;
+/** Re-derives the structure of every level an owned opening change cut into or out of. */
+export function reconcileOwnedFloorOpeningChanges(store, before, changes) {
+    const after = store.getState().nodes;
     const oldIndex = createFloorOpeningIndex(before);
     const newIndex = createFloorOpeningIndex(after);
     const levels = new Set();
@@ -21,5 +21,5 @@ export function reconcileOwnedFloorOpeningChanges(before, changes) {
         }
     }
     if (levels.size)
-        applyStructureReconciliation(useScene, { levelIds: [...levels], mintId: generateId });
+        applyStructureReconciliation(store, { levelIds: [...levels], mintId: generateId });
 }

package/dist/systems/roof/roof-elevation-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roof-elevation-system.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-elevation-system.tsx"],"names":[],"mappings":"AAiCA,wBAAgB,2BAA2B,IAAI,MAAM,IAAI,CAwExD;AAED,wBAAgB,mBAAmB,SAGlC"}
+{"version":3,"file":"roof-elevation-system.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-elevation-system.tsx"],"names":[],"mappings":"AAqBA,wBAAgB,2BAA2B,IAAI,MAAM,IAAI,CAgExD;AAED,wBAAgB,mBAAmB,SAGlC"}

package/dist/systems/roof/roof-elevation-system.js

@@ -1,22 +1,14 @@
 'use client';
 import { useEffect } from 'react';
 import { roofsKeptOverStorey } from '../../services/roof-move.js';
+import { isSettlingDocument } from '../../store/document-settling.js';
 import { getSceneHistoryPauseDepth, notifySceneCommit, pauseSceneHistory, resumeSceneHistory, } from '../../store/history-control.js';
 import useScene from '../../store/use-scene.js';
-import { resolveRoofElevation } from './roof-elevation.js';
-const ROOF_ELEVATION_EPSILON = 1e-4;
+import { isRoofElevationInput, planRoofElevationUpdates } from './roof-elevation.js';
 function sceneSnapshot() {
     const { nodes, rootNodeIds, collections, materials, installedPlugins } = useScene.getState();
     return { nodes, rootNodeIds, collections, materials, installedPlugins };
 }
-function isElevationRelevant(node) {
-    return (node?.type === 'roof' ||
-        node?.type === 'wall' ||
-        node?.type === 'slab' ||
-        node?.type === 'level' ||
-        node?.type === 'building' ||
-        node?.type === 'site');
-}
 export function initializeRoofElevationSync() {
     let disposed = false;
     let queued = false;
@@ -36,20 +28,10 @@ export function initializeRoofElevationSync() {
             const { nodes, updateNodes, readOnly } = useScene.getState();
             if (readOnly)
                 return;
-            const updates = changedFrom
-                ? roofsKeptOverStorey(changedFrom, nodes)
-                : [];
-            for (const node of Object.values(nodes)) {
-                if (node.type !== 'roof' || node.support?.kind !== 'walls')
-                    continue;
-                const elevation = resolveRoofElevation(node, nodes);
-                if (Math.abs(node.position[1] - elevation) <= ROOF_ELEVATION_EPSILON)
-                    continue;
-                updates.push({
-                    id: node.id,
-                    data: { position: [node.position[0], elevation, node.position[2]] },
-                });
-            }
+            const updates = [
+                ...(changedFrom ? roofsKeptOverStorey(changedFrom, nodes) : []),
+                ...planRoofElevationUpdates(nodes),
+            ];
             if (updates.length === 0)
                 return;
             const before = sceneSnapshot();
@@ -76,13 +58,13 @@ export function initializeRoofElevationSync() {
         });
     };
     const unsubscribe = useScene.subscribe((state, previous) => {
-        if (syncing || state.nodes === previous.nodes)
+        if (syncing || state.nodes === previous.nodes || isSettlingDocument(useScene))
             return;
         const ids = new Set([...Object.keys(state.nodes), ...Object.keys(previous.nodes)]);
         for (const id of ids) {
             const next = state.nodes[id];
             const prev = previous.nodes[id];
-            if (next !== prev && (isElevationRelevant(next) || isElevationRelevant(prev))) {
+            if (next !== prev && (isRoofElevationInput(next) || isRoofElevationInput(prev))) {
                 schedule(previous.nodes);
                 return;
             }

package/dist/systems/roof/roof-elevation.d.ts

@@ -1,4 +1,4 @@
-import type { AnyNode, LevelNode, RoofNode, WallNode } from '../../schema/index.js';
+import type { AnyNode, AnyNodeId, LevelNode, RoofNode, WallNode } from '../../schema/index.js';
 export declare function resolveRoofWallTopElevation(targetLevelId: LevelNode['id'], wall: WallNode, nodes: Readonly<Record<string, AnyNode>>, elevations?: Map<string, import("../../index.js").LevelElevation>): number;
 export declare function resolveRoofElevation(roof: RoofNode, nodes: Readonly<Record<string, AnyNode>>): number;
 /**
@@ -6,4 +6,19 @@ export declare function resolveRoofElevation(roof: RoofNode, nodes: Readonly<Rec
  * roof (m); null when it stands on none of them, or has no segments to stand with.
  */
 export declare function roofWallTop(roof: RoofNode, nodes: Readonly<Record<string, AnyNode>>, levelId: string): number | null;
+/** Kinds whose change can move a wall-supported roof. */
+export declare function isRoofElevationInput(node: AnyNode | undefined): boolean;
+/** Wall-supported roofs whose stored Y no longer sits on their walls, and where it should. */
+export declare function planRoofElevationUpdates(nodes: Readonly<Record<string, AnyNode>>, only?: ReadonlySet<string> | null): Array<{
+    id: AnyNodeId;
+    data: Partial<AnyNode>;
+}>;
+/**
+ * The roofs an edit can move, from the nodes it changed. A roof rests on the walls of its own level
+ * or the level below, so: a changed roof (or segment); for a changed wall, the roofs on its level
+ * and the level above; for a changed slab, the levels whose walls it touches (its own, which it
+ * carries, and the one below, whose plane-bound tops it caps) and every level above it in its
+ * building (a base plate lifts them). Null, for every roof, when a level, building or site changed.
+ */
+export declare function roofsAffectedBy(before: Readonly<Record<string, AnyNode>>, after: Readonly<Record<string, AnyNode>>, changedIds: Iterable<string>): Set<string> | null;
 //# sourceMappingURL=roof-elevation.d.ts.map

package/dist/systems/roof/roof-elevation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roof-elevation.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-elevation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAmB,QAAQ,EAAE,MAAM,cAAc,CAAA;AAO3F,wBAAgB,2BAA2B,CACzC,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,EAC9B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,UAAU,8CAA4B,GACrC,MAAM,CAMR;AAqFD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,MAAM,CAiCR;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,IAAI,CAQf"}
+{"version":3,"file":"roof-elevation.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-elevation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,SAAS,EACT,QAAQ,EAER,QAAQ,EACT,MAAM,cAAc,CAAA;AAarB,wBAAgB,2BAA2B,CACzC,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,EAC9B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,UAAU,8CAA4B,GACrC,MAAM,CAUR;AAwFD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,MAAM,CAiCR;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,IAAI,CAQf;AAID,yDAAyD;AACzD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,CASvE;AAED,8FAA8F;AAC9F,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,IAAI,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,GAChC,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC,CAYlD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,GAC3B,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAkCpB"}