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

package/dist/slab/panel.js

@@ -1,10 +1,11 @@
 'use client';
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useScene } from '@pascal-app/core';
-import { ActionButton, ActionGroup, holeEditScope, PanelSection, PanelWrapper, SliderControl, triggerSFX, useEditingHole, useEditor, useInteractionScope, } from '@pascal-app/editor';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { MIN_SLAB_THICKNESS, useScene } from '@pascal-app/core';
+import { ActionButton, ActionGroup, holeEditScope, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useEditingHole, useEditor, useInteractionScope, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Edit, Move, Plus, Trash2 } from 'lucide-react';
 import { useCallback, useEffect, useRef } from 'react';
+import { applySlabAnchorElevationChange, applySlabElevationPreset, applySlabRecessDepthChange, applySlabThicknessChange, applySlabTopChange, clampSlabElevation, getSlabAnchorElevation, getSlabBaseElevation, getSlabRecessDepth, } from './elevation-limit';
 /**
  * Phase 5 Stage E — slab inspector (kind-owned).
  *
@@ -18,6 +19,7 @@ import { useCallback, useEffect, useRef } from 'react';
  */
 export function SlabPanel() {
     const selectedId = useViewer((s) => s.selection.selectedIds[0]);
+    const unit = useViewer((s) => s.unit);
     const setSelection = useViewer((s) => s.setSelection);
     const editingHole = useEditingHole();
     const setMovingNode = useEditor((s) => s.setMovingNode);
@@ -32,6 +34,64 @@ export function SlabPanel() {
             return;
         useScene.getState().updateNode(selectedId, updates);
     }, [selectedId]);
+    const handleElevationChange = useCallback((proposed) => {
+        const current = nodeRef.current;
+        if (!current)
+            return;
+        const { elevation } = clampSlabElevation(useScene.getState().nodes, current, proposed);
+        handleUpdate(applySlabTopChange(current, elevation));
+    }, [handleUpdate]);
+    const handleThicknessChange = useCallback((proposed) => {
+        const current = nodeRef.current;
+        if (!current)
+            return;
+        const base = getSlabBaseElevation(current);
+        const requested = applySlabThicknessChange(current, proposed);
+        const clamped = clampSlabElevation(useScene.getState().nodes, current, requested.elevation);
+        handleUpdate(applySlabThicknessChange(current, Math.max(MIN_SLAB_THICKNESS, clamped.elevation - base)));
+    }, [handleUpdate]);
+    const handleAnchorChange = useCallback((proposed) => {
+        const current = nodeRef.current;
+        if (!current)
+            return;
+        const patch = applySlabAnchorElevationChange(current, proposed);
+        const requestedTop = patch.elevation ?? current.elevation;
+        const { elevation } = clampSlabElevation(useScene.getState().nodes, current, requestedTop);
+        if (current.recessed) {
+            const delta = elevation - requestedTop;
+            handleUpdate({
+                ...patch,
+                elevation,
+                recessedRimElevation: (patch.recessedRimElevation ?? proposed) + delta,
+            });
+            return;
+        }
+        handleUpdate(applySlabAnchorElevationChange(current, elevation - current.thickness));
+    }, [handleUpdate]);
+    const handleRecessDepthChange = useCallback((proposed) => {
+        const current = nodeRef.current;
+        if (!current?.recessed)
+            return;
+        handleUpdate(applySlabRecessDepthChange(current, proposed));
+    }, [handleUpdate]);
+    const handleElevationPreset = useCallback((signedDepth) => {
+        const current = nodeRef.current;
+        if (!current)
+            return;
+        const anchor = getSlabAnchorElevation(current);
+        const requested = applySlabElevationPreset(current, signedDepth);
+        if (requested.recessed) {
+            handleUpdate(requested);
+            return;
+        }
+        const requestedTop = requested.elevation ?? current.elevation;
+        const { elevation } = clampSlabElevation(useScene.getState().nodes, current, requestedTop);
+        const thickness = Math.max(MIN_SLAB_THICKNESS, elevation - anchor);
+        handleUpdate({ ...requested, elevation: anchor + thickness, thickness });
+    }, [handleUpdate]);
+    const handleTerrainModeChange = useCallback((mode) => {
+        handleUpdate({ fillToTerrain: mode === 'terrain' ? true : undefined });
+    }, [handleUpdate]);
     const handleClose = useCallback(() => {
         setSelection({ selectedIds: [] });
         useInteractionScope
@@ -128,7 +188,25 @@ export function SlabPanel() {
         return Math.abs(area) / 2;
     };
     const area = calculateArea(node.polygon);
-    return (_jsxs(PanelWrapper, { icon: "/icons/floor.webp", onClose: handleClose, title: node.name || 'Slab', width: 320, children: [_jsxs(PanelSection, { title: "Elevation", children: [_jsx(SliderControl, { label: "Height", max: 1, min: -1, onChange: (v) => handleUpdate({ elevation: v }), precision: 3, step: 0.01, unit: "m", value: Math.round(node.elevation * 1000) / 1000 }), _jsxs("div", { className: "mt-2 grid grid-cols-2 gap-1.5 px-1 pb-1", children: [_jsx(ActionButton, { label: "Sunken (-15cm)", onClick: () => handleUpdate({ elevation: -0.15 }) }), _jsx(ActionButton, { label: "Ground (0m)", onClick: () => handleUpdate({ elevation: 0 }) }), _jsx(ActionButton, { label: "Raised (+5cm)", onClick: () => handleUpdate({ elevation: 0.05 }) }), _jsx(ActionButton, { label: "Step (+15cm)", onClick: () => handleUpdate({ elevation: 0.15 }) })] })] }), _jsx(PanelSection, { title: "Info", children: _jsxs("div", { className: "flex items-center justify-between px-2 py-1 text-muted-foreground text-sm", children: [_jsx("span", { children: "Area" }), _jsxs("span", { className: "font-mono text-white", children: [area.toFixed(2), " m\u00B2"] })] }) }), _jsxs(PanelSection, { title: "Holes", children: [node.holes && node.holes.length > 0 ? (_jsx("div", { className: "flex flex-col gap-1 pb-2", children: node.holes.map((hole, index) => {
+    // Clean preset values per display system; imperial stores exact meters
+    // for whole-inch offsets.
+    const elevationPresets = unit === 'imperial'
+        ? [
+            { label: 'Sunken (6")', elevation: -0.1524 },
+            { label: 'Thin (1")', elevation: 0.0254 },
+            { label: 'Standard (2")', elevation: 0.0508 },
+            { label: 'Thick (6")', elevation: 0.1524 },
+        ]
+        : [
+            { label: 'Sunken (15cm)', elevation: -0.15 },
+            { label: 'Thin (2cm)', elevation: 0.02 },
+            { label: 'Standard (5cm)', elevation: 0.05 },
+            { label: 'Thick (15cm)', elevation: 0.15 },
+        ];
+    return (_jsxs(PanelWrapper, { icon: "/icons/floor.webp", onClose: handleClose, title: node.name || 'Slab', width: 320, children: [_jsxs(PanelSection, { title: "Elevation", children: [_jsx(SliderControl, { label: node.recessed ? 'Floor' : 'Surface', max: 6, min: -3, onChange: handleElevationChange, precision: 3, step: 0.01, unit: "m", value: Math.round(node.elevation * 1000) / 1000 }), _jsx(SliderControl, { label: node.recessed ? 'Rim' : 'Base', max: 6, min: -3, onChange: handleAnchorChange, precision: 3, step: 0.01, unit: "m", value: Math.round(getSlabAnchorElevation(node) * 1000) / 1000 }), node.recessed ? (_jsx(SliderControl, { label: "Depth", max: 2, min: MIN_SLAB_THICKNESS, onChange: handleRecessDepthChange, precision: 2, step: 0.01, unit: "m", value: Math.round(getSlabRecessDepth(node) * 100) / 100 })) : (_jsx(SliderControl, { label: "Thickness", max: 0.5, min: MIN_SLAB_THICKNESS, onChange: handleThicknessChange, precision: 2, step: 0.01, unit: "m", value: Math.round((node.thickness ?? 0.05) * 100) / 100 })), !node.recessed && (_jsxs(_Fragment, { children: [_jsx("div", { className: "px-1 font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: "Foundation" }), _jsx(SegmentedControl, { onChange: handleTerrainModeChange, options: [
+                                    { label: 'Fixed', value: 'fixed' },
+                                    { label: 'Follows terrain', value: 'terrain' },
+                                ], value: node.fillToTerrain ? 'terrain' : 'fixed' }), node.fillToTerrain && (_jsx("div", { className: "px-1 text-[11px] text-muted-foreground", children: "Extends the perimeter down to terrain. The flat surface, base, and thickness stay unchanged." }))] })), _jsx("div", { className: "mt-2 grid grid-cols-2 gap-1.5 px-1 pb-1", children: elevationPresets.map((preset) => (_jsx(ActionButton, { label: preset.label, onClick: () => handleElevationPreset(preset.elevation) }, preset.label))) })] }), _jsx(PanelSection, { title: "Info", children: _jsxs("div", { className: "flex items-center justify-between px-2 py-1 text-muted-foreground text-sm", children: [_jsx("span", { children: "Area" }), _jsxs("span", { className: "font-mono text-white", children: [area.toFixed(2), " m\u00B2"] })] }) }), _jsxs(PanelSection, { title: "Holes", children: [node.holes && node.holes.length > 0 ? (_jsx("div", { className: "flex flex-col gap-1 pb-2", children: node.holes.map((hole, index) => {
                             const holeArea = calculateArea(hole);
                             const isEditing = editingHole?.nodeId === selectedId && editingHole?.holeIndex === index;
                             const source = node.holeMetadata?.[index]?.source ?? 'manual';

package/dist/slab/parametrics.d.ts

@@ -1,4 +1,4 @@
-import type { ParametricDescriptor } from '@pascal-app/core';
+import { type ParametricDescriptor } from '@pascal-app/core';
 import type { SlabNode } from './schema';
 /**
  * Inspector descriptor for slab.

package/dist/slab/parametrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/slab/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,oBAAoB,CAAC,QAAQ,CAQ1D,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/slab/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAChF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,oBAAoB,CAAC,QAAQ,CAmB1D,CAAA"}

package/dist/slab/parametrics.js

@@ -1,3 +1,4 @@
+import { MIN_SLAB_THICKNESS } from '@pascal-app/core';
 /**
  * Inspector descriptor for slab.
  *
@@ -12,7 +13,18 @@ export const slabParametrics = {
     groups: [
         {
             label: 'Elevation',
-            fields: [{ key: 'elevation', kind: 'number', unit: 'm', min: -1, max: 1, step: 0.01 }],
+            fields: [
+                { key: 'elevation', kind: 'number', unit: 'm', min: -1, max: 1, step: 0.01 },
+                {
+                    key: 'thickness',
+                    kind: 'number',
+                    unit: 'm',
+                    min: MIN_SLAB_THICKNESS,
+                    max: 0.5,
+                    step: 0.01,
+                    visibleIf: (n) => !n.recessed,
+                },
+            ],
         },
     ],
     customPanel: () => import('./panel'),

package/dist/slab/placement-ownership.d.ts

@@ -0,0 +1,3 @@
+export type SlabCompletionTrigger = 'grid' | 'keyboard';
+export declare function shouldRegistryCommitSlab(viewMode: '2d' | '3d' | 'split', trigger: SlabCompletionTrigger): boolean;
+//# sourceMappingURL=placement-ownership.d.ts.map

package/dist/slab/placement-ownership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"placement-ownership.d.ts","sourceRoot":"","sources":["../../src/slab/placement-ownership.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,UAAU,CAAA;AAEvD,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,IAAI,GAAG,IAAI,GAAG,OAAO,EAC/B,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAET"}

package/dist/slab/placement-ownership.js

@@ -0,0 +1,3 @@
+export function shouldRegistryCommitSlab(viewMode, trigger) {
+    return trigger === 'keyboard' || viewMode !== '2d';
+}

package/dist/slab/quick-measurement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quick-measurement.d.ts","sourceRoot":"","sources":["../../src/slab/quick-measurement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAOxE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,sBAAsB,GAAG,IAAI,CAiClF"}
+{"version":3,"file":"quick-measurement.d.ts","sourceRoot":"","sources":["../../src/slab/quick-measurement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAOxE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,sBAAsB,GAAG,IAAI,CAkClF"}

package/dist/slab/quick-measurement.js

@@ -2,11 +2,12 @@ import { polygonBoundaryLength, polygonReportAnchor, polygonSurfaceArea, } from
 export function slabQuickMeasurement(node) {
     if (node.polygon.length < 3)
         return null;
-    const thickness = node.elevation ?? 0.05;
+    const elevation = node.elevation ?? 0.05;
+    const thickness = node.thickness ?? 0.05;
     return {
         title: node.name ?? 'Floor slab',
         kindLabel: 'Floor slab',
-        anchor: polygonReportAnchor(node.polygon, thickness + 0.04),
+        anchor: polygonReportAnchor(node.polygon, elevation + 0.04),
         metrics: [
             {
                 key: 'area',

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

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/slab/system.tsx"],"names":[],"mappings":"AA0DA,QAAA,MAAM,WAAW,YAmBhB,CAAA;AAED,eAAe,WAAW,CAAA"}
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/slab/system.tsx"],"names":[],"mappings":"AAmEA,QAAA,MAAM,WAAW,YAmBhB,CAAA;AAED,eAAe,WAAW,CAAA"}

package/dist/slab/system.js

@@ -6,10 +6,10 @@ import { useEffect } from 'react';
  * context — wall centerlines/thickness (exterior flush offsets) and sibling
  * slab polygons (interior centerline seams) — none of which lives on the slab
  * node itself. Store updates only dirty the node that changed, so a wall
- * thickness edit or a neighbour slab add/remove/reshape would leave stale
- * slab meshes. Watch a per-level signature of those inputs and dirty every
- * slab on a level whose signature moved; `GeometrySystem` then rebuilds
- * them through `def.geometry` as usual.
+ * thickness edit, a neighbour slab add/remove/reshape, or a building transform
+ * would leave stale slab meshes. Watch a per-level signature of those inputs
+ * and dirty every slab on a level whose signature moved; `GeometrySystem` then
+ * rebuilds them through `def.geometry` as usual.
  */
 function levelSlabContextSignatures(nodes) {
     const partsByLevel = new Map();
@@ -35,6 +35,16 @@ function levelSlabContextSignatures(nodes) {
             push(levelId, `s|${slab.id}|${slab.elevation ?? ''}|${slab.polygon.map(([x, z]) => `${x},${z}`).join(';')}`);
         }
     }
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'building')
+            continue;
+        const transform = `${node.position.join(',')}|${node.rotation.join(',')}`;
+        for (const childId of node.children) {
+            const child = nodes[childId];
+            if (child?.type === 'level')
+                push(child.id, `b|${node.id}|${transform}`);
+        }
+    }
     const signatures = new Map();
     for (const [levelId, parts] of partsByLevel.entries()) {
         signatures.set(levelId, parts.sort().join('||'));

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/slab/tool.tsx"],"names":[],"mappings":"AAsDA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EA4O5B,CAAA;AAED,eAAe,QAAQ,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/slab/tool.tsx"],"names":[],"mappings":"AA4EA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EA2T5B,CAAA;AAED,eAAe,QAAQ,CAAA"}

package/dist/slab/tool.js

@@ -1,10 +1,12 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { DEFAULT_ANGLE_STEP, emitter, snapPointAlongAngleRay, snapPointToGrid, useScene, } from '@pascal-app/core';
-import { CursorSphere, clearSlabSnapFeedback, EDITOR_LAYER, isAngleSnapActive, isGridSnapActive, markToolCancelConsumed, resolveSlabPlanPointSnap, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { DEFAULT_ANGLE_STEP, emitter, resolveSlabPlacementElevation, snapPointAlongAngleRay, snapPointToGrid, useScene, } from '@pascal-app/core';
+import { CursorSphere, clearPlacementSurface, clearSlabSnapFeedback, EDITOR_LAYER, isAngleSnapActive, isGridSnapActive, markToolCancelConsumed, publishHorizontalConstructionPlane, publishPlacementSurface, resampleTerrainConstructionPlane, resolveEventConstructionPlane, resolveLevelConstructionPlane, resolvePointerSupportSurface, resolveSlabPlanPointSnap, triggerSFX, useEditor, useFloorplanDraftPreview, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
+import { useThree } from '@react-three/fiber';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { BufferGeometry, DoubleSide, Shape, Vector3 } from 'three';
+import { shouldRegistryCommitSlab } from './placement-ownership';
 import { SlabNode } from './schema';
 /**
  * Phase 5 Stage D — slab placement tool (kind-owned via `def.tool`).
@@ -18,14 +20,20 @@ import { SlabNode } from './schema';
  * single pointer-down → drag-up.
  */
 const Y_OFFSET = 0.02;
-function commitSlabDrawing(levelId, points) {
+const SURFACE_UP = new Vector3(0, 1, 0);
+const surfacePointScratch = new Vector3();
+function commitSlabDrawing(levelId, points, baseElevation) {
     const { createNode, nodes } = useScene.getState();
     const slabCount = Object.values(nodes).filter((n) => n.type === 'slab').length;
     const name = `Slab ${slabCount + 1}`;
     // A placed slab preset seeds `toolDefaults.slab` (thickness, material, …)
     // before the tool activates; the drawn polygon always wins.
     const defaults = useEditor.getState().toolDefaults.slab ?? {};
-    const slab = SlabNode.parse({ ...defaults, name, polygon: points });
+    const authored = SlabNode.parse({ ...defaults, name, polygon: points });
+    const slab = {
+        ...authored,
+        elevation: resolveSlabPlacementElevation(authored, baseElevation),
+    };
     createNode(slab, levelId);
     triggerSFX('sfx:structure-build');
     return slab.id;
@@ -36,33 +44,70 @@ export const SlabTool = () => {
     const closingLineRef = useRef(null);
     const currentLevelId = useViewer((s) => s.selection.levelId);
     const setSelection = useViewer((s) => s.setSelection);
+    const slabDefaults = useEditor((s) => s.toolDefaults.slab);
+    const isRecessed = slabDefaults?.recessed === true;
+    const camera = useThree((state) => state.camera);
+    const cameraRef = useRef(camera);
+    cameraRef.current = camera;
     const [points, setPoints] = useState([]);
     const [cursorPosition, setCursorPosition] = useState([0, 0]);
     const [snappedCursorPosition, setSnappedCursorPosition] = useState([0, 0]);
     const [levelY, setLevelY] = useState(0);
     const previousSnappedPointRef = useRef(null);
+    const constructionPlaneRef = useRef(null);
     // Clear preset-seeded defaults on deactivation so a later manual slab draw
     // isn't built with a stale preset's parameters. Unmount-only.
     useEffect(() => () => useEditor.getState().setToolDefaults('slab', null), []);
-    useEffect(() => () => clearSlabSnapFeedback(), []);
+    useEffect(() => () => {
+        clearSlabSnapFeedback();
+        clearPlacementSurface();
+    }, []);
     // Publish the live vertex count so the HUD shows "Finish" only at ≥ 3 points.
     useEffect(() => {
         useEditor.getState().setDraftVertexCount(points.length);
     }, [points.length]);
     useEffect(() => () => useEditor.getState().setDraftVertexCount(0), []);
+    useEffect(() => {
+        useFloorplanDraftPreview.getState().setPolygonDraft('slab', points);
+    }, [points]);
+    useEffect(() => () => {
+        const draftPreview = useFloorplanDraftPreview.getState();
+        if (draftPreview.polygonDraftType === 'slab') {
+            draftPreview.setPolygonDraft(null, []);
+        }
+        draftPreview.setCursorPoint(null);
+    }, []);
     useEffect(() => {
         if (!currentLevelId)
             return;
+        const pointedSurfaceFor = (event) => event.nativeEvent?.target instanceof HTMLCanvasElement
+            ? resolvePointerSupportSurface(cameraRef.current, event.position)
+            : null;
+        const resetDraft = () => {
+            setPoints([]);
+            constructionPlaneRef.current = null;
+            previousSnappedPointRef.current = null;
+            clearSlabSnapFeedback();
+            clearPlacementSurface();
+        };
         const onGridMove = (event) => {
             if (!cursorRef.current)
                 return;
-            const rawPoint = [event.localPosition[0], event.localPosition[2]];
+            const pointed = points.length === 0 && !isRecessed ? pointedSurfaceFor(event) : null;
+            const plane = constructionPlaneRef.current ?? (isRecessed ? resolveLevelConstructionPlane() : null);
+            if (plane) {
+                publishHorizontalConstructionPlane(event, plane);
+            }
+            else if (pointed) {
+                publishPlacementSurface(surfacePointScratch.set(event.position[0], pointed.worldY, event.position[2]), SURFACE_UP);
+            }
+            const localPosition = pointed?.localPoint ?? event.localPosition;
+            const rawPoint = [localPosition[0], localPosition[2]];
             // Slab drafting is the 'polygon' snap context (grid / lines / off — no
             // angle, no Shift bypass; Shift cycles the mode, Off is the bypass).
             const gridStep = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
             const gridPosition = [...snapPointToGrid(rawPoint, gridStep)];
             setCursorPosition(gridPosition);
-            setLevelY(event.localPosition[1]);
             const lastPoint = points[points.length - 1];
             // Angle lock only when the mode asks for it (polygon never does today, but
             // honour the flag so the behaviour follows the HUD).
@@ -74,6 +119,10 @@ export const SlabTool = () => {
                 fallbackPoint: orthoPoint,
                 levelId: currentLevelId,
             }).point;
+            const hoverPlane = plane ??
+                resampleTerrainConstructionPlane(resolveEventConstructionPlane(event, pointed), displayPoint);
+            setLevelY(hoverPlane.localY);
+            useFloorplanDraftPreview.getState().setCursorPoint(displayPoint);
             setSnappedCursorPosition(displayPoint);
             if (points.length > 0 &&
                 previousSnappedPointRef.current &&
@@ -82,9 +131,9 @@ export const SlabTool = () => {
                 triggerSFX('sfx:grid-snap');
             }
             previousSnappedPointRef.current = displayPoint;
-            cursorRef.current.position.set(displayPoint[0], event.localPosition[1], displayPoint[1]);
+            cursorRef.current.position.set(displayPoint[0], hoverPlane.localY, displayPoint[1]);
         };
-        const onGridClick = (_event) => {
+        const onGridClick = (event) => {
             if (!currentLevelId)
                 return;
             const clickPoint = previousSnappedPointRef.current ?? cursorPosition;
@@ -93,12 +142,21 @@ export const SlabTool = () => {
                 firstPoint &&
                 Math.abs(clickPoint[0] - firstPoint[0]) < 0.25 &&
                 Math.abs(clickPoint[1] - firstPoint[1]) < 0.25) {
-                const slabId = commitSlabDrawing(currentLevelId, points);
-                setSelection({ selectedIds: [slabId] });
-                setPoints([]);
-                clearSlabSnapFeedback();
+                if (shouldRegistryCommitSlab(useEditor.getState().viewMode, 'grid')) {
+                    const slabId = commitSlabDrawing(currentLevelId, points, constructionPlaneRef.current?.elevation ?? null);
+                    setSelection({ selectedIds: [slabId] });
+                }
+                resetDraft();
             }
             else {
+                if (points.length === 0) {
+                    const plane = isRecessed
+                        ? (resolveLevelConstructionPlane() ?? resolveEventConstructionPlane(event, null))
+                        : resampleTerrainConstructionPlane(resolveEventConstructionPlane(event, pointedSurfaceFor(event)), clickPoint);
+                    constructionPlaneRef.current = plane;
+                    setLevelY(plane.localY);
+                    publishHorizontalConstructionPlane(event, plane);
+                }
                 // Every non-closing vertex is a "start" tick; the closing click above
                 // fires the structure-build (end) cue.
                 triggerSFX('sfx:structure-build-start');
@@ -107,27 +165,27 @@ export const SlabTool = () => {
         };
         // Finish the polygon (Enter or double-click): commit once there are enough
         // vertices. Closing near the first vertex (in onGridClick) is the third way.
-        const finishDrawing = () => {
+        const finishDrawing = (trigger) => {
             if (points.length < 3)
                 return;
-            const slabId = commitSlabDrawing(currentLevelId, points);
-            setSelection({ selectedIds: [slabId] });
-            setPoints([]);
-            clearSlabSnapFeedback();
+            if (shouldRegistryCommitSlab(useEditor.getState().viewMode, trigger)) {
+                const slabId = commitSlabDrawing(currentLevelId, points, constructionPlaneRef.current?.elevation ?? null);
+                setSelection({ selectedIds: [slabId] });
+            }
+            resetDraft();
         };
         const onGridDoubleClick = (_event) => {
-            finishDrawing();
+            finishDrawing('grid');
         };
         const onCancel = () => {
             if (points.length > 0)
                 markToolCancelConsumed();
-            setPoints([]);
-            clearSlabSnapFeedback();
+            resetDraft();
         };
         const onKeyDown = (e) => {
             if (e.key === 'Enter') {
                 e.preventDefault();
-                finishDrawing();
+                finishDrawing('keyboard');
             }
         };
         document.addEventListener('keydown', onKeyDown);
@@ -142,7 +200,7 @@ export const SlabTool = () => {
             emitter.off('grid:double-click', onGridDoubleClick);
             emitter.off('tool:cancel', onCancel);
         };
-    }, [currentLevelId, points, cursorPosition, setSelection]);
+    }, [currentLevelId, points, cursorPosition, isRecessed, setSelection]);
     useEffect(() => {
         if (!(mainLineRef.current && closingLineRef.current))
             return;

package/dist/solar-panel/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/solar-panel/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAgNzC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,OAAO,cAAc,CAwDtE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/solar-panel/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAgNzC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,OAAO,cAAc,CAyDtE,CAAA"}

package/dist/solar-panel/definition.js

@@ -239,6 +239,7 @@ export const solarPanelDefinition = {
         kind: 'parametric',
         module: () => import('./renderer'),
     },
+    preview: () => import('./preview'),
     tool: () => import('./tool'),
     affordanceTools: {
         move: () => import('./move-tool'),

package/dist/solar-panel/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/solar-panel/tool.tsx"],"names":[],"mappings":"AA4BA;;;;;;;GAOG;AACH,QAAA,MAAM,cAAc,mCAoInB,CAAA;AAED,eAAe,cAAc,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/solar-panel/tool.tsx"],"names":[],"mappings":"AA4BA;;;;;;;GAOG;AACH,QAAA,MAAM,cAAc,mCAoJnB,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/solar-panel/tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { emitter, SolarPanelNode, sceneRegistry, useScene, } from '@pascal-app/core';
-import { triggerSFX } from '@pascal-app/editor';
+import { triggerSFX, usePlacementPreview } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import * as THREE from 'three';
@@ -67,6 +67,13 @@ const SolarPanelTool = () => {
             setPreviewSurfaceQuat(surfaceQuatFromNormal(normal, new THREE.Quaternion()));
             setPreviewYaw((event.node.rotation ?? 0) + (hit.segment.rotation ?? 0));
             setPreviewPos(worldToBuildingLocal(wx, wy, wz));
+            usePlacementPreview.getState().set(SolarPanelNode.parse({
+                ...previewNode,
+                parentId: hit.segment.id,
+                position: [hit.localX, hit.localY, hit.localZ],
+                roofSegmentId: hit.segment.id,
+                surfaceNormal: [normal.x, normal.y, normal.z],
+            }), hit.segment);
             publishRoofSurfacePlacementGuides({
                 roof: event.node,
                 segment: hit.segment,
@@ -98,6 +105,9 @@ const SolarPanelTool = () => {
             state.dirtyNodes.add(hit.segment.id);
             setSelection({ selectedIds: [panel.id] });
             triggerSFX('sfx:item-place');
+            const placementPreview = usePlacementPreview.getState();
+            if (placementPreview.node?.id === previewNode.id)
+                placementPreview.clear();
             clearRoofSurfacePlacementGuides();
             event.stopPropagation();
         };
@@ -108,12 +118,18 @@ const SolarPanelTool = () => {
             emitter.off('roof:move', updatePreview);
             emitter.off('roof:enter', updatePreview);
             emitter.off('roof:click', onClick);
+            const placementPreview = usePlacementPreview.getState();
+            if (placementPreview.node?.id === previewNode.id)
+                placementPreview.clear();
             clearRoofSurfacePlacementGuides();
         };
     }, [activeBuildingId, setSelection, previewNode]);
     return (_jsxs(_Fragment, { children: [_jsx(RoofAttachmentFallbackPreview, { activeBuildingId: activeBuildingId, ghost: _jsx(SolarPanelPreview, { node: previewNode, invalid: true }), onInvalidTarget: () => {
                     setPreviewPos(null);
                     setPreviewSurfaceQuat(null);
+                    const placementPreview = usePlacementPreview.getState();
+                    if (placementPreview.node?.id === previewNode.id)
+                        placementPreview.clear();
                     clearRoofSurfacePlacementGuides();
                 } }), activeBuildingId && previewPos && previewSurfaceQuat && (_jsx("group", { position: previewPos, children: _jsx("group", { "rotation-y": previewYaw, children: _jsx("group", { quaternion: previewSurfaceQuat, children: _jsx(SolarPanelPreview, { node: previewNode }) }) }) }))] }));
 };

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/spawn/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAKpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA0CpC,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAsE5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/spawn/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAKpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA0CpC,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAuE5D,CAAA"}

package/dist/spawn/definition.js

@@ -92,6 +92,7 @@ export const spawnDefinition = {
     tool: () => import('./tool'),
     toolHints: [
         { key: 'Left click', label: 'Place spawn point' },
+        { key: 'R / T', label: 'Rotate spawn point' },
         { key: 'Esc', label: 'Cancel' },
     ],
     presentation: {

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/spawn/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAA;AAGzB,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CA6BhE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/spawn/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,SAAS,EAGf,MAAM,kBAAkB,CAAA;AAIzB,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CA+BhE,CAAA"}

package/dist/spawn/floorplan-affordances.js

@@ -1,4 +1,5 @@
-import { useScene, } from '@pascal-app/core';
+import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { isAngleSnapActive } from '@pascal-app/editor';
 import { rotateAffordanceDelta } from '../shared/rotate-affordance';
 export const spawnRotateAffordance = {
     start({ node, initialPlanPoint }) {
@@ -10,20 +11,22 @@ export const spawnRotateAffordance = {
         let lastRotation = initialRotation;
         return {
             affectedIds: [spawnId],
-            apply({ planPoint, modifiers }) {
+            apply({ planPoint }) {
                 const delta = rotateAffordanceDelta({
                     center: [cx, cz],
                     initialAngle,
                     planPoint,
-                    free: modifiers.shiftKey,
+                    free: !isAngleSnapActive(),
                 });
                 lastRotation = initialRotation - delta;
-                useScene.getState().updateNode(spawnId, { rotation: lastRotation });
+                useLiveNodeOverrides.getState().set(spawnId, { rotation: lastRotation });
+                useScene.getState().markDirty(spawnId);
             },
             canCommit() {
                 return true;
             },
             commit() {
+                useLiveNodeOverrides.getState().clear(spawnId);
                 useScene.getState().updateNode(spawnId, { rotation: lastRotation });
             },
         };

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/spawn/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAExB,KAAK,SAAS,EAGf,MAAM,kBAAkB,CAAA;AAGzB,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,SAAS,CA4BnE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/spawn/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAExB,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAGzB,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,SAAS,CA8BnE,CAAA"}

package/dist/spawn/floorplan-move.js

@@ -1,5 +1,5 @@
-import { snapScalar, useScene, } from '@pascal-app/core';
-import { getSegmentGridStep } from '@pascal-app/editor';
+import { snapScalar, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getSegmentGridStep, isGridSnapActive } from '@pascal-app/editor';
 export const spawnFloorplanMoveTarget = ({ node }) => {
     const spawnId = node.id;
     const startY = node.position[1];
@@ -7,14 +7,15 @@ export const spawnFloorplanMoveTarget = ({ node }) => {
     let lastPosition = null;
     const session = {
         affectedIds: [spawnId],
-        apply({ planPoint, modifiers }) {
-            const step = getSegmentGridStep();
-            const snap = (value) => (modifiers.shiftKey ? value : snapScalar(value, step));
+        apply({ planPoint }) {
+            const step = isGridSnapActive() ? getSegmentGridStep() : 0;
+            const snap = (value) => (step > 0 ? snapScalar(value, step) : value);
             const next = [snap(planPoint[0]), startY, snap(planPoint[1])];
             if (lastPosition && lastPosition[0] === next[0] && lastPosition[2] === next[2])
                 return;
             lastPosition = next;
-            useScene.getState().updateNodes([{ id: spawnId, data: { position: next } }]);
+            useLiveNodeOverrides.getState().set(spawnId, { position: next });
+            useScene.getState().markDirty(spawnId);
         },
         canCommit() {
             if (!lastPosition)
@@ -24,6 +25,7 @@ export const spawnFloorplanMoveTarget = ({ node }) => {
         commit() {
             if (!lastPosition)
                 return;
+            useLiveNodeOverrides.getState().clear(spawnId);
             useScene.getState().updateNodes([{ id: spawnId, data: { position: lastPosition } }]);
         },
     };

package/dist/spawn/renderer.d.ts

@@ -1,4 +1,8 @@
 import { type SpawnNode } from '@pascal-app/core';
+export declare const SpawnPreview: ({ layers, node }: {
+    layers?: number;
+    node: SpawnNode;
+}) => import("react").JSX.Element;
 /**
  * Registry-driven spawn renderer. Behaviorally identical to the legacy
  * `@pascal-app/viewer/components/renderers/spawn/spawn-renderer.tsx` — same

package/dist/spawn/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/spawn/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAOzB;;;;;;;;;GASG;AACH,QAAA,MAAM,aAAa,GAAI,UAAU;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,gCAkEnD,CAAA;AAED,eAAe,aAAa,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/spawn/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAoGzB,eAAO,MAAM,YAAY,GAAI,kBAAkB;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,SAAS,CAAA;CAAE,gCAElF,CAAA;AAED;;;;;;;;;GASG;AACH,QAAA,MAAM,aAAa,GAAI,UAAU;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,gCAsBnD,CAAA;AAED,eAAe,aAAa,CAAA"}