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

package/dist/ceiling/hole-editor.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { resolveLevelId, useLiveNodeOverrides, useScene } from '@pascal-app/core';
+import { resolveCeilingHeight, resolveLevelId, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { PolygonEditor } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useCallback, useEffect } from 'react';
@@ -40,6 +40,6 @@ export const CeilingHoleEditor = ({ ceilingId, holeIndex }) => {
     }, [ceilingId]);
     if (!(ceiling && hole) || hole.length < 3)
         return null;
-    return (_jsx(PolygonEditor, { allowEdgeMove: true, allowPolygonMove: true, color: "#ef4444", levelId: resolveLevelId(ceiling, useScene.getState().nodes), minVertices: 3, onPolygonChange: handlePolygonChange, onPolygonPreview: handlePolygonPreview, polygon: hole, surfaceHeight: ceiling.height ?? 2.5 }));
+    return (_jsx(PolygonEditor, { allowEdgeMove: true, allowPolygonMove: true, color: "#ef4444", levelId: resolveLevelId(ceiling, useScene.getState().nodes), minVertices: 3, onPolygonChange: handlePolygonChange, onPolygonPreview: handlePolygonPreview, polygon: hole, surfaceHeight: resolveCeilingHeight(ceiling, useScene.getState().nodes) }));
 };
 export default CeilingHoleEditor;

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

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/ceiling/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,WAAW,EAUjB,MAAM,kBAAkB,CAAA;AAgFzB,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAuK3D,CAAA;AAiHD,eAAe,eAAe,CAAA"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/ceiling/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,WAAW,EAWjB,MAAM,kBAAkB,CAAA;AAgFzB,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAwK3D,CAAA;AAiHD,eAAe,eAAe,CAAA"}

package/dist/ceiling/move-tool.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { collectAlignmentAnchors, emitter, polygonAnchors, resolveAlignment, sceneRegistry, snapScalar, useLiveTransforms, useScene, } from '@pascal-app/core';
+import { collectAlignmentAnchors, emitter, polygonAnchors, resolveAlignment, resolveCeilingHeight, sceneRegistry, snapScalar, useLiveTransforms, useScene, } from '@pascal-app/core';
 import { CursorSphere, consumePlacementDragRelease, isAlignmentGuideActive, isMagneticSnapActive, markToolCancelConsumed, triggerSFX, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
@@ -65,7 +65,8 @@ export const MoveCeilingTool = ({ node }) => {
     const originalPolygonRef = useRef(node.polygon.map(([x, z]) => [x, z]));
     const originalHolesRef = useRef((node.holes ?? []).map((hole) => hole.map(([x, z]) => [x, z])));
     const originalCenterRef = useRef(getPolygonCenter(originalPolygonRef.current));
-    const heightRef = useRef(node.height ?? 2.5);
+    // Resolved once at drag start — the ceiling plane can't change mid-move.
+    const heightRef = useRef(resolveCeilingHeight(node, useScene.getState().nodes));
     const dragAnchorRef = useRef(null);
     const previousGridPosRef = useRef(null);
     const deltaRef = useRef([0, 0]);
@@ -198,7 +199,7 @@ export const MoveCeilingTool = ({ node }) => {
             window.removeEventListener('pointerup', onPlacementDragPointerUp);
         };
     }, [exitMoveMode, node.id]);
-    return (_jsx(CeilingMovePreview, { ceilingId: node.id, cursorLocalPos: cursorLocalPos, height: node.height ?? 2.5, originalHoles: originalHolesRef.current, originalPolygon: originalPolygonRef.current }));
+    return (_jsx(CeilingMovePreview, { ceilingId: node.id, cursorLocalPos: cursorLocalPos, height: heightRef.current, originalHoles: originalHolesRef.current, originalPolygon: originalPolygonRef.current }));
 };
 /**
  * Translucent fill + bright outline showing where the ceiling will land

package/dist/ceiling/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/ceiling/panel.tsx"],"names":[],"mappings":"AAmBA;;;;;;;GAOG;AACH,wBAAgB,YAAY,uCA+P3B;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/ceiling/panel.tsx"],"names":[],"mappings":"AA2BA;;;;;;;GAOG;AACH,wBAAgB,YAAY,uCA0V3B;AAED,eAAe,YAAY,CAAA"}

package/dist/ceiling/panel.js

@@ -1,7 +1,7 @@
 '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 { getCeilingClampBound, resolveCeilingHeight, useScene, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, formatLinearMeasurement, 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';
@@ -15,19 +15,64 @@ import { useCallback, useEffect, useRef } from 'react';
  */
 export function CeilingPanel() {
     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);
     const node = useScene((s) => selectedId ? s.nodes[selectedId] : undefined);
+    // Ceilings no longer drive the storey height — the stored level height
+    // does — so height writes clamp under min(storey plane, lowest covering
+    // slab underside from the level above) − margin instead of poking into
+    // the level above or a deck hanging from it (clamp, never ask).
+    // Selector returns a primitive, so recomputing per store update is
+    // re-render-safe.
+    const maxHeight = useScene((s) => {
+        const parent = node?.parentId ? s.nodes[node.parentId] : undefined;
+        return parent?.type === 'level'
+            ? getCeilingClampBound(parent.id, s.nodes, node?.polygon ?? [])
+            : 6;
+    });
+    // Effective height: the stored custom height, or — for follows-mode
+    // ceilings (absent `height`) — the live level-top bound. Primitive
+    // selector so it tracks level-height / covering-slab edits.
+    const resolvedHeight = useScene((s) => {
+        const ceiling = selectedId
+            ? s.nodes[selectedId]
+            : undefined;
+        return ceiling?.type === 'ceiling' ? resolveCeilingHeight(ceiling, s.nodes) : 2.5;
+    });
     // Panel slider-drag fix recipe (plans/editor-node-registry.md): stable
     // handler refs so slider drags don't trigger Maximum update depth.
     const nodeRef = useRef(node);
     nodeRef.current = node;
+    const maxHeightRef = useRef(maxHeight);
+    maxHeightRef.current = maxHeight;
+    const resolvedHeightRef = useRef(resolvedHeight);
+    resolvedHeightRef.current = resolvedHeight;
     const handleUpdate = useCallback((updates) => {
         if (!selectedId)
             return;
         useScene.getState().updateNode(selectedId, updates);
     }, [selectedId]);
+    const handleHeightChange = useCallback((proposed) => {
+        handleUpdate({ height: Math.min(proposed, maxHeightRef.current) });
+    }, [handleUpdate]);
+    const handleTopModeChange = useCallback((mode) => {
+        const n = nodeRef.current;
+        if (!n)
+            return;
+        const isCustom = n.height != null;
+        if (mode === 'custom' && !isCustom) {
+            // Seed from the current resolved height so the surface doesn't
+            // jump at the moment of detaching from the level top.
+            handleUpdate({ height: Math.min(resolvedHeightRef.current, maxHeightRef.current) });
+        }
+        else if (mode === 'storey' && isCustom) {
+            // Absent `height` = follows the level top; the store strips
+            // undefined keys.
+            handleUpdate({ height: undefined });
+        }
+    }, [handleUpdate]);
     const handleClose = useCallback(() => {
         setSelection({ selectedIds: [] });
         useInteractionScope
@@ -122,7 +167,24 @@ export function CeilingPanel() {
         return Math.abs(area) / 2;
     };
     const area = calculateArea(node.polygon);
-    return (_jsxs(PanelWrapper, { icon: "/icons/ceiling.webp", onClose: handleClose, title: node.name || 'Ceiling', width: 320, children: [_jsxs(PanelSection, { title: "Height", children: [_jsx(SliderControl, { label: "Height", max: 6, min: 0, onChange: (v) => handleUpdate({ height: v }), precision: 3, step: 0.01, unit: "m", value: Math.round(node.height * 1000) / 1000 }), _jsxs("div", { className: "mt-2 grid grid-cols-3 gap-1.5 px-1 pb-1", children: [_jsx(ActionButton, { label: "Low (2.4m)", onClick: () => handleUpdate({ height: 2.4 }) }), _jsx(ActionButton, { label: "Standard (2.5m)", onClick: () => handleUpdate({ height: 2.5 }) }), _jsx(ActionButton, { label: "High (3.0m)", onClick: () => handleUpdate({ height: 3.0 }) })] })] }), _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 isFollows = node.height == null;
+    // Clean preset values per display system; imperial stores exact meters
+    // for 8'0" / 8'6" / 9'0" ceilings.
+    const heightPresets = unit === 'imperial'
+        ? [
+            { label: 'Low (8\'0")', height: 2.4384 },
+            { label: 'Standard (8\'6")', height: 2.5908 },
+            { label: 'High (9\'0")', height: 2.7432 },
+        ]
+        : [
+            { label: 'Low (2.4m)', height: 2.4 },
+            { label: 'Standard (2.5m)', height: 2.5 },
+            { label: 'High (3.0m)', height: 3.0 },
+        ];
+    return (_jsxs(PanelWrapper, { icon: "/icons/ceiling.webp", onClose: handleClose, title: node.name || 'Ceiling', width: 320, children: [_jsxs(PanelSection, { title: "Height", children: [_jsx(SegmentedControl, { onChange: handleTopModeChange, options: [
+                            { label: 'Follows level', value: 'storey' },
+                            { label: 'Custom height', value: 'custom' },
+                        ], value: isFollows ? 'storey' : 'custom' }), isFollows ? (_jsxs("div", { className: "px-1 text-[11px] text-muted-foreground", children: ["Currently ", formatLinearMeasurement(resolvedHeight, unit)] })) : (_jsx(SliderControl, { label: "Height", max: Math.min(6, maxHeight), min: 0, onChange: handleHeightChange, precision: 3, step: 0.01, unit: "m", value: Math.round((node.height ?? resolvedHeight) * 1000) / 1000 })), _jsx("div", { className: "mt-2 grid grid-cols-3 gap-1.5 px-1 pb-1", children: heightPresets.map((preset) => (_jsx(ActionButton, { label: preset.label, onClick: () => handleHeightChange(preset.height) }, 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/ceiling/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/ceiling/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,WAAW,EAMjB,MAAM,kBAAkB,CAAA;AAiBzB,eAAO,MAAM,eAAe,GAAI,UAAU;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,gCAoG9D,CAAA;AAED,eAAe,eAAe,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/ceiling/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,WAAW,EAOjB,MAAM,kBAAkB,CAAA;AAiBzB,eAAO,MAAM,eAAe,GAAI,UAAU;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,gCAwG9D,CAAA;AAED,eAAe,eAAe,CAAA"}

package/dist/ceiling/renderer.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { getMaterialPresetByRef, resolveMaterial, useLiveTransforms, useRegistry, useScene, } from '@pascal-app/core';
+import { getMaterialPresetByRef, resolveCeilingHeight, resolveMaterial, useLiveTransforms, useRegistry, useScene, } from '@pascal-app/core';
 import { createSurfaceRoleMaterial, NodeRenderer, resolveSurfaceColor, useViewer, } from '@pascal-app/viewer';
 import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
 import { BackSide } from 'three/webgpu';
@@ -31,7 +31,11 @@ export const CeilingRenderer = ({ node }) => {
     // ceiling slot references re-tints it live.
     const sceneMaterials = useScene((s) => s.materials);
     const liveTransform = useLiveTransforms((s) => s.get(node.id));
-    const ceilingY = (node.height ?? 2.5) - 0.01 + (liveTransform?.position[1] ?? 0);
+    // Resolved height: explicit when stored, else the live level-top bound
+    // (primitive selector, so follows-mode ceilings track level-height edits
+    // and covering-slab changes without a node write).
+    const resolvedHeight = useScene((s) => resolveCeilingHeight(node, s.nodes));
+    const ceilingY = resolvedHeight - 0.01 + (liveTransform?.position[1] ?? 0);
     const position = [
         liveTransform?.position[0] ?? 0,
         ceilingY,

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/ceiling/tool.tsx"],"names":[],"mappings":"AAoDA,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,EAwV/B,CAAA;AAED,eAAe,WAAW,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/ceiling/tool.tsx"],"names":[],"mappings":"AAqDA,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,EAuW/B,CAAA;AAED,eAAe,WAAW,CAAA"}

package/dist/ceiling/tool.js

@@ -1,7 +1,7 @@
 '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, clearCeilingSnapFeedback, EDITOR_LAYER, isAngleSnapActive, isGridSnapActive, markToolCancelConsumed, resolveCeilingPlanPointSnap, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { CursorSphere, clearCeilingSnapFeedback, EDITOR_LAYER, isAngleSnapActive, isGridSnapActive, markToolCancelConsumed, resolveCeilingPlanPointSnap, triggerSFX, useEditor, useFloorplanDraftPreview, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { BufferGeometry, DoubleSide, Shape, Vector3 } from 'three';
@@ -52,6 +52,16 @@ export const CeilingTool = () => {
         useEditor.getState().setDraftVertexCount(points.length);
     }, [points.length]);
     useEffect(() => () => useEditor.getState().setDraftVertexCount(0), []);
+    useEffect(() => {
+        useFloorplanDraftPreview.getState().setPolygonDraft('ceiling', points);
+    }, [points]);
+    useEffect(() => () => {
+        const draftPreview = useFloorplanDraftPreview.getState();
+        if (draftPreview.polygonDraftType === 'ceiling') {
+            draftPreview.setPolygonDraft(null, []);
+        }
+        draftPreview.setCursorPoint(null);
+    }, []);
     const verticalGeo = useMemo(() => new BufferGeometry().setFromPoints([
         new Vector3(0, 0, 0),
         new Vector3(0, CEILING_HEIGHT - GRID_OFFSET, 0),
@@ -81,6 +91,7 @@ export const CeilingTool = () => {
                 fallbackPoint: orthoPoint,
                 levelId: currentLevelId,
             }).point;
+            useFloorplanDraftPreview.getState().setCursorPoint(displayPoint);
             setSnappedCursorPosition(displayPoint);
             if (points.length > 0 &&
                 previousSnappedPointRef.current &&

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/chimney/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAqUtC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CAoEhE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/chimney/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAqUtC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CAqEhE,CAAA"}

package/dist/chimney/definition.js

@@ -369,6 +369,7 @@ export const chimneyDefinition = {
         kind: 'parametric',
         module: () => import('./renderer'),
     },
+    preview: () => import('./preview'),
     tool: () => import('./tool'),
     toolHints: [
         { key: 'Left click', label: 'Place chimney on roof' },

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/chimney/tool.tsx"],"names":[],"mappings":"AA4CA,QAAA,MAAM,WAAW,mCAyIhB,CAAA;AAED,eAAe,WAAW,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/chimney/tool.tsx"],"names":[],"mappings":"AA4CA,QAAA,MAAM,WAAW,mCAwJhB,CAAA;AAED,eAAe,WAAW,CAAA"}

package/dist/chimney/tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { ChimneyNode, emitter, 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';
@@ -79,6 +79,12 @@ const ChimneyTool = () => {
             setSegmentXform(xform);
             setHitLocal([hit.localX, hit.localY, hit.localZ]);
             setPreviewSegment(hit.segment);
+            usePlacementPreview.getState().set(ChimneyNode.parse({
+                ...previewNode,
+                parentId: hit.segment.id,
+                position: [hit.localX, hit.localY, hit.localZ],
+                roofSegmentId: hit.segment.id,
+            }), hit.segment);
             publishRoofSurfacePlacementGuides({
                 roof: event.node,
                 segment: hit.segment,
@@ -103,6 +109,9 @@ const ChimneyTool = () => {
             state.dirtyNodes.add(hit.segment.id);
             setSelection({ selectedIds: [chimney.id] });
             triggerSFX('sfx:item-place');
+            const placementPreview = usePlacementPreview.getState();
+            if (placementPreview.node?.id === previewNode.id)
+                placementPreview.clear();
             clearRoofSurfacePlacementGuides();
             event.stopPropagation();
         };
@@ -113,6 +122,9 @@ const ChimneyTool = () => {
             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]);
@@ -120,6 +132,9 @@ const ChimneyTool = () => {
                     setSegmentXform(null);
                     setHitLocal(null);
                     setPreviewSegment(null);
+                    const placementPreview = usePlacementPreview.getState();
+                    if (placementPreview.node?.id === previewNode.id)
+                        placementPreview.clear();
                     clearRoofSurfacePlacementGuides();
                 } }), activeBuildingId && segmentXform && hitLocal && previewSegment && (_jsx("group", { position: segmentXform.position, quaternion: segmentXform.quaternion, children: _jsx("group", { position: [hitLocal[0], 0, hitLocal[2]], children: _jsx(ChimneyPreview, { node: previewNode, segment: previewSegment }) }) }))] }));
 };

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/column/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAMzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AA8RrC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAyF9D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/column/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAUzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AA0SrC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAgG9D,CAAA"}

package/dist/column/definition.js

@@ -1,5 +1,6 @@
 import { ColumnNode as ColumnNodeSchema, } from '@pascal-app/core';
-import { buildColumnFloorplan } from './floorplan';
+import { collectStructuralGridAxes, resolveStructuralGridSnap, } from '../structural-grid/coordination';
+import { buildColumnFloorplan, computeColumnFloorplanLevelData } from './floorplan';
 import { columnResizeAffordance, columnRotateAffordance } from './floorplan-affordances';
 import { columnFloorplanMoveTarget } from './floorplan-move';
 import { columnPaint } from './paint';
@@ -272,6 +273,10 @@ function columnHandles(node) {
     handles.push(columnRotateHandle(), columnMoveHandle());
     return handles;
 }
+function resolveColumnStructuralGridMoveSnap({ candidatePosition, nodes, levelId, }) {
+    const snap = resolveStructuralGridSnap([candidatePosition[0], candidatePosition[2]], collectStructuralGridAxes(nodes, levelId));
+    return snap ? [snap.point[0], candidatePosition[1], snap.point[1]] : null;
+}
 /**
  * Column — Stage A registration. Wrap-export of the legacy
  * `ColumnRenderer` (no system — column geometry is computed inline in
@@ -309,7 +314,11 @@ export const columnDefinition = {
         // Generic 3D translate-on-XZ via `MoveRegistryNodeTool` (grid snap + the
         // mode-driven snapping the overhaul standardised). 2D move keeps using
         // `floorplanMoveTarget`, which wins the 2D move dispatch.
-        movable: { axes: ['x', 'z'], gridSnap: true },
+        movable: {
+            axes: ['x', 'z'],
+            gridSnap: true,
+            groupMoveSnap: resolveColumnStructuralGridMoveSnap,
+        },
         slots: (node) => columnSlots(node),
         paint: columnPaint,
         // Slab elevation lift via the generic `<FloorElevationSystem>` + the
@@ -337,6 +346,7 @@ export const columnDefinition = {
         kind: 'parametric',
         module: () => import('./renderer'),
     },
+    preview: () => import('./renderer').then(({ ColumnPreview }) => ({ default: ColumnPreview })),
     // Registry-driven placement tool — renders a translucent `ColumnPreview`
     // ghost at the cursor (mirroring the shelf build tool) instead of the
     // bare sphere the legacy editor-side `ColumnTool` showed. `ToolManager`'s
@@ -346,6 +356,8 @@ export const columnDefinition = {
         { key: 'Left click', label: 'Place column' },
         { key: 'Esc', label: 'Cancel' },
     ],
+    computeFloorplanLevelData: computeColumnFloorplanLevelData,
+    floorplanDependsOnSiblings: true,
     floorplan: buildColumnFloorplan,
     // 2D body move routes through this kind-specific target so the column
     // aligns by its footprint *edges* (and snaps flush to wall faces) instead

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/column/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,mBAAmB,EAEzB,MAAM,kBAAkB,CAAA;AAYzB;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,GAAG,EACC,OAAO,GACP,OAAO,GACP,SAAS,GACT,QAAQ,GACR,aAAa,GACb,aAAa,GACb,qBAAqB,GACrB,kBAAkB,CAAA;IACtB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC3B,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,UAAU,CAkFlE,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,UAAU,CA8BlE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/column/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,mBAAmB,EAGzB,MAAM,kBAAkB,CAAA;AAazB;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,GAAG,EACC,OAAO,GACP,OAAO,GACP,SAAS,GACT,QAAQ,GACR,aAAa,GACb,aAAa,GACb,qBAAqB,GACrB,kBAAkB,CAAA;IACtB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC3B,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,UAAU,CAoFlE,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,UAAU,CAgClE,CAAA"}

package/dist/column/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';
 // Floor minimums — mirror the 3D handles in `column/definition.ts` so a
 // drag can't push a value past what the renderer accepts.
@@ -22,9 +23,10 @@ export const columnResizeAffordance = {
         const initialBraceBottomSpread = node.braceBottomSpread ?? Math.max(node.width * 3, 1.2);
         const initialBraceTopSpread = node.braceTopSpread ?? 0.12;
         let lastPatch = {};
-        const commitPatch = (patch) => {
+        const previewPatch = (patch) => {
             lastPatch = patch;
-            useScene.getState().updateNode(columnId, patch);
+            useLiveNodeOverrides.getState().set(columnId, patch);
+            useScene.getState().markDirty(columnId);
         };
         return {
             affectedIds: [columnId],
@@ -33,42 +35,42 @@ export const columnResizeAffordance = {
                 const projDelta = currentProj - initialProj;
                 switch (dim) {
                     case 'width':
-                        commitPatch({
+                        previewPatch({
                             width: Math.max(MIN_COLUMN_WIDTH, initialWidth + 2 * projDelta),
                         });
                         return;
                     case 'depth':
-                        commitPatch({
+                        previewPatch({
                             depth: Math.max(MIN_COLUMN_DEPTH, initialDepth + 2 * projDelta),
                         });
                         return;
                     case 'uniform': {
                         const next = Math.max(MIN_COLUMN_WIDTH, initialWidth + 2 * projDelta);
-                        commitPatch({ width: next, depth: next });
+                        previewPatch({ width: next, depth: next });
                         return;
                     }
                     case 'radius':
-                        commitPatch({
+                        previewPatch({
                             radius: Math.max(MIN_COLUMN_RADIUS, initialRadius + projDelta),
                         });
                         return;
                     case 'brace-width':
-                        commitPatch({
+                        previewPatch({
                             braceWidth: Math.max(MIN_BRACE_DIMENSION, initialBraceWidth + 2 * projDelta),
                         });
                         return;
                     case 'brace-depth':
-                        commitPatch({
+                        previewPatch({
                             braceDepth: Math.max(MIN_BRACE_DIMENSION, initialBraceDepth + 2 * projDelta),
                         });
                         return;
                     case 'brace-bottom-spread':
-                        commitPatch({
+                        previewPatch({
                             braceBottomSpread: Math.max(MIN_BRACE_BOTTOM_SPREAD, initialBraceBottomSpread + 2 * projDelta),
                         });
                         return;
                     case 'brace-top-spread':
-                        commitPatch({
+                        previewPatch({
                             braceTopSpread: Math.max(MIN_BRACE_TOP_SPREAD, initialBraceTopSpread + 2 * projDelta),
                         });
                         return;
@@ -79,6 +81,7 @@ export const columnResizeAffordance = {
             },
             commit() {
                 if (Object.keys(lastPatch).length > 0) {
+                    useLiveNodeOverrides.getState().clear(columnId);
                     useScene.getState().updateNode(columnId, lastPatch);
                 }
             },
@@ -104,21 +107,23 @@ export const columnRotateAffordance = {
         let lastRotation = initialRotation;
         return {
             affectedIds: [columnId],
-            apply({ planPoint, modifiers }) {
+            apply({ planPoint }) {
                 const delta = rotateAffordanceDelta({
                     center: [cx, cz],
                     initialAngle,
                     planPoint,
-                    free: modifiers.shiftKey,
+                    free: !isAngleSnapActive(),
                 });
                 const newRotation = initialRotation - delta;
                 lastRotation = newRotation;
-                useScene.getState().updateNode(columnId, { rotation: newRotation });
+                useLiveNodeOverrides.getState().set(columnId, { rotation: newRotation });
+                useScene.getState().markDirty(columnId);
             },
             canCommit() {
                 return true;
             },
             commit() {
+                useLiveNodeOverrides.getState().clear(columnId);
                 useScene.getState().updateNode(columnId, { rotation: lastRotation });
             },
         };

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/column/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,UAAU,EAEf,KAAK,mBAAmB,EAMzB,MAAM,kBAAkB,CAAA;AAYzB;;;;;;;GAOG;AAEH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CAiErE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/column/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,UAAU,EAEf,KAAK,mBAAmB,EAMzB,MAAM,kBAAkB,CAAA;AAgBzB;;;;;;;GAOG;AAEH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CAsErE,CAAA"}

package/dist/column/floorplan-move.js

@@ -1,6 +1,7 @@
 import { collectAlignmentAnchors, movingFootprintAnchors, sceneRegistry, useLiveTransforms, useScene, } from '@pascal-app/core';
 import { applyFloorplanAlignment, getFloorStackPreviewPosition, isGridSnapActive, isMagneticSnapActive, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
+import { collectStructuralGridAxes, resolveStructuralGridSnap, } from '../structural-grid/coordination';
 /**
  * 2D floor-plan move handler for column. Columns need the same footprint-edge
  * alignment as shelf / item, but they must preview through live transforms and
@@ -33,9 +34,13 @@ export const columnFloorplanMoveTarget = ({ node, nodes }) => {
             const gridSnapped = resolveCursor(planPoint, { snap });
             // Figma-style alignment layered on the active snap mode.
             const { point: snapped } = applyFloorplanAlignment(gridSnapped, movingFootprintAnchors(node, gridSnapped[0], gridSnapped[1], rotationY), candidates, { applySnap: isMagneticSnapActive() });
-            const next = [snapped[0], originalPosition[1], snapped[1]];
+            const structuralSnap = isGridSnapActive() || isMagneticSnapActive()
+                ? resolveStructuralGridSnap(snapped, collectStructuralGridAxes(nodes, node.parentId))
+                : null;
+            const coordinated = structuralSnap?.point ?? snapped;
+            const next = [coordinated[0], originalPosition[1], coordinated[1]];
             lastPosition = next;
-            const snapKey = `${snapped[0]},${snapped[1]}`;
+            const snapKey = `${coordinated[0]},${coordinated[1]}`;
             if (snapKey !== lastSnapKey) {
                 triggerSFX('sfx:grid-snap');
                 lastSnapKey = snapKey;

package/dist/column/floorplan.d.ts

@@ -1,4 +1,11 @@
-import type { ColumnNode, FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+import type { AnyNode, ColumnNode, FloorplanGeometry, FloorplanPoint, GeometryContext, StructuralGridNode } from '@pascal-app/core';
+export type ColumnFloorplanLevelData = {
+    structuralGrids: StructuralGridNode[];
+};
+export declare function computeColumnFloorplanLevelData({ siblings, nodes, }: {
+    siblings: readonly ColumnNode[];
+    nodes: Record<string, AnyNode>;
+}): ColumnFloorplanLevelData;
 /**
  * Stage C floor-plan builder for column. Inlined from the legacy
  * `getColumnPlanFootprint` helper in `floorplan-panel.tsx`. The
@@ -12,4 +19,5 @@ import type { ColumnNode, FloorplanGeometry, GeometryContext } from '@pascal-app
  * dragging the body, and a rotate-arrow at the front-right corner.
  */
 export declare function buildColumnFloorplan(node: ColumnNode, ctx: GeometryContext): FloorplanGeometry | null;
+export declare function getColumnFloorplanFootprint(node: ColumnNode): FloorplanPoint[];
 //# sourceMappingURL=floorplan.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/column/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EAEjB,eAAe,EAChB,MAAM,kBAAkB,CAAA;AAezB;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAgI1B"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/column/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,UAAU,EACV,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,kBAAkB,EACnB,MAAM,kBAAkB,CAAA;AAsBzB,MAAM,MAAM,wBAAwB,GAAG;IACrC,eAAe,EAAE,kBAAkB,EAAE,CAAA;CACtC,CAAA;AAED,wBAAgB,+BAA+B,CAAC,EAC9C,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAA;IAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,wBAAwB,CAI3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAiL1B;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,UAAU,GAAG,cAAc,EAAE,CAE9E"}

package/dist/column/floorplan.js

@@ -1,13 +1,22 @@
+import { floorplanGeometryMetadata } from '@pascal-app/editor';
+import { collectStructuralGridAxes, resolveStructuralGridReference, } from '../structural-grid/coordination';
 // Offsets for the floor-plan selection arrows. Resize chevrons hug the
 // footprint a hair off the rim; the rotate-arrow corner sits a bit
 // further out so it doesn't crowd the resize arrows.
 const RESIZE_ARROW_OFFSET = 0.12;
 const ROTATE_ARROW_CORNER_OFFSET = 0.22;
+const GRID_REFERENCE_OFFSET = 0.16;
+const GRID_REFERENCE_FONT_SIZE = 0.13;
 const ROUND_CROSS_SECTIONS = new Set([
     'round',
     'octagonal',
     'sixteen-sided',
 ]);
+export function computeColumnFloorplanLevelData({ siblings, nodes, }) {
+    return {
+        structuralGrids: collectStructuralGridAxes(nodes, siblings[0]?.parentId),
+    };
+}
 /**
  * Stage C floor-plan builder for column. Inlined from the legacy
  * `getColumnPlanFootprint` helper in `floorplan-panel.tsx`. The
@@ -21,8 +30,8 @@ const ROUND_CROSS_SECTIONS = new Set([
  * dragging the body, and a rotate-arrow at the front-right corner.
  */
 export function buildColumnFloorplan(node, ctx) {
-    const polygon = getColumnPlanFootprint(node);
-    if (polygon.length < 3)
+    const points = getColumnFloorplanFootprint(node);
+    if (points.length < 3)
         return null;
     const view = ctx.viewState;
     const palette = view?.palette;
@@ -31,7 +40,6 @@ export function buildColumnFloorplan(node, ctx) {
     const showSelectedChrome = isSelected || isHighlighted;
     const stroke = showSelectedChrome && palette ? palette.selectedStroke : '#374151';
     const fill = showSelectedChrome ? '#fed7aa' : '#9ca3af';
-    const points = polygon.map((p) => [p.x, p.y]);
     const children = [
         {
             kind: 'polygon',
@@ -40,8 +48,53 @@ export function buildColumnFloorplan(node, ctx) {
             stroke,
             strokeWidth: showSelectedChrome ? 0.03 : 0.02,
             opacity: 0.92,
+            metadata: floorplanGeometryMetadata({ annotationObstacle: 'bounds' }),
         },
     ];
+    const { halfX, halfZ } = columnPlanHalfExtents(node);
+    const centerMarkHalf = Math.min(0.09, Math.max(0.035, Math.min(halfX, halfZ) * 0.45));
+    const centerX = node.position[0];
+    const centerZ = node.position[2];
+    children.push({
+        kind: 'line',
+        x1: centerX - centerMarkHalf,
+        y1: centerZ - centerMarkHalf,
+        x2: centerX + centerMarkHalf,
+        y2: centerZ + centerMarkHalf,
+        stroke,
+        strokeWidth: 0.9,
+        vectorEffect: 'non-scaling-stroke',
+        pointerEvents: 'none',
+        metadata: floorplanGeometryMetadata({ annotationRole: 'column-center' }),
+    }, {
+        kind: 'line',
+        x1: centerX - centerMarkHalf,
+        y1: centerZ + centerMarkHalf,
+        x2: centerX + centerMarkHalf,
+        y2: centerZ - centerMarkHalf,
+        stroke,
+        strokeWidth: 0.9,
+        vectorEffect: 'non-scaling-stroke',
+        pointerEvents: 'none',
+        metadata: floorplanGeometryMetadata({ annotationRole: 'column-center' }),
+    });
+    const levelData = ctx.levelData;
+    const gridReference = resolveStructuralGridReference([centerX, centerZ], levelData?.structuralGrids ?? []);
+    if (gridReference) {
+        children.push({
+            kind: 'text',
+            x: centerX,
+            y: centerZ + halfZ + GRID_REFERENCE_OFFSET,
+            text: gridReference,
+            fontSize: GRID_REFERENCE_FONT_SIZE,
+            fill: stroke,
+            fontWeight: 700,
+            textAnchor: 'middle',
+            dominantBaseline: 'middle',
+            upright: true,
+            metadata: floorplanGeometryMetadata({ annotationRole: 'column-center' }),
+        });
+    }
     // Hatch overlay on selected — same `<defs>` pattern as the wall.
     if (isSelected && palette) {
         children.push({
@@ -117,7 +170,6 @@ export function buildColumnFloorplan(node, ctx) {
         // Rotate-arrow at the +X / +Z corner — matches the 3D
         // `columnRotateHandle` corner placement so users see the rotation
         // affordance in the same quadrant across views.
-        const { halfX, halfZ } = columnPlanHalfExtents(node);
         const cornerLocalX = halfX + ROTATE_ARROW_CORNER_OFFSET;
         const cornerLocalZ = halfZ + ROTATE_ARROW_CORNER_OFFSET;
         const [cornerWorldX, cornerWorldZ] = rotatePlanVector(cornerLocalX, cornerLocalZ, rot);
@@ -132,6 +184,9 @@ export function buildColumnFloorplan(node, ctx) {
     }
     return { kind: 'group', children };
 }
+export function getColumnFloorplanFootprint(node) {
+    return getColumnPlanFootprint(node).map((point) => [point.x, point.y]);
+}
 /**
  * XZ half-extents for the column's plan footprint. Mirrors the 3D
  * `columnFootprintHalf` so side-arrows + rotate-arrow ring the same

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/column/tool.tsx"],"names":[],"mappings":"AA+CA;;;;;;;;;;GAUG;AACH,QAAA,MAAM,UAAU,0CA2Hf,CAAA;AAED,eAAe,UAAU,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/column/tool.tsx"],"names":[],"mappings":"AAoDA;;;;;;;;;;GAUG;AACH,QAAA,MAAM,UAAU,0CA0Jf,CAAA;AAED,eAAe,UAAU,CAAA"}