@pascal-app/core 1.0.6 → 1.0.7

package/dist/systems/document-reconcile.d.ts

@@ -0,0 +1,40 @@
+import { type SpatialGridManager } from '../hooks/spatial-grid/spatial-grid-manager.js';
+import type { SceneNodes } from '../lib/structure-kernel.js';
+import type { AnyNode } from '../schema/index.js';
+import type { SceneStore } from '../store/use-scene.js';
+/** Kinds whose change re-sizes a straight stair's flights or re-cuts its floor openings. */
+export declare function isStairOpeningInput(node: AnyNode | undefined): boolean;
+/** Kinds whose change re-cuts an elevator's (and so every owner's) floor openings. */
+export declare function isElevatorOpeningInput(node: AnyNode | undefined): boolean;
+/** Whether any node of an input kind differs between two versions of a scene. */
+export declare function changedInputs(before: SceneNodes, after: SceneNodes, isInput: (node: AnyNode | undefined) => boolean, options?: {
+    ignoreChildLists?: boolean;
+}): boolean;
+export type DocumentReconcileOptions = {
+    /**
+     * The view the passes read a version of the nodes through: a detached scene's tracked view, so
+     * their reads are recorded. Applied to every version a pass compares, so identity holds between.
+     */
+    read?: (nodes: SceneNodes) => SceneNodes;
+    /** Re-derive every level's structure, not only the levels whose structure changed since `before`. */
+    allLevels?: boolean;
+    /** The support index the passes query; by default one built from the store's own nodes. */
+    grid?: () => SpatialGridManager;
+};
+/**
+ * Every derived write the document owes after an edit, in one synchronous pass, so a patch taken
+ * afterwards is complete and applying it to the editor leaves its systems nothing to write:
+ *
+ * - room structure (zones, auto ceilings, floor plates) for the levels whose structure changed,
+ *   as space detection derives it for a batch;
+ * - stair rises and the floor openings stairs and elevators own, as the opening systems do;
+ * - the elevation of wall-supported roofs, and of a roof kept over the storey it covers when its
+ *   level moves, as the roof system does.
+ *
+ * The opening and roof systems still run in the editor (on a microtask, for edits made by hand);
+ * they plan with the same functions, so after this pass they find nothing to do. Writes are
+ * history-paused: they join the triggering edit's undo step. Support queries read an index built
+ * from the store's nodes, never the editor's previews.
+ */
+export declare function reconcileDocument(store: SceneStore, before: SceneNodes, options?: DocumentReconcileOptions): void;
+//# sourceMappingURL=document-reconcile.d.ts.map

package/dist/systems/document-reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-reconcile.d.ts","sourceRoot":"","sources":["../../src/systems/document-reconcile.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,kBAAkB,EAGxB,MAAM,4CAA4C,CAAA;AAInD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AACzD,OAAO,KAAK,EAAE,OAAO,EAAa,MAAM,WAAW,CAAA;AAKnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAWpD,4FAA4F;AAC5F,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,CAStE;AAED,sFAAsF;AACtF,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,CAQzE;AAED,iFAAiF;AACjF,wBAAgB,aAAa,CAC3B,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,KAAK,OAAO,EAC/C,OAAO,GAAE;IAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3C,OAAO,CAST;AAYD,MAAM,MAAM,wBAAwB,GAAG;IACrC;;;OAGG;IACH,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,UAAU,CAAA;IACxC,qGAAqG;IACrG,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,2FAA2F;IAC3F,IAAI,CAAC,EAAE,MAAM,kBAAkB,CAAA;CAChC,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,UAAU,EAClB,OAAO,GAAE,wBAA6B,GACrC,IAAI,CA0FN"}

package/dist/systems/document-reconcile.js

@@ -0,0 +1,159 @@
+import { structureChangeBatch } from '../commands/structure/shared.js';
+import { supportIndexOf, withSpatialGrid, } from '../hooks/spatial-grid/spatial-grid-manager.js';
+import { resolveLevelId } from '../lib/node-ancestry.js';
+import { structureLevelsForChange } from '../lib/space-detection.js';
+import { applyStructureReconciliation } from '../lib/structure-commit.js';
+import { generateId } from '../schema/base.js';
+import { roofsKeptOverStorey } from '../services/roof-move.js';
+import { pauseSceneHistory, resumeSceneHistory } from '../store/history-control.js';
+import { withoutLivePreviews } from '../store/live-previews.js';
+import { planOwnedFloorOpenings } from './owned-floor-openings.js';
+import { reconcileOwnedFloorOpeningChanges } from './reconcile-owned-floor-openings.js';
+import { isRoofElevationInput, planRoofElevationUpdates, roofsAffectedBy, } from './roof/roof-elevation.js';
+import { changedStairOpeningOwners } from './stair/stair-opening-sync.js';
+import { syncStairRises } from './stair/stair-rise.js';
+/** Kinds whose change re-sizes a straight stair's flights or re-cuts its floor openings. */
+export function isStairOpeningInput(node) {
+    return (node?.type === 'building' ||
+        node?.type === 'ceiling' ||
+        node?.type === 'level' ||
+        node?.type === 'slab' ||
+        node?.type === 'stair' ||
+        node?.type === 'stair-segment');
+}
+/** Kinds whose change re-cuts an elevator's (and so every owner's) floor openings. */
+export function isElevatorOpeningInput(node) {
+    return (node?.type === 'building' ||
+        node?.type === 'ceiling' ||
+        node?.type === 'elevator' ||
+        node?.type === 'level' ||
+        node?.type === 'slab');
+}
+/** Whether any node of an input kind differs between two versions of a scene. */
+export function changedInputs(before, after, isInput, options = {}) {
+    if (before === after)
+        return false;
+    const differs = (previous, next) => previous !== next &&
+        (isInput(previous) || isInput(next)) &&
+        !(options.ignoreChildLists && onlyChildListChanged(previous, next));
+    for (const id in after)
+        if (differs(before[id], after[id]))
+            return true;
+    for (const id in before)
+        if (!(id in after) && differs(before[id], undefined))
+            return true;
+    return false;
+}
+/** Only a node's child list changed: its children's own changes are what passes react to. */
+function onlyChildListChanged(previous, next) {
+    if (!(previous && next))
+        return false;
+    const a = previous;
+    const b = next;
+    for (const key in b)
+        if (key !== 'children' && a[key] !== b[key])
+            return false;
+    for (const key in a)
+        if (key !== 'children' && !(key in b))
+            return false;
+    return true;
+}
+/**
+ * Every derived write the document owes after an edit, in one synchronous pass, so a patch taken
+ * afterwards is complete and applying it to the editor leaves its systems nothing to write:
+ *
+ * - room structure (zones, auto ceilings, floor plates) for the levels whose structure changed,
+ *   as space detection derives it for a batch;
+ * - stair rises and the floor openings stairs and elevators own, as the opening systems do;
+ * - the elevation of wall-supported roofs, and of a roof kept over the storey it covers when its
+ *   level moves, as the roof system does.
+ *
+ * The opening and roof systems still run in the editor (on a microtask, for edits made by hand);
+ * they plan with the same functions, so after this pass they find nothing to do. Writes are
+ * history-paused: they join the triggering edit's undo step. Support queries read an index built
+ * from the store's nodes, never the editor's previews.
+ */
+export function reconcileDocument(store, before, options = {}) {
+    const read = options.read ?? ((nodes) => nodes);
+    const nodes = () => store.getState().nodes;
+    const view = () => read(nodes());
+    const grid = options.grid ?? (() => supportIndexOf(store, resolveLevelId));
+    // The kernel and opening planners read the store's nodes through `read`; their writes go to it.
+    const readingStore = {
+        getState: () => ({ ...store.getState(), nodes: view() }),
+    };
+    const write = (apply) => {
+        pauseSceneHistory(store);
+        try {
+            apply();
+        }
+        finally {
+            resumeSceneHistory(store);
+        }
+    };
+    const applyOpenings = (changes) => {
+        if (!changes.length)
+            return;
+        const previous = nodes();
+        write(() => {
+            store.getState().applyNodeChanges(structureChangeBatch(changes));
+            reconcileOwnedFloorOpeningChanges(readingStore, read(previous), changes);
+        });
+    };
+    withoutLivePreviews(() => withSpatialGrid(grid, () => {
+        const levelIds = options.allLevels ? undefined : structureLevelsForChange(before, nodes());
+        if (!levelIds || levelIds.length)
+            write(() => applyStructureReconciliation(readingStore, {
+                levelIds,
+                previousNodes: options.allLevels ? undefined : read(before),
+                mintId: generateId,
+            }));
+        // A parent's child list is bookkeeping: what was added or removed is an input of its own.
+        const settled = { ignoreChildLists: true };
+        let stairsFrom = before;
+        let elevatorsFrom = before;
+        let roofsFrom = before;
+        // Each pass can feed another (a stair's openings change slabs, slabs carry roofs); a pass runs
+        // again only on a change to its own inputs, so this settles in a few rounds.
+        for (let round = 0; round < 8; round++) {
+            const start = nodes();
+            if (changedInputs(stairsFrom, start, isStairOpeningInput, settled)) {
+                const from = stairsFrom;
+                stairsFrom = start;
+                const rises = syncStairRises(view());
+                if (rises.length)
+                    write(() => store.getState().updateNodes(rises));
+                // Which stairs this edit moved is the edit's own bookkeeping; the re-cut reads the scene.
+                const owners = changedStairOpeningOwners(from, nodes());
+                applyOpenings(planOwnedFloorOpenings(view(), { ownerIds: owners }));
+                stairsFrom = nodes();
+            }
+            if (changedInputs(elevatorsFrom, nodes(), isElevatorOpeningInput, settled)) {
+                applyOpenings(planOwnedFloorOpenings(view()));
+                elevatorsFrom = nodes();
+            }
+            // A roof's own child list is an input: a segment added reshapes its footprint.
+            const current = nodes();
+            const changed = [];
+            for (const id in current)
+                if (current[id] !== roofsFrom[id] &&
+                    (current[id]?.type === 'roof' || !onlyChildListChanged(roofsFrom[id], current[id])))
+                    changed.push(id);
+            for (const id in roofsFrom)
+                if (!(id in current))
+                    changed.push(id);
+            const roofInput = (node) => isRoofElevationInput(node) || node?.type === 'roof-segment';
+            if (changed.some((id) => roofInput(roofsFrom[id]) || roofInput(current[id]))) {
+                const roofs = [
+                    ...roofsKeptOverStorey(roofsFrom, view()),
+                    ...planRoofElevationUpdates(view(), roofsAffectedBy(roofsFrom, current, changed)),
+                ];
+                if (roofs.length)
+                    write(() => store.getState().updateNodes(roofs));
+                roofsFrom = nodes();
+            }
+            if (nodes() === start)
+                break;
+        }
+    }));
+}

package/dist/systems/elevator/elevator-opening-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"elevator-opening-system.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-opening-system.tsx"],"names":[],"mappings":"AAsCA,wBAAgB,6BAA6B,eAyB5C;AAED,eAAO,MAAM,qBAAqB,YAIjC,CAAA"}
+{"version":3,"file":"elevator-opening-system.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-opening-system.tsx"],"names":[],"mappings":"AAYA,wBAAgB,6BAA6B,eAgC5C;AAED,eAAO,MAAM,qBAAqB,YAIjC,CAAA"}

package/dist/systems/elevator/elevator-opening-system.js

@@ -1,32 +1,13 @@
 'use client';
 import { useEffect } from 'react';
 import { structureChangeBatch } from '../../commands/structure/shared.js';
+import { isSettlingDocument } from '../../store/document-settling.js';
 import { pauseSceneHistory, resumeSceneHistory } from '../../store/history-control.js';
 import { isHydrationNormalization } from '../../store/scene-hydration.js';
 import useScene from '../../store/use-scene.js';
+import { changedInputs, isElevatorOpeningInput } from '../document-reconcile.js';
 import { planOwnedFloorOpenings } from '../owned-floor-openings.js';
 import { reconcileOwnedFloorOpeningChanges } from '../reconcile-owned-floor-openings.js';
-function isOpeningRelevantNode(node) {
-    return (node?.type === 'building' ||
-        node?.type === 'ceiling' ||
-        node?.type === 'elevator' ||
-        node?.type === 'level' ||
-        node?.type === 'slab');
-}
-function hasOpeningRelevantNodeChange(nextNodes, prevNodes) {
-    if (nextNodes === prevNodes)
-        return false;
-    const ids = new Set([...Object.keys(nextNodes), ...Object.keys(prevNodes)]);
-    for (const id of ids) {
-        const nextNode = nextNodes[id];
-        const prevNode = prevNodes[id];
-        if (nextNode === prevNode)
-            continue;
-        if (isOpeningRelevantNode(nextNode) || isOpeningRelevantNode(prevNode))
-            return true;
-    }
-    return false;
-}
 export function initializeElevatorOpeningSync() {
     let syncingAutoOpenings = false;
     const applyChanges = (skipExistingSurfaces = false) => {
@@ -38,7 +19,7 @@ export function initializeElevatorOpeningSync() {
         try {
             const before = useScene.getState().nodes;
             useScene.getState().applyNodeChanges(structureChangeBatch(changes));
-            reconcileOwnedFloorOpeningChanges(before, changes);
+            reconcileOwnedFloorOpeningChanges(useScene, before, changes);
         }
         finally {
             resumeSceneHistory(useScene);
@@ -47,9 +28,13 @@ export function initializeElevatorOpeningSync() {
     };
     applyChanges(true);
     return useScene.subscribe((state, prevState) => {
-        if (syncingAutoOpenings)
+        if (syncingAutoOpenings || isSettlingDocument(useScene))
             return;
-        if (!hasOpeningRelevantNodeChange(state.nodes, prevState.nodes))
+        // A level's child list is bookkeeping (furniture re-parenting under it): what joined or left
+        // is an input of its own, as the document reconcile reads it.
+        if (!changedInputs(prevState.nodes, state.nodes, isElevatorOpeningInput, {
+            ignoreChildLists: true,
+        }))
             return;
         applyChanges(isHydrationNormalization() || state.hydrationId !== prevState.hydrationId);
     });

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"}