@pascal-app/nodes 1.0.0-beta.4 → 1.0.0

package/dist/eyebrow-vent/renderer.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
-import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, resolveMaterialRef, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef } from 'react';
 import * as THREE from 'three';
 import { getAnalyticalNormal, surfaceQuatFromNormal } from '../shared/roof-surface';
@@ -26,6 +26,7 @@ const EyebrowVentRenderer = ({ node: storeNode }) => {
     const textures = useViewer((s) => s.textures);
     const colorPreset = useViewer((s) => s.colorPreset);
     const sceneTheme = useViewer((s) => s.sceneTheme);
+    const sceneMaterials = useScene((s) => s.materials);
     const overrides = useLiveNodeOverrides((s) => s.get(storeNode.id));
     const node = overrides
         ? { ...storeNode, ...overrides }
@@ -43,13 +44,31 @@ const EyebrowVentRenderer = ({ node: storeNode }) => {
         return surfaceQuatFromNormal(normal, new THREE.Quaternion());
     }, [segment, node.position[0], node.position[2]]);
     const material = useMemo(() => {
-        if (!textures || (!node.material && !node.materialPreset)) {
-            return createSurfaceRoleMaterial('roof', colorPreset, THREE.FrontSide, sceneTheme);
-        }
-        return node.material
-            ? createMaterial(node.material, shading)
-            : (createMaterialFromPresetRef(node.materialPreset, shading) ?? defaultMaterial);
-    }, [textures, colorPreset, sceneTheme, shading, node.material, node.materialPreset]);
+        const roleDefault = createSurfaceRoleMaterial('roof', colorPreset, THREE.FrontSide, sceneTheme);
+        const resolve = (role) => {
+            if (!textures)
+                return roleDefault;
+            const slotMaterial = resolveMaterialRef(node.slots?.[role], sceneMaterials, shading);
+            if (slotMaterial)
+                return slotMaterial;
+            if (node.material)
+                return createMaterial(node.material, shading);
+            if (node.materialPreset) {
+                return createMaterialFromPresetRef(node.materialPreset, shading) ?? defaultMaterial;
+            }
+            return roleDefault;
+        };
+        return [resolve('hood'), resolve('front')];
+    }, [
+        textures,
+        colorPreset,
+        sceneTheme,
+        shading,
+        node.slots,
+        node.material,
+        node.materialPreset,
+        sceneMaterials,
+    ]);
     const yAxis = useMemo(() => new THREE.Vector3(0, 1, 0), []);
     const composedQuat = useMemo(() => {
         const yawQuat = new THREE.Quaternion().setFromAxisAngle(yAxis, node.rotation ?? 0);

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

@@ -1 +1 @@
-{"version":3,"file":"curve-tool.d.ts","sourceRoot":"","sources":["../../src/fence/curve-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,SAAS,EAUf,MAAM,kBAAkB,CAAA;AAYzB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAsIxD,CAAA;AAED,eAAe,cAAc,CAAA"}
+{"version":3,"file":"curve-tool.d.ts","sourceRoot":"","sources":["../../src/fence/curve-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAQf,MAAM,kBAAkB,CAAA;AAYzB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAyIxD,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/fence/curve-tool.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { emitter, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallChordFrame, getWallMidpointHandlePoint, normalizeWallCurveOffset, pauseSceneHistory, resumeSceneHistory, useScene, } from '@pascal-app/core';
+import { acquireSceneHistoryPause, emitter, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallChordFrame, getWallMidpointHandlePoint, normalizeWallCurveOffset, useScene, } from '@pascal-app/core';
 import { CursorSphere, getSegmentGridStep, markToolCancelConsumed, snapScalarToGrid, triggerSFX, useInteractionScope, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useCallback, useEffect, useRef, useState } from 'react';
@@ -36,8 +36,8 @@ export const CurveFenceTool = ({ node }) => {
         const originalCurveOffset = originalCurveOffsetRef.current;
         const chord = getWallChordFrame(node);
         const maxCurveOffset = getMaxWallCurveOffset(node);
-        pauseSceneHistory(useScene);
-        let wasCommitted = false;
+        let releaseHistory = acquireSceneHistoryPause(useScene);
+        let wasFinalized = false;
         const applyPreview = (curveOffset) => {
             if (previewOffsetRef.current === curveOffset) {
                 return;
@@ -76,21 +76,23 @@ export const CurveFenceTool = ({ node }) => {
             applyPreview(nextCurveOffset);
         };
         const onGridClick = (event) => {
+            if (wasFinalized)
+                return;
             if (Date.now() - activatedAtRef.current < 150) {
                 event.nativeEvent?.stopPropagation?.();
                 return;
             }
             const curveOffset = previewOffsetRef.current;
-            wasCommitted = true;
+            wasFinalized = true;
             if (curveOffset !== originalCurveOffset) {
                 // Restore original baseline while paused so the next resume+update
                 // registers as a single tracked change (undo reverts to original).
                 useScene.getState().updateNode(nodeId, { curveOffset: originalCurveOffset });
                 useScene.getState().markDirty(nodeId);
-                resumeSceneHistory(useScene);
+                releaseHistory();
                 useScene.getState().updateNode(nodeId, { curveOffset });
                 useScene.getState().markDirty(nodeId);
-                pauseSceneHistory(useScene);
+                releaseHistory = acquireSceneHistoryPause(useScene);
             }
             triggerSFX('sfx:item-place');
             useViewer.getState().setSelection({ selectedIds: [nodeId] });
@@ -98,9 +100,12 @@ export const CurveFenceTool = ({ node }) => {
             event.nativeEvent?.stopPropagation?.();
         };
         const onCancel = () => {
+            if (wasFinalized)
+                return;
             restoreOriginal();
+            wasFinalized = true;
             useViewer.getState().setSelection({ selectedIds: [nodeId] });
-            resumeSceneHistory(useScene);
+            releaseHistory();
             markToolCancelConsumed();
             exitCurveMode();
         };
@@ -108,10 +113,10 @@ export const CurveFenceTool = ({ node }) => {
         emitter.on('grid:click', onGridClick);
         emitter.on('tool:cancel', onCancel);
         return () => {
-            if (!wasCommitted) {
+            if (!wasFinalized) {
                 restoreOriginal();
             }
-            resumeSceneHistory(useScene);
+            releaseHistory();
             emitter.off('grid:move', onGridMove);
             emitter.off('grid:click', onGridClick);
             emitter.off('tool:cancel', onCancel);

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/fence/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AAkBzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAgPpC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAyH5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/fence/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AAmBzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAgPpC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CA0H5D,CAAA"}

package/dist/fence/definition.js

@@ -1,7 +1,7 @@
 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 { fenceControlPointAffordance, fenceCurveAffordance, fenceMoveEndpointAffordance, fenceTangentAffordance, fenceThicknessAffordance, } from './floorplan-affordances';
 import { fenceFloorplanMoveTarget } from './floorplan-move';
 import { buildFenceGeometry } from './geometry';
 import { resolveFenceLiftElevation, resolveFenceLiftElevationForNodes } from './lift';
@@ -305,6 +305,7 @@ export const fenceDefinition = {
         'move-control-point': fenceControlPointAffordance,
         'move-tangent': fenceTangentAffordance,
         curve: fenceCurveAffordance,
+        thickness: fenceThicknessAffordance,
     },
     // Body move on the fence is driven by the two `move-arrow` chevrons
     // the floor-plan builder emits at the midpoint. Pointer-down enters

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

@@ -10,6 +10,7 @@ import { type FenceNode, type FloorplanAffordance } from '@pascal-app/core';
  * both committed on pointer-up).
  */
 export declare const fenceCurveAffordance: FloorplanAffordance<FenceNode>;
+export declare const fenceThicknessAffordance: FloorplanAffordance<FenceNode>;
 /**
  * Spline control-point drag — reshapes one point of the fence `path`. Grid
  * snap follows the active mode; start/end stay pinned to the path ends so endpoint-

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,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"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/fence/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,SAAS,EACd,KAAK,mBAAmB,EAUzB,MAAM,kBAAkB,CAAA;AAsFzB;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,EAAE,mBAAmB,CAAC,SAAS,CAsC/D,CAAA;AAED,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,SAAS,CAgCnE,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, resolveFenceSupportSlabPatch, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getFenceCenterlineFrameAt, 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
@@ -20,6 +20,7 @@ const LINKED_FENCE_ENDPOINT_EPSILON = 0.025;
 // arm is this many times the raw tangent vector, so dividing the dragged
 // offset back out recovers the stored tangent.
 const TANGENT_HANDLE_ARM_SCALE = 3;
+const MIN_FENCE_THICKNESS = 0.03;
 function pointsNearlyEqual(a, b) {
     return (Math.abs(a[0] - b[0]) <= LINKED_FENCE_ENDPOINT_EPSILON &&
         Math.abs(a[1] - b[1]) <= LINKED_FENCE_ENDPOINT_EPSILON);
@@ -94,6 +95,34 @@ export const fenceCurveAffordance = {
         };
     },
 };
+export const fenceThicknessAffordance = {
+    start({ node, payload, initialPlanPoint }) {
+        const { side } = payload;
+        const frame = getFenceCenterlineFrameAt(node, 0.5);
+        const outwardX = frame.normal.x * side;
+        const outwardY = frame.normal.y * side;
+        const initialThickness = node.thickness ?? 0.08;
+        const fenceId = node.id;
+        let lastThickness = initialThickness;
+        return {
+            affectedIds: [fenceId],
+            apply({ planPoint }) {
+                const outwardDelta = (planPoint[0] - initialPlanPoint[0]) * outwardX +
+                    (planPoint[1] - initialPlanPoint[1]) * outwardY;
+                lastThickness = Math.max(MIN_FENCE_THICKNESS, snapScalarToGrid(initialThickness + outwardDelta * 2, getSegmentGridStep()));
+                useLiveNodeOverrides.getState().set(fenceId, { thickness: lastThickness });
+                useScene.getState().markDirty(fenceId);
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene.getState().updateNodes([{ id: fenceId, data: { thickness: lastThickness } }]);
+                useLiveNodeOverrides.getState().clear(fenceId);
+            },
+        };
+    },
+};
 /**
  * Spline control-point drag — reshapes one point of the fence `path`. Grid
  * snap follows the active mode; start/end stay pinned to the path ends so endpoint-

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/fence/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,eAAe,EAQrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAiNzC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,CA0S5F"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/fence/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,eAAe,EAQrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAiNzC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,CAyT5F"}

package/dist/fence/floorplan.js

@@ -386,6 +386,20 @@ export function buildFenceFloorplan(node, ctx) {
                 payload: { fenceId: node.id, endpoint: 'end' },
             });
         }
+        const thicknessFrame = getFenceCenterlineFrameAt(node, 0.5);
+        const halfThickness = (node.thickness ?? 0.08) / 2;
+        for (const side of [1, -1]) {
+            children.push({
+                kind: 'endpoint-handle',
+                point: [
+                    thicknessFrame.point.x + thicknessFrame.normal.x * halfThickness * side,
+                    thicknessFrame.point.y + thicknessFrame.normal.y * halfThickness * side,
+                ],
+                state: 'idle',
+                affordance: 'thickness',
+                payload: { fenceId: node.id, side },
+            });
+        }
         // Two perpendicular `move-arrow` chevrons at the fence midpoint.
         // No `affordance` → the registry layer routes pointer-down through
         // `setMovingNode`, which the `FloorplanRegistryMoveOverlay` picks

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

@@ -1 +1 @@
-{"version":3,"file":"move-control-point-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-control-point-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,SAAS,EAMf,MAAM,kBAAkB,CAAA;AAazB,eAAO,MAAM,yBAAyB,EAAE,KAAK,CAAC,EAAE,CAAC;IAC/C,MAAM,EAAE;QAAE,KAAK,EAAE,SAAS,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;CAC5C,CAoGA,CAAA;AAED,eAAe,yBAAyB,CAAA"}
+{"version":3,"file":"move-control-point-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-control-point-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAazB,eAAO,MAAM,yBAAyB,EAAE,KAAK,CAAC,EAAE,CAAC;IAC/C,MAAM,EAAE;QAAE,KAAK,EAAE,SAAS,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;CAC5C,CAuGA,CAAA;AAED,eAAe,yBAAyB,CAAA"}

package/dist/fence/move-control-point-tool.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { emitter, pauseSceneHistory, resumeSceneHistory, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { acquireSceneHistoryPause, emitter, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { CursorSphere, getSegmentGridStep, isGridSnapActive, markToolCancelConsumed, snapScalarToGrid, triggerSFX, useInteractionScope, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useState } from 'react';
@@ -15,8 +15,8 @@ export const MoveFenceControlPointTool = ({ target }) => {
         originalPoint[1],
     ]);
     useEffect(() => {
-        pauseSceneHistory(useScene);
-        let committed = false;
+        const releaseHistory = acquireSceneHistoryPause(useScene);
+        let finalized = false;
         let lastPoint = [originalPoint[0], originalPoint[1]];
         const buildPatch = (point) => {
             const nextPath = originalPath.map((pathPoint, pathIndex) => pathIndex === index ? point : pathPoint);
@@ -59,8 +59,10 @@ export const MoveFenceControlPointTool = ({ target }) => {
             }
         };
         const onGridClick = (event) => {
-            committed = true;
-            resumeSceneHistory(useScene);
+            if (finalized)
+                return;
+            finalized = true;
+            releaseHistory();
             useScene.getState().updateNode(fenceId, buildPatch(lastPoint));
             useLiveNodeOverrides.getState().clear(fenceId);
             useScene.getState().markDirty(fenceId);
@@ -68,8 +70,11 @@ export const MoveFenceControlPointTool = ({ target }) => {
             event.nativeEvent?.stopPropagation?.();
         };
         const onCancel = () => {
+            if (finalized)
+                return;
             restore();
-            resumeSceneHistory(useScene);
+            finalized = true;
+            releaseHistory();
             markToolCancelConsumed();
             exit(false);
         };
@@ -77,9 +82,9 @@ export const MoveFenceControlPointTool = ({ target }) => {
         emitter.on('grid:click', onGridClick);
         emitter.on('tool:cancel', onCancel);
         return () => {
-            if (!committed) {
+            if (!finalized) {
                 restore();
-                resumeSceneHistory(useScene);
+                releaseHistory();
             }
             emitter.off('grid:move', onGridMove);
             emitter.off('grid:click', onGridClick);

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

@@ -1 +1 @@
-{"version":3,"file":"move-tangent-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-tangent-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,SAAS,EAMf,MAAM,kBAAkB,CAAA;AAezB,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC;IAC1C,MAAM,EAAE;QAAE,KAAK,EAAE,SAAS,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,IAAI,GAAG,KAAK,CAAA;KAAE,CAAA;CAChE,CAqGA,CAAA;AAED,eAAe,oBAAoB,CAAA"}
+{"version":3,"file":"move-tangent-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-tangent-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAezB,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC;IAC1C,MAAM,EAAE;QAAE,KAAK,EAAE,SAAS,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,IAAI,GAAG,KAAK,CAAA;KAAE,CAAA;CAChE,CAwGA,CAAA;AAED,eAAe,oBAAoB,CAAA"}

package/dist/fence/move-tangent-tool.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { emitter, pauseSceneHistory, resumeSceneHistory, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { acquireSceneHistoryPause, emitter, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { CursorSphere, getSegmentGridStep, isGridSnapActive, markToolCancelConsumed, snapScalarToGrid, triggerSFX, useInteractionScope, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useState } from 'react';
@@ -11,8 +11,8 @@ export const MoveFenceTangentTool = ({ target }) => {
     const anchor = target.fence.path?.[index] ?? target.fence.start;
     const [cursor, setCursor] = useState([anchor[0], 0, anchor[1]]);
     useEffect(() => {
-        pauseSceneHistory(useScene);
-        let committed = false;
+        const releaseHistory = acquireSceneHistoryPause(useScene);
+        let finalized = false;
         const originalTangents = (target.fence.tangents ?? []).map((t) => (t ? [t[0], t[1]] : null));
         let lastTangents = originalTangents;
         const writeTangent = (vector) => {
@@ -54,9 +54,11 @@ export const MoveFenceTangentTool = ({ target }) => {
             writeTangent([armX / TANGENT_HANDLE_ARM_SCALE, armZ / TANGENT_HANDLE_ARM_SCALE]);
         };
         const onGridClick = (event) => {
-            committed = true;
+            if (finalized)
+                return;
+            finalized = true;
             const finalTangents = lastTangents;
-            resumeSceneHistory(useScene);
+            releaseHistory();
             useScene.getState().updateNode(fenceId, { tangents: finalTangents });
             useLiveNodeOverrides.getState().clear(fenceId);
             useScene.getState().markDirty(fenceId);
@@ -65,8 +67,11 @@ export const MoveFenceTangentTool = ({ target }) => {
             event.nativeEvent?.stopPropagation?.();
         };
         const onCancel = () => {
+            if (finalized)
+                return;
             restore();
-            resumeSceneHistory(useScene);
+            finalized = true;
+            releaseHistory();
             markToolCancelConsumed();
             exit(false);
         };
@@ -74,9 +79,9 @@ export const MoveFenceTangentTool = ({ target }) => {
         emitter.on('grid:click', onGridClick);
         emitter.on('tool:cancel', onCancel);
         return () => {
-            if (!committed) {
+            if (!finalized) {
                 restore();
-                resumeSceneHistory(useScene);
+                releaseHistory();
             }
             emitter.off('grid:move', onGridMove);
             emitter.off('grid:click', onGridClick);

package/dist/fence/parametrics.js

@@ -49,8 +49,8 @@ export const fenceParametrics = {
                     component: FenceCurveEditor,
                     visibleIf: (n) => !isSplineFence(n),
                 },
-                { key: 'height', kind: 'number', unit: 'm', min: 0.4, max: 4, step: 0.05 },
-                { key: 'thickness', kind: 'number', unit: 'm', min: 0.03, max: 0.5, step: 0.005 },
+                { key: 'height', kind: 'number', unit: 'm', min: 0.4, max: 1000, step: 0.05 },
+                { key: 'thickness', kind: 'number', unit: 'm', min: 0.03, max: 1000, step: 0.005 },
             ],
         },
         {
@@ -58,7 +58,7 @@ export const fenceParametrics = {
             fields: [
                 { key: 'baseHeight', kind: 'number', unit: 'm', min: 0.04, max: 1, step: 0.01 },
                 { key: 'topRailHeight', kind: 'number', unit: 'm', min: 0.01, max: 0.25, step: 0.005 },
-                { key: 'postSpacing', kind: 'number', unit: 'm', min: 0.05, max: 5, step: 0.01 },
+                { key: 'postSpacing', kind: 'number', unit: 'm', min: 0.05, max: 1000, step: 0.01 },
                 { key: 'postSize', kind: 'number', unit: 'm', min: 0.01, max: 0.4, step: 0.005 },
                 {
                     // Dropdown (not segmented) so the inspector renders its "Post Cap"

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/fence/tool.tsx"],"names":[],"mappings":"AA8bA,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,EAM7B,CAAA;AA8gBD,eAAe,SAAS,CAAA"}

package/dist/fence/tool.js

@@ -5,7 +5,7 @@ import { CursorSphere, clearPlacementSurface, createFenceOnCurrentLevel, createS
 import { getSceneTheme, useViewer } from '@pascal-app/viewer';
 import { useThree } from '@react-three/fiber';
 import { useEffect, useMemo, useRef, useState } from 'react';
-import { BoxGeometry, BufferGeometry, DoubleSide, Vector3, } from 'three';
+import { BufferGeometry, DoubleSide, Vector3 } from 'three';
 import { DraftAngleArc, DraftAxisGuides, DraftMeasurementLabel, getNearestAxisAngleLabel, } from '../shared/draft-axis-guides';
 const FENCE_PREVIEW_HEIGHT = 1.8;
 const FENCE_PREVIEW_THICKNESS = 0.08;
@@ -19,7 +19,7 @@ const surfacePointScratch = new Vector3();
 // them; those keep the uncapped max election and leave the grid plane alone.
 function pointedSurfaceFor(camera, event) {
     return event.nativeEvent?.target instanceof HTMLCanvasElement
-        ? resolvePointerSupportSurface(camera, event.position)
+        ? resolvePointerSupportSurface(camera, event.position, { includeNodeTopSurfaces: true })
         : null;
 }
 /** Figma-style alignment-snap threshold (meters), matching the move tools. */
@@ -216,14 +216,14 @@ function getDraftAngleLabels(start, end, segments, baseY, previewHeight, preview
     }
     return labels;
 }
-function getDraftMeasurementState(start, end, segments, unit, baseY, previewHeight, previewThickness) {
+function getDraftMeasurementState(start, end, segments, unit, metricNotation, baseY, previewHeight, previewThickness) {
     const dx = end[0] - start[0];
     const dz = end[1] - start[1];
     const length = Math.hypot(dx, dz);
     if (length < 0.01)
         return null;
     return {
-        lengthLabel: formatLinearMeasurement(length, unit),
+        lengthLabel: formatLinearMeasurement(length, unit, metricNotation),
         lengthPosition: [
             (start[0] + end[0]) / 2,
             baseY + previewHeight + DRAFT_LABEL_Y_OFFSET,
@@ -259,14 +259,10 @@ function updateFencePreview(mesh, start, end, previewHeight, previewThickness) {
     }
     mesh.visible = true;
     direction.normalize();
-    const geometry = new BoxGeometry(length, previewHeight, previewThickness);
     const angle = Math.atan2(direction.z, direction.x);
     mesh.position.set((start.x + end.x) / 2, start.y + previewHeight / 2, (start.z + end.z) / 2);
     mesh.rotation.y = -angle;
-    if (mesh.geometry) {
-        mesh.geometry.dispose();
-    }
-    mesh.geometry = geometry;
+    mesh.scale.set(length, previewHeight, previewThickness);
 }
 function getCurrentLevelElements() {
     const currentLevelId = useViewer.getState().selection.levelId;
@@ -291,6 +287,7 @@ export const FenceTool = () => {
 };
 const StraightFenceTool = () => {
     const unit = useViewer((state) => state.unit);
+    const metricNotation = useViewer((state) => state.metricNotation);
     const isDark = useViewer((state) => getSceneTheme(state.sceneTheme).appearance === 'dark');
     // A placed preset seeds `toolDefaults.fence` before the tool mounts, so
     // the draft preview is drawn at the preset's height / thickness rather
@@ -312,6 +309,7 @@ const StraightFenceTool = () => {
     const previewRef = useRef(null);
     const startingPoint = useRef(new Vector3(0, 0, 0));
     const endingPoint = useRef(new Vector3(0, 0, 0));
+    const constructionSurface = useRef(null);
     const buildingState = useRef(0);
     const [draftMeasurement, setDraftMeasurement] = useState(null);
     const [axisGuide, setAxisGuide] = useState(null);
@@ -351,6 +349,7 @@ const StraightFenceTool = () => {
         };
         const stopDrafting = () => {
             buildingState.current = 0;
+            constructionSurface.current = null;
             previewRef.current.visible = false;
             setDraftMeasurement(null);
             setAxisGuide(null);
@@ -369,11 +368,17 @@ const StraightFenceTool = () => {
             // (`event.localPosition[1]`) sits at the lift the committed fence
             // will get. Aiming past the deck edge drops it back to the floor.
             const pointed = pointedSurfaceFor(cameraRef.current, event);
-            if (pointed) {
-                publishPlacementSurface(surfacePointScratch.set(event.position[0], pointed.worldY, event.position[2]), SURFACE_UP);
+            const activeSurface = constructionSurface.current ?? pointed;
+            if (activeSurface) {
+                publishPlacementSurface(surfacePointScratch.set(event.position[0], activeSurface.worldY, event.position[2]), SURFACE_UP);
             }
+            const activeY = activeSurface?.localPoint?.[1] ?? event.localPosition[1];
             const { walls, fences } = getCurrentLevelElements();
-            const localPoint = [event.localPosition[0], event.localPosition[2]];
+            const pointedLocal = buildingState.current === 0 ? pointed?.localPoint : null;
+            const localPoint = [
+                pointedLocal?.[0] ?? event.localPosition[0],
+                pointedLocal?.[2] ?? event.localPosition[2],
+            ];
             // While drafting, the segment locks to 15° rays from its start.
             // Snapping is governed by the snapping mode (`'off'` is the bypass);
             // there is no Shift hold-to-bypass. Alignment follows the magnetic snap
@@ -388,7 +393,7 @@ const StraightFenceTool = () => {
                     angleSnap: angleLocked,
                     magnetic: isMagneticSnapActive(),
                 }), { applySnap: !angleLocked });
-                endingPoint.current.set(snappedLocal[0], event.localPosition[1], snappedLocal[1]);
+                endingPoint.current.set(snappedLocal[0], activeY, snappedLocal[1]);
                 const draftPreview = useFloorplanDraftPreview.getState();
                 draftPreview.setFenceDraftStart([startingPoint.current.x, startingPoint.current.z]);
                 draftPreview.setFenceDraftEnd(snappedLocal);
@@ -406,7 +411,7 @@ const StraightFenceTool = () => {
                 }
                 previousFenceEnd = currentFenceEnd;
                 updateFencePreview(previewRef.current, startingPoint.current, endingPoint.current, previewHeightRef.current, previewThicknessRef.current);
-                setDraftMeasurement(getDraftMeasurementState([startingPoint.current.x, startingPoint.current.z], snappedLocal, getReferenceSegments(walls, fences), unit, startingPoint.current.y, previewHeightRef.current, previewThicknessRef.current));
+                setDraftMeasurement(getDraftMeasurementState([startingPoint.current.x, startingPoint.current.z], snappedLocal, getReferenceSegments(walls, fences), unit, metricNotation, startingPoint.current.y, previewHeightRef.current, previewThicknessRef.current));
             }
             else {
                 const snappedPoint = alignPoint(snapFenceDraftPoint({
@@ -415,7 +420,7 @@ const StraightFenceTool = () => {
                     fences,
                     magnetic: isMagneticSnapActive(),
                 }));
-                cursorRef.current.position.set(snappedPoint[0], event.localPosition[1], snappedPoint[1]);
+                cursorRef.current.position.set(snappedPoint[0], activeY, snappedPoint[1]);
                 setDraftMeasurement(null);
                 setAxisGuide(null);
             }
@@ -428,6 +433,7 @@ const StraightFenceTool = () => {
                 return;
             }
             const { walls, fences } = getCurrentLevelElements();
+            const pointed = pointedSurfaceFor(cameraRef.current, event);
             const localClick = [event.localPosition[0], event.localPosition[2]];
             if (buildingState.current === 0) {
                 const snappedStart = alignPoint(snapFenceDraftPoint({
@@ -436,7 +442,8 @@ const StraightFenceTool = () => {
                     fences,
                     magnetic: isMagneticSnapActive(),
                 }));
-                startingPoint.current.set(snappedStart[0], event.localPosition[1], snappedStart[1]);
+                startingPoint.current.set(snappedStart[0], pointed?.localPoint?.[1] ?? event.localPosition[1], snappedStart[1]);
+                constructionSurface.current = pointed;
                 endingPoint.current.copy(startingPoint.current);
                 buildingState.current = 1;
                 const draftPreview = useFloorplanDraftPreview.getState();
@@ -466,8 +473,12 @@ const StraightFenceTool = () => {
                 const dz = snappedEnd[1] - startingPoint.current.z;
                 if (dx * dx + dz * dz < 0.01 * 0.01)
                     return;
-                const pointed = pointedSurfaceFor(cameraRef.current, event);
-                const createdFence = createFenceOnCurrentLevel([startingPoint.current.x, startingPoint.current.z], snappedEnd, { supportCap: pointed ? pointed.elevation : null });
+                const pointedSurface = constructionSurface.current ?? pointed;
+                const createdFence = createFenceOnCurrentLevel([startingPoint.current.x, startingPoint.current.z], snappedEnd, {
+                    supportCap: pointedSurface?.elevation ?? null,
+                    preferredSupportSlabId: pointedSurface?.supportSlabId ?? null,
+                    constructionElevation: pointedSurface?.sourceNodeId ? pointedSurface.elevation : null,
+                });
                 if (!createdFence)
                     return;
                 // The new segment is now a real node — make it an alignment target
@@ -485,7 +496,7 @@ const StraightFenceTool = () => {
                 // chains its next segment from the same point (its own snap
                 // pipeline can resolve a slightly different endpoint).
                 useSegmentDraftChain.getState().setChainStart('fence', [nextStart[0], nextStart[1]]);
-                startingPoint.current.set(nextStart[0], event.localPosition[1], nextStart[1]);
+                startingPoint.current.set(nextStart[0], constructionSurface.current?.localPoint?.[1] ?? event.localPosition[1], nextStart[1]);
                 endingPoint.current.copy(startingPoint.current);
                 const draftPreview = useFloorplanDraftPreview.getState();
                 draftPreview.setFenceDraftEnd(null);
@@ -523,8 +534,8 @@ const StraightFenceTool = () => {
             draftPreview.setFenceDraftStart(null);
             draftPreview.setFenceDraftEnd(null);
         };
-    }, [unit]);
-    return (_jsxs("group", { children: [_jsx(DraftAxisGuides, { guide: axisGuide, labelColor: measurementColor, labelShadowColor: measurementShadowColor }), _jsx(CursorSphere, { height: previewHeight, ref: cursorRef }), _jsxs("mesh", { layers: EDITOR_LAYER, ref: previewRef, renderOrder: 1, visible: false, children: [_jsx("shapeGeometry", {}), _jsx("meshBasicMaterial", { color: "#ffffff", depthTest: false, depthWrite: false, opacity: 0.45, side: DoubleSide, transparent: true })] }), draftMeasurement && (_jsxs(_Fragment, { children: [_jsx(DraftMeasurementLabel, { color: measurementColor, label: draftMeasurement.lengthLabel, position: draftMeasurement.lengthPosition, shadowColor: measurementShadowColor }), draftMeasurement.angleLabels.map((angleLabel) => (_jsxs("group", { children: [_jsx(DraftAngleArc, { arc: angleLabel.arc, color: measurementColor }), _jsx(DraftMeasurementLabel, { color: measurementColor, label: angleLabel.label, position: angleLabel.position, shadowColor: measurementShadowColor })] }, angleLabel.id)))] }))] }));
+    }, [unit, metricNotation]);
+    return (_jsxs("group", { children: [_jsx(DraftAxisGuides, { guide: axisGuide, labelColor: measurementColor, labelShadowColor: measurementShadowColor }), _jsx(CursorSphere, { height: previewHeight, ref: cursorRef }), _jsxs("mesh", { layers: EDITOR_LAYER, ref: previewRef, renderOrder: 1, visible: false, children: [_jsx("boxGeometry", {}), _jsx("meshBasicMaterial", { color: "#ffffff", depthTest: false, depthWrite: false, opacity: 0.45, side: DoubleSide, transparent: true })] }), draftMeasurement && (_jsxs(_Fragment, { children: [_jsx(DraftMeasurementLabel, { color: measurementColor, label: draftMeasurement.lengthLabel, position: draftMeasurement.lengthPosition, shadowColor: measurementShadowColor }), draftMeasurement.angleLabels.map((angleLabel) => (_jsxs("group", { children: [_jsx(DraftAngleArc, { arc: angleLabel.arc, color: measurementColor }), _jsx(DraftMeasurementLabel, { color: measurementColor, label: angleLabel.label, position: angleLabel.position, shadowColor: measurementShadowColor })] }, angleLabel.id)))] }))] }));
 };
 const SPLINE_PREVIEW_COLOR = '#8381ed';
 const SPLINE_PREVIEW_SEGMENTS = 40;
@@ -543,7 +554,7 @@ const SplineFenceDraft = () => {
     cameraRef.current = camera;
     // Pointer cap for the commit (Enter / double-click carry no useful grid
     // event of their own) — last resolved on move/click.
-    const supportCapRef = useRef(null);
+    const supportSurfaceRef = useRef(null);
     const draftRef = useRef(draftPoints);
     draftRef.current = draftPoints;
     // Mirror the full transient curve so additional preview surfaces observe
@@ -564,7 +575,11 @@ const SplineFenceDraft = () => {
             const points = draftRef.current;
             if (points.length >= 2) {
                 const created = createSplineFenceOnCurrentLevel(points, undefined, {
-                    supportCap: supportCapRef.current,
+                    supportCap: supportSurfaceRef.current?.elevation ?? null,
+                    preferredSupportSlabId: supportSurfaceRef.current?.supportSlabId ?? null,
+                    constructionElevation: supportSurfaceRef.current?.sourceNodeId
+                        ? supportSurfaceRef.current.elevation
+                        : null,
                 });
                 if (created) {
                     triggerSFX('sfx:item-place');
@@ -581,22 +596,31 @@ const SplineFenceDraft = () => {
         const trackPointedSurface = (event) => {
             const pointed = pointedSurfaceFor(cameraRef.current, event);
             if (!pointed)
-                return;
-            supportCapRef.current = pointed.elevation;
-            publishPlacementSurface(surfacePointScratch.set(event.position[0], pointed.worldY, event.position[2]), SURFACE_UP);
-            setLiftY(event.localPosition[1]);
+                return null;
+            if (draftRef.current.length === 0)
+                supportSurfaceRef.current = pointed;
+            const activeSurface = supportSurfaceRef.current ?? pointed;
+            publishPlacementSurface(surfacePointScratch.set(event.position[0], activeSurface.worldY, event.position[2]), SURFACE_UP);
+            setLiftY(activeSurface.localPoint?.[1] ?? event.localPosition[1]);
+            return pointed;
         };
         const onMove = (event) => {
-            trackPointedSurface(event);
-            setCursor(snapPoint([event.localPosition[0], event.localPosition[2]]));
+            const pointed = trackPointedSurface(event);
+            setCursor(snapPoint([
+                pointed?.localPoint?.[0] ?? event.localPosition[0],
+                pointed?.localPoint?.[2] ?? event.localPosition[2],
+            ]));
         };
         const onClick = (event) => {
-            trackPointedSurface(event);
+            const pointed = trackPointedSurface(event);
             if (event.nativeEvent.detail >= 2) {
                 commit();
                 return;
             }
-            const point = snapPoint([event.localPosition[0], event.localPosition[2]]);
+            const point = snapPoint([
+                pointed?.localPoint?.[0] ?? event.localPosition[0],
+                pointed?.localPoint?.[2] ?? event.localPosition[2],
+            ]);
             triggerSFX('sfx:grid-snap');
             setDraftPoints((prev) => [...prev, point]);
         };