@pascal-app/nodes 0.1.1 → 1.0.0-beta.2

package/dist/fence/definition.js

@@ -1,8 +1,10 @@
 import { getFenceControlHandle, isSplineFence, } from '@pascal-app/core';
+import { clearStructuralElevationGuide, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
 import { buildFenceFloorplan } from './floorplan';
 import { fenceControlPointAffordance, fenceCurveAffordance, fenceMoveEndpointAffordance, fenceTangentAffordance, } from './floorplan-affordances';
 import { fenceFloorplanMoveTarget } from './floorplan-move';
 import { buildFenceGeometry } from './geometry';
+import { resolveFenceLiftElevation, resolveFenceLiftElevationForNodes } from './lift';
 import { fencePaint } from './paint';
 import { fenceParametrics } from './parametrics';
 import { FenceNode } from './schema';
@@ -13,6 +15,12 @@ const SIDE_HANDLE_TOP_INSET = 0.08;
 const SIDE_HANDLE_MIN_HEIGHT = 0.4;
 const HEIGHT_HANDLE_OFFSET = 0.45;
 const MIN_FENCE_HEIGHT = 0.3;
+function fenceBaseElevation(n, sceneApi) {
+    const nodes = sceneApi?.nodes();
+    return nodes
+        ? resolveFenceLiftElevationForNodes(n, nodes)
+        : resolveFenceLiftElevation(n, () => undefined);
+}
 function fenceMidpointFrame(n) {
     const dx = n.end[0] - n.start[0];
     const dz = n.end[1] - n.start[1];
@@ -24,6 +32,14 @@ function fenceMidpointFrame(n) {
         normalZ: dx / len,
     };
 }
+function fenceElevationGuideSource(n) {
+    const { midX, midZ } = fenceMidpointFrame(n);
+    return {
+        nodeId: n.id,
+        levelId: n.parentId,
+        anchor: [midX, midZ],
+    };
+}
 // Side-move arrows: click to hand the fence to its move tool. Same shape
 // as wall — front + back faces, positioned past the fence thickness near
 // the top so they don't compete with endpoint pickers in the floating
@@ -34,11 +50,12 @@ function fenceSideMoveHandle(side) {
         kind: 'tap-action',
         onActivate: (node, _scene, editor) => editor.engageMove(node),
         placement: {
-            position: (n) => {
+            position: (n, sceneApi) => {
                 const { midX, midZ, normalX, normalZ } = fenceMidpointFrame(n);
                 const offset = Math.max((n.thickness ?? 0.1) / 2 + SIDE_HANDLE_OFFSET, SIDE_HANDLE_MIN_OFFSET);
                 const h = n.height ?? 1.8;
-                const handleY = Math.max(h - SIDE_HANDLE_TOP_INSET, SIDE_HANDLE_MIN_HEIGHT);
+                const handleY = fenceBaseElevation(n, sceneApi) +
+                    Math.max(h - SIDE_HANDLE_TOP_INSET, SIDE_HANDLE_MIN_HEIGHT);
                 return [midX + sign * normalX * offset, handleY, midZ + sign * normalZ * offset];
             },
             rotationY: (n) => {
@@ -69,9 +86,13 @@ function fenceHeightHandle() {
         currentValue: (n) => n.height ?? 1.8,
         apply: (_n, newHeight) => ({ height: newHeight }),
         placement: {
-            position: (n) => {
+            position: (n, sceneApi) => {
                 const { midX, midZ } = fenceMidpointFrame(n);
-                return [midX, (n.height ?? 1.8) + HEIGHT_HANDLE_OFFSET, midZ];
+                return [
+                    midX,
+                    fenceBaseElevation(n, sceneApi) + (n.height ?? 1.8) + HEIGHT_HANDLE_OFFSET,
+                    midZ,
+                ];
             },
             rotationY: (n) => {
                 const { normalX, normalZ } = fenceMidpointFrame(n);
@@ -80,6 +101,36 @@ function fenceHeightHandle() {
         },
     };
 }
+function fenceElevationHandle(currentBase) {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        shape: 'tracker',
+        gridSnap: true,
+        currentValue: () => currentBase,
+        magneticSnap: (n, newValue, sceneApi) => resolveStructuralElevationSnap(fenceElevationGuideSource(n), newValue, sceneApi.nodes()),
+        onDrag: (n, sceneApi) => publishStructuralElevationGuide(fenceElevationGuideSource(n), fenceBaseElevation(n, sceneApi), sceneApi.nodes()),
+        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
+        apply: (initial, newBase, sceneApi) => {
+            // The offset is measured from the support WITHOUT the current offset —
+            // including the ground, so dragging a fence's base to an absolute height
+            // on a hillside stores the delta from that hillside and the fence keeps
+            // following it.
+            const supportBase = resolveFenceLiftElevationForNodes({ ...initial, supportOffset: undefined }, sceneApi.nodes());
+            const nextOffset = newBase - supportBase;
+            return {
+                supportOffset: Math.abs(nextOffset) < 1e-6 ? undefined : nextOffset,
+            };
+        },
+        placement: {
+            position: (n, sceneApi) => {
+                const { midX, midZ } = fenceMidpointFrame(n);
+                return [midX, fenceBaseElevation(n, sceneApi), midZ];
+            },
+        },
+    };
+}
 // Corner picker — dashed vertical leader + billboarded hex disc at the
 // endpoint. Tap engages the endpoint-move flow (sister to the wall
 // pickers). nodeHeight controls the leader's vertical reach so the
@@ -92,9 +143,9 @@ function fenceCornerPicker(endpoint) {
         nodeHeight: (n) => n.height ?? 1.8,
         onActivate: (node, _scene, editor) => editor.engageEndpointMove(node, endpoint),
         placement: {
-            position: (n) => {
+            position: (n, sceneApi) => {
                 const corner = endpoint === 'start' ? n.start : n.end;
-                return [corner[0], 0, corner[1]];
+                return [corner[0], fenceBaseElevation(n, sceneApi), corner[1]];
             },
         },
     };
@@ -108,9 +159,9 @@ function fenceControlPointPicker(index) {
         nodeHeight: (n) => n.height ?? 1.8,
         onActivate: (node, _scene, editor) => editor.engageControlPointMove(node, index),
         placement: {
-            position: (n) => {
+            position: (n, sceneApi) => {
                 const point = n.path?.[index] ?? n.start;
-                return [point[0], 0, point[1]];
+                return [point[0], fenceBaseElevation(n, sceneApi), point[1]];
             },
         },
     };
@@ -125,23 +176,26 @@ function fenceTangentPicker(index, side) {
         nodeHeight: (n) => (n.height ?? 1.8) * 0.6,
         onActivate: (node, _scene, editor) => editor.engageTangentMove(node, index, side),
         placement: {
-            position: (n) => {
+            position: (n, sceneApi) => {
                 const point = n.path?.[index] ?? n.start;
+                const baseElevation = fenceBaseElevation(n, sceneApi);
                 if (!n.path)
-                    return [point[0], 0, point[1]];
+                    return [point[0], baseElevation, point[1]];
                 const handle = getFenceControlHandle(n.path, n.tangents, index);
                 return [
                     point[0] + sign * handle.x * TANGENT_HANDLE_ARM_SCALE,
-                    0,
+                    baseElevation,
                     point[1] + sign * handle.y * TANGENT_HANDLE_ARM_SCALE,
                 ];
             },
         },
     };
 }
-const fenceHandles = (node) => {
+const fenceHandles = (node, sceneApi) => {
+    const elevationHandle = fenceElevationHandle(fenceBaseElevation(node, sceneApi));
     if (isSplineFence(node) && node.path) {
         return [
+            elevationHandle,
             fenceHeightHandle(),
             ...node.path.flatMap((_, index) => [
                 fenceControlPointPicker(index),
@@ -153,6 +207,7 @@ const fenceHandles = (node) => {
     return [
         fenceSideMoveHandle('front'),
         fenceSideMoveHandle('back'),
+        elevationHandle,
         fenceHeightHandle(),
         fenceCornerPicker('start'),
         fenceCornerPicker('end'),
@@ -174,7 +229,7 @@ const fenceHandles = (node) => {
 export const fenceDefinition = {
     kind: 'fence',
     snapProfile: 'structural',
-    schemaVersion: 1,
+    schemaVersion: 2,
     schema: FenceNode,
     category: 'structure',
     surfaceRole: 'wall',
@@ -226,8 +281,13 @@ export const fenceDefinition = {
     tool: () => import('./tool'),
     // Stage B: pure geometry function. Generic <GeometrySystem> rebuilds
     // on dirtyNodes; <ParametricNodeRenderer> mounts the empty group.
-    // `renderer` + `system` fields dropped along with their files.
     geometry: buildFenceGeometry,
+    // Dependency tracker only — a hosted railing (`supportSlabId`) renders at
+    // its slab's elevation, so host elevation edits must re-dirty the fence.
+    system: {
+        module: () => import('./system'),
+        priority: 4,
+    },
     // Stage C: floor-plan rendering. FloorplanRegistryLayer iterates kinds
     // with `floorplan` set and renders via FloorplanGeometryRenderer.
     // Legacy `floorplanFenceEntries` short-circuits to [] when fence is

package/dist/fence/floorplan-affordances.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/fence/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,SAAS,EACd,KAAK,mBAAmB,EAQzB,MAAM,kBAAkB,CAAA;AAoFzB;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,EAAE,mBAAmB,CAAC,SAAS,CAsC/D,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,SAAS,CAqCtE,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,SAAS,CAoDjE,CAAA;AAED,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,SAAS,CAkFtE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/fence/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,SAAS,EACd,KAAK,mBAAmB,EASzB,MAAM,kBAAkB,CAAA;AAoFzB;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,EAAE,mBAAmB,CAAC,SAAS,CAsC/D,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,SAAS,CAqCtE,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,SAAS,CAoDjE,CAAA;AAED,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,SAAS,CA4HtE,CAAA"}

package/dist/fence/floorplan-affordances.js

@@ -1,4 +1,4 @@
-import { getMaxWallCurveOffset, getWallChordFrame, normalizeWallCurveOffset, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getMaxWallCurveOffset, getWallChordFrame, normalizeWallCurveOffset, resolveFenceSupportSlabPatch, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { alignFloorplanDraftPoint, getSegmentGridStep, isAlignmentGuideActive, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, isSegmentLongEnough, snapBuildingLocalToWorldGrid, snapFenceDraftPoint, snapScalarToGrid, useAlignmentGuides, } from '@pascal-app/editor';
 /**
  * Floor-plan 2D drag affordances for fence — sister to the 3D
@@ -204,6 +204,9 @@ export const fenceMoveEndpointAffordance = {
         const { walls, fences } = collectLevel(nodes, parentId);
         const linkedOriginals = collectLinkedFences(fences, node.id, originalMovingPoint);
         const affectedIds = [node.id, ...linkedOriginals.map((l) => l.id)];
+        let lastPatches = new Map();
+        let lastStart = originalStart;
+        let lastEnd = originalEnd;
         return {
             affectedIds,
             apply({ planPoint, modifiers }) {
@@ -249,22 +252,56 @@ export const fenceMoveEndpointAffordance = {
                         start: pointsNearlyEqual(l.start, originalMovingPoint) ? aligned : l.start,
                         end: pointsNearlyEqual(l.end, originalMovingPoint) ? aligned : l.end,
                     }));
-                useScene.getState().updateNodes([
-                    { id: node.id, data: { start: nextStart, end: nextEnd } },
-                    ...linkedUpdates.map((u) => ({
-                        id: u.id,
-                        data: { start: u.start, end: u.end },
-                    })),
+                lastStart = nextStart;
+                lastEnd = nextEnd;
+                const nextPatches = new Map([
+                    [node.id, { start: nextStart, end: nextEnd }],
+                    ...linkedUpdates.map((update) => [update.id, { start: update.start, end: update.end }]),
                 ]);
+                // Re-elect the slab lift host as the endpoint drags (uncapped max
+                // election — 2D has no camera ray). Fences run no per-frame
+                // election: `supportSlabId` IS the lift.
+                const patchedNodes = { ...sceneNodes };
+                for (const [id, patch] of nextPatches) {
+                    patchedNodes[id] = { ...patchedNodes[id], ...patch };
+                }
+                for (const id of nextPatches.keys()) {
+                    const fence = patchedNodes[id];
+                    if (fence?.type !== 'fence')
+                        continue;
+                    const patch = resolveFenceSupportSlabPatch(fence, patchedNodes);
+                    if (patch.supportSlabId !== fence.supportSlabId) {
+                        nextPatches.set(id, { ...nextPatches.get(id), ...patch });
+                    }
+                }
+                const overrides = useLiveNodeOverrides.getState();
+                const scene = useScene.getState();
+                for (const linked of linkedOriginals) {
+                    if (!nextPatches.has(linked.id)) {
+                        overrides.clear(linked.id);
+                        scene.markDirty(linked.id);
+                    }
+                }
+                for (const [id, patch] of nextPatches) {
+                    overrides.set(id, patch);
+                    scene.markDirty(id);
+                }
+                lastPatches = nextPatches;
             },
             canCommit() {
                 // Pointer-up always runs canCommit — drop the alignment guide here
                 // so it doesn't linger after a commit / reject.
                 useAlignmentGuides.getState().clear();
-                const finalFence = useScene.getState().nodes[node.id];
-                return (!!finalFence &&
-                    finalFence.type === 'fence' &&
-                    isSegmentLongEnough(finalFence.start, finalFence.end));
+                return isSegmentLongEnough(lastStart, lastEnd);
+            },
+            commit() {
+                useScene.getState().updateNodes(Array.from(lastPatches, ([id, data]) => ({
+                    id,
+                    data,
+                })));
+                const overrides = useLiveNodeOverrides.getState();
+                for (const id of affectedIds)
+                    overrides.clear(id);
             },
         };
     },

package/dist/fence/floorplan-move.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/fence/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,mBAAmB,EAIzB,MAAM,kBAAkB,CAAA;AAuDzB;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,SAAS,CAiJnE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/fence/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,mBAAmB,EAKzB,MAAM,kBAAkB,CAAA;AAuDzB;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,SAAS,CA4LnE,CAAA"}

package/dist/fence/floorplan-move.js

@@ -1,4 +1,4 @@
-import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { resolveFenceSupportSlabPatch, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { getSegmentGridStep, isGridSnapActive, isSegmentLongEnough, snapPointToGrid, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 function pointsEqual(a, b) {
@@ -125,6 +125,27 @@ export const fenceFloorplanMoveTarget = ({ node }) => {
             // tracked change. Drop the override AFTER the scene write so
             // mid-commit reads still see the new position (override wins until
             // cleared; scene wins after).
+            // The re-elected slab lift host rides in the same write (uncapped max
+            // election — 2D has no camera ray): a fence moved onto / off an
+            // elevated deck must land on the right surface, since fences run no
+            // per-frame election (`supportSlabId` IS the lift). One updateNodes
+            // keeps the whole move a single tracked change. Election runs on the
+            // committed endpoints against the pre-write store (the patch only
+            // reads the parent level + the slab grid).
+            const baselineNodes = useScene.getState().nodes;
+            const supportFor = (start, end, path, id) => {
+                const fence = baselineNodes[id];
+                return fence?.type === 'fence'
+                    ? resolveFenceSupportSlabPatch({
+                        start,
+                        end,
+                        path,
+                        curveOffset: fence.curveOffset,
+                        thickness: fence.thickness,
+                        parentId: fence.parentId,
+                    }, baselineNodes)
+                    : {};
+            };
             const fenceUpdate = isNew
                 ? {
                     id: fenceId,
@@ -133,9 +154,18 @@ export const fenceFloorplanMoveTarget = ({ node }) => {
                         end: lastNextEnd,
                         path: lastNextPath,
                         metadata: { ...originalMetadata, isNew: false },
+                        ...supportFor(lastNextStart, lastNextEnd, lastNextPath, fenceId),
                     },
                 }
-                : { id: fenceId, data: { start: lastNextStart, end: lastNextEnd, path: lastNextPath } };
+                : {
+                    id: fenceId,
+                    data: {
+                        start: lastNextStart,
+                        end: lastNextEnd,
+                        path: lastNextPath,
+                        ...supportFor(lastNextStart, lastNextEnd, lastNextPath, fenceId),
+                    },
+                };
             const linkedUpdates = linkedOriginals.map((l) => ({
                 id: l.id,
                 ...projectLinked(l, lastNextStart, lastNextEnd, lastDelta[0], lastDelta[1]),
@@ -144,7 +174,12 @@ export const fenceFloorplanMoveTarget = ({ node }) => {
                 fenceUpdate,
                 ...linkedUpdates.map((u) => ({
                     id: u.id,
-                    data: { start: u.start, end: u.end, path: u.path },
+                    data: {
+                        start: u.start,
+                        end: u.end,
+                        path: u.path,
+                        ...supportFor(u.start, u.end, u.path, u.id),
+                    },
                 })),
             ]);
             const overrides = useLiveNodeOverrides.getState();

package/dist/fence/geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/fence/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAA0B,MAAM,kBAAkB,CAAA;AAC/E,OAAO,EAEL,KAAK,WAAW,EAKhB,KAAK,aAAa,EAGnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAa,KAAK,EAAqC,MAAM,OAAO,CAAA;AAC3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAwFzC,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,SAAS,EACf,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,KAAK,CAwBP"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/fence/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,eAAe,EAA0B,MAAM,kBAAkB,CAAA;AAC/F,OAAO,EAEL,KAAK,WAAW,EAKhB,KAAK,aAAa,EAGnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAa,KAAK,EAAqC,MAAM,OAAO,CAAA;AAE3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAwFzC,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,SAAS,EACf,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,KAAK,CA0CP"}

package/dist/fence/geometry.js

@@ -1,6 +1,7 @@
 import { getMaterialPresetByRef } from '@pascal-app/core';
 import { applyMaterialPresetToMaterials, createDefaultMaterial, createMaterial, createSurfaceRoleMaterial, generateFenceSlotGeometries, resolveMaterialRef, resolveSlotDefaultMaterial, } from '@pascal-app/viewer';
 import { FrontSide, Group, Mesh } from 'three';
+import { resolveFenceLiftElevation } from './lift';
 import { FENCE_SLOT_DEFAULTS } from './slots';
 const FENCE_SLOT_ORDER = ['posts', 'infill', 'base', 'rail'];
 const fenceMaterialCache = new Map();
@@ -50,6 +51,19 @@ function getLegacyFenceMaterial(node, shading) {
 export function buildFenceGeometry(node, ctx, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme) {
     const group = new Group();
     const geometries = generateFenceSlotGeometries(node);
+    // A hosted railing (`supportSlabId`) stands on its slab's walking surface;
+    // an unhosted one stands on the ground, which `ctx.levelBaseAt` resolves at
+    // the fence's own start point — the anchor its plan geometry is measured
+    // from, so the resolver and the mesh cannot disagree about where the ground
+    // is under this fence. The builder emits local-space children, so the lift
+    // lives on an inner group rather than the registered (React-transformed)
+    // root.
+    const lift = ctx
+        ? resolveFenceLiftElevation(node, (id) => ctx.resolve(id), ctx.levelBaseAt?.(node.start[0], node.start[1]) ?? 0)
+        : 0;
+    const meshParent = new Group();
+    meshParent.position.y = lift;
+    group.add(meshParent);
     for (const slotId of FENCE_SLOT_ORDER) {
         const geometry = geometries[slotId];
         if (geometry.getAttribute('position') === undefined)
@@ -59,7 +73,7 @@ export function buildFenceGeometry(node, ctx, shading = 'rendered', textures = t
         mesh.castShadow = true;
         mesh.receiveShadow = true;
         mesh.userData.slotId = slotId;
-        group.add(mesh);
+        meshParent.add(mesh);
     }
     return group;
 }

package/dist/fence/lift.d.ts

@@ -0,0 +1,38 @@
+import { type AnyNode } from '@pascal-app/core';
+import type { FenceNode } from './schema';
+/**
+ * Elevation (meters above the level plane) a hosted fence stands at.
+ *
+ * A fence carrying `supportSlabId` is a railing on that slab's walking
+ * surface (drawn onto a deck, or placed by a deck preset). The
+ * host pins the lift only while it still exists as a slab on the fence's
+ * own level — a stale host (deleted slab, reparented fence) silently
+ * falls back to the level floor, mirroring the read-path rules of the
+ * other `supportSlabId` carriers. Pure so it is unit-testable and
+ * callable from the geometry builder with `ctx.resolve`.
+ *
+ * `levelBase` is what "the level floor" means here — the sculpted ground
+ * under the fence (`levelBaseElevationAt`, reached through `ctx.levelBaseAt`
+ * in the builder and {@link resolveFenceLiftElevationForNodes} everywhere
+ * else), or 0 for a level with no terrain under it. A caller-resolved scalar
+ * rather than a terrain lookup inside, so this stays pure and the sample stays
+ * at the caller's chosen point; it substitutes for the literal `0` this used to
+ * return in every unhosted branch, and nowhere else — a host slab that still
+ * exists wins outright, so a railing on a deck pad keeps the pad's elevation
+ * instead of following the hillside around it.
+ */
+export declare function resolveFenceLiftElevation(node: Pick<FenceNode, 'supportSlabId' | 'supportOffset' | 'parentId'>, resolve: (id: string) => AnyNode | undefined, levelBase?: number): number;
+/**
+ * {@link resolveFenceLiftElevation} against a nodes record, with the level base
+ * resolved from the terrain under the fence's start point — the same anchor the
+ * geometry builder samples, so a handle, a snap guide and the rendered rail all
+ * agree about where the ground is.
+ *
+ * Exists so the callers that already hold the whole scene (handles via
+ * `sceneApi.nodes()`, the dependency tracker, the editor's elevation guides)
+ * don't each re-derive the level walk and the sample point. The builder keeps
+ * using the pure form, since `GeometryContext` deliberately exposes the ground
+ * as a closure rather than the store.
+ */
+export declare function resolveFenceLiftElevationForNodes(node: Pick<FenceNode, 'id' | 'start' | 'supportSlabId' | 'supportOffset' | 'parentId'>, nodes: Record<string, AnyNode>): number;
+//# sourceMappingURL=lift.d.ts.map

package/dist/fence/lift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lift.d.ts","sourceRoot":"","sources":["../../src/fence/lift.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAKb,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,eAAe,GAAG,eAAe,GAAG,UAAU,CAAC,EACrE,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,GAAG,SAAS,EAC5C,SAAS,SAAI,GACZ,MAAM,CAQR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,GAAG,OAAO,GAAG,eAAe,GAAG,eAAe,GAAG,UAAU,CAAC,EACtF,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,CAIR"}

package/dist/fence/lift.js

@@ -0,0 +1,51 @@
+import { findLevelAncestorId, levelBaseElevationAt, } from '@pascal-app/core';
+/**
+ * Elevation (meters above the level plane) a hosted fence stands at.
+ *
+ * A fence carrying `supportSlabId` is a railing on that slab's walking
+ * surface (drawn onto a deck, or placed by a deck preset). The
+ * host pins the lift only while it still exists as a slab on the fence's
+ * own level — a stale host (deleted slab, reparented fence) silently
+ * falls back to the level floor, mirroring the read-path rules of the
+ * other `supportSlabId` carriers. Pure so it is unit-testable and
+ * callable from the geometry builder with `ctx.resolve`.
+ *
+ * `levelBase` is what "the level floor" means here — the sculpted ground
+ * under the fence (`levelBaseElevationAt`, reached through `ctx.levelBaseAt`
+ * in the builder and {@link resolveFenceLiftElevationForNodes} everywhere
+ * else), or 0 for a level with no terrain under it. A caller-resolved scalar
+ * rather than a terrain lookup inside, so this stays pure and the sample stays
+ * at the caller's chosen point; it substitutes for the literal `0` this used to
+ * return in every unhosted branch, and nowhere else — a host slab that still
+ * exists wins outright, so a railing on a deck pad keeps the pad's elevation
+ * instead of following the hillside around it.
+ */
+export function resolveFenceLiftElevation(node, resolve, levelBase = 0) {
+    const offset = node.supportOffset ?? 0;
+    if (!node.supportSlabId)
+        return levelBase + offset;
+    const host = resolve(node.supportSlabId);
+    if (host?.type !== 'slab')
+        return levelBase + offset;
+    if ((host.parentId ?? null) !== (node.parentId ?? null))
+        return levelBase + offset;
+    const elevation = host.elevation;
+    return (Number.isFinite(elevation) ? elevation : 0) + offset;
+}
+/**
+ * {@link resolveFenceLiftElevation} against a nodes record, with the level base
+ * resolved from the terrain under the fence's start point — the same anchor the
+ * geometry builder samples, so a handle, a snap guide and the rendered rail all
+ * agree about where the ground is.
+ *
+ * Exists so the callers that already hold the whole scene (handles via
+ * `sceneApi.nodes()`, the dependency tracker, the editor's elevation guides)
+ * don't each re-derive the level walk and the sample point. The builder keeps
+ * using the pure form, since `GeometryContext` deliberately exposes the ground
+ * as a closure rather than the store.
+ */
+export function resolveFenceLiftElevationForNodes(node, nodes) {
+    const levelId = findLevelAncestorId(node.id, nodes);
+    const levelBase = levelId ? levelBaseElevationAt(nodes, levelId, node.start[0], node.start[1]) : 0;
+    return resolveFenceLiftElevation(node, (id) => nodes[id], levelBase);
+}

package/dist/fence/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAUf,MAAM,kBAAkB,CAAA;AAsHzB,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAwQvD,CAAA;AAED,eAAe,aAAa,CAAA"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAWf,MAAM,kBAAkB,CAAA;AAsHzB,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAgSvD,CAAA;AAED,eAAe,aAAa,CAAA"}

package/dist/fence/move-tool.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { constrainWallMoveDeltaToAxis, emitter, getPerpendicularWallMoveAxis, isCurvedWall, isSplineFence, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { constrainWallMoveDeltaToAxis, emitter, getPerpendicularWallMoveAxis, isCurvedWall, isSplineFence, resolveFenceSupportSlabPatch, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { CursorSphere, consumePlacementDragRelease, getSegmentGridStep, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, snapFenceDraftPoint, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useCallback, useEffect, useRef, useState } from 'react';
@@ -132,10 +132,30 @@ export const MoveFenceTool = ({ node }) => {
             }
         };
         const applyCommittedUpdates = (updates) => {
-            useScene.getState().updateNodes(updates.map((entry) => ({
-                id: entry.id,
-                data: { start: entry.start, end: entry.end, path: entry.path },
-            })));
+            // Fold the re-elected slab lift host into the same write — a fence
+            // moved onto / off an elevated deck must land on the right surface
+            // (fences run no per-frame election; `supportSlabId` IS the lift),
+            // and one updateNodes keeps the whole move a single undo step.
+            // Election runs on the committed endpoints against the pre-write
+            // store (the patch only reads the parent level + the slab grid).
+            const baselineNodes = useScene.getState().nodes;
+            useScene.getState().updateNodes(updates.map((entry) => {
+                const fence = baselineNodes[entry.id];
+                const support = fence?.type === 'fence'
+                    ? resolveFenceSupportSlabPatch({
+                        start: entry.start,
+                        end: entry.end,
+                        path: entry.path,
+                        curveOffset: fence.curveOffset,
+                        thickness: fence.thickness,
+                        parentId: fence.parentId,
+                    }, baselineNodes)
+                    : {};
+                return {
+                    id: entry.id,
+                    data: { start: entry.start, end: entry.end, path: entry.path, ...support },
+                };
+            }));
             for (const entry of updates) {
                 useScene.getState().markDirty(entry.id);
             }

package/dist/fence/system.d.ts

@@ -0,0 +1,3 @@
+declare const FenceSystems: () => null;
+export default FenceSystems;
+//# sourceMappingURL=system.d.ts.map

package/dist/fence/system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/fence/system.tsx"],"names":[],"mappings":"AAiCA,QAAA,MAAM,YAAY,YAgBjB,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/fence/system.js

@@ -0,0 +1,46 @@
+'use client';
+import { useScene } from '@pascal-app/core';
+import { useEffect } from 'react';
+import { resolveFenceLiftElevationForNodes } from './lift';
+/**
+ * Hosted-railing dependency tracker. A fence with `supportSlabId` renders at
+ * its host slab's elevation, but a store update only dirties the node that
+ * changed — editing the slab's elevation (or restoring a deleted host) would
+ * leave the railing floating at the stale height. Watch each hosted fence's
+ * resolved lift and dirty the fence when it moves; `GeometrySystem` rebuilds
+ * through `def.geometry` as usual. (Deleting the host needs no help here:
+ * `deleteNodesAction` strips `supportSlabId` and dirties the fence itself.)
+ */
+function fenceLiftSignatures(nodes) {
+    const signatures = new Map();
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'fence')
+            continue;
+        const fence = node;
+        // Unhosted fences are covered too, and by a different mechanism: their lift
+        // is the ground, which only a sculpt moves, and `markTerrainSupportDependents`
+        // dirties them from the terrain change itself. Tracking them here would
+        // resolve every fence in the scene on every store update to catch an event
+        // this subscription never sees.
+        if (!fence.supportSlabId)
+            continue;
+        signatures.set(fence.id, resolveFenceLiftElevationForNodes(fence, nodes));
+    }
+    return signatures;
+}
+const FenceSystems = () => {
+    useEffect(() => {
+        let previous = fenceLiftSignatures(useScene.getState().nodes);
+        return useScene.subscribe((state) => {
+            const current = fenceLiftSignatures(state.nodes);
+            for (const [fenceId, lift] of current.entries()) {
+                if (previous.get(fenceId) !== lift) {
+                    state.markDirty(fenceId);
+                }
+            }
+            previous = current;
+        });
+    }, []);
+    return null;
+};
+export default FenceSystems;

package/dist/fence/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/fence/tool.tsx"],"names":[],"mappings":"AAqbA,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,EAM7B,CAAA;AA+cD,eAAe,SAAS,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/fence/tool.tsx"],"names":[],"mappings":"AAycA,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,EAM7B,CAAA;AAweD,eAAe,SAAS,CAAA"}