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

package/dist/fence/tool.js

@@ -1,13 +1,27 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { calculateLevelMiters, collectAlignmentAnchors, emitter, getTwoPointFenceCurveTangents, getWallMiterBoundaryPoints, resolveAlignment, sampleFenceSpline, useScene, } from '@pascal-app/core';
-import { CursorSphere, createFenceOnCurrentLevel, createSplineFenceOnCurrentLevel, EDITOR_LAYER, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, getSegmentGridStep, isAlignmentGuideActive, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, snapFenceDraftPoint, snapScalarToGrid, triggerSFX, useAlignmentGuides, useEditor, useFenceCurveDraft, useSegmentDraftChain, } from '@pascal-app/editor';
+import { CursorSphere, clearPlacementSurface, createFenceOnCurrentLevel, createSplineFenceOnCurrentLevel, EDITOR_LAYER, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, getSegmentGridStep, isAlignmentGuideActive, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, publishPlacementSurface, resolvePointerSupportSurface, snapFenceDraftPoint, snapScalarToGrid, triggerSFX, useAlignmentGuides, useEditor, useFenceCurveDraft, useFloorplanDraftPreview, useSegmentDraftChain, } from '@pascal-app/editor';
 import { getSceneTheme, useViewer } from '@pascal-app/viewer';
-import { Html } from '@react-three/drei';
+import { useThree } from '@react-three/fiber';
 import { useEffect, useMemo, useRef, useState } from 'react';
-import { BoxGeometry, BufferGeometry, DoubleSide, Vector3 } from 'three';
+import { BoxGeometry, 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;
+// Grid-plane surface publish (pointer-decided): scratch + constant normal so
+// per-move publishes don't allocate.
+const SURFACE_UP = new Vector3(0, 1, 0);
+const surfacePointScratch = new Vector3();
+// The walking surface the pointer actually aims at (deck top when over the
+// deck, floor/ground underneath it) — only for genuine 3D pointer events.
+// The 2D floor plan emits synthetic grid events with no camera ray behind
+// 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)
+        : null;
+}
 /** Figma-style alignment-snap threshold (meters), matching the move tools. */
 const ALIGNMENT_THRESHOLD_M = 0.08;
 // HUD label heights are measured from the top of the preview bar, so they
@@ -17,7 +31,6 @@ const DRAFT_ANGLE_LABEL_Y_OFFSET = 0.08;
 const DRAFT_ANGLE_ARC_Y_OFFSET = 0.012;
 const DRAFT_ANGLE_ARC_MIN_RADIUS = 0.32;
 const DRAFT_ANGLE_ARC_MAX_RADIUS = 0.72;
-const DRAFT_ANGLE_ARC_SEGMENTS = 24;
 function clamp(value, min, max) {
     return Math.min(max, Math.max(min, value));
 }
@@ -290,12 +303,18 @@ const StraightFenceTool = () => {
     previewHeightRef.current = previewHeight;
     const previewThicknessRef = useRef(previewThickness);
     previewThicknessRef.current = previewThickness;
+    // Camera for the pointer-support resolution (deck top vs floor) — read
+    // through a ref so the live event handlers see the current camera.
+    const camera = useThree((state) => state.camera);
+    const cameraRef = useRef(camera);
+    cameraRef.current = camera;
     const cursorRef = useRef(null);
     const previewRef = useRef(null);
     const startingPoint = useRef(new Vector3(0, 0, 0));
     const endingPoint = useRef(new Vector3(0, 0, 0));
     const buildingState = useRef(0);
     const [draftMeasurement, setDraftMeasurement] = useState(null);
+    const [axisGuide, setAxisGuide] = useState(null);
     const measurementColor = isDark ? '#ffffff' : '#111111';
     const measurementShadowColor = isDark ? '#111111' : '#ffffff';
     // Scope seeded defaults to this tool session: clear on deactivation so a
@@ -334,12 +353,25 @@ const StraightFenceTool = () => {
             buildingState.current = 0;
             previewRef.current.visible = false;
             setDraftMeasurement(null);
+            setAxisGuide(null);
+            const draftPreview = useFloorplanDraftPreview.getState();
+            draftPreview.setFenceDraftStart(null);
+            draftPreview.setFenceDraftEnd(null);
             useSegmentDraftChain.getState().clear('fence');
             useAlignmentGuides.getState().clear();
         };
         const onGridMove = (event) => {
             if (!(cursorRef.current && previewRef.current))
                 return;
+            // Ride the grid event plane on the pointed surface: aiming at an
+            // elevated deck lifts the plane to the deck top, so the draft's XZ
+            // lands where the cursor points and the preview/cursor Y
+            // (`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 { walls, fences } = getCurrentLevelElements();
             const localPoint = [event.localPosition[0], event.localPosition[2]];
             // While drafting, the segment locks to 15° rays from its start.
@@ -357,7 +389,16 @@ const StraightFenceTool = () => {
                     magnetic: isMagneticSnapActive(),
                 }), { applySnap: !angleLocked });
                 endingPoint.current.set(snappedLocal[0], event.localPosition[1], snappedLocal[1]);
+                const draftPreview = useFloorplanDraftPreview.getState();
+                draftPreview.setFenceDraftStart([startingPoint.current.x, startingPoint.current.z]);
+                draftPreview.setFenceDraftEnd(snappedLocal);
                 cursorRef.current.position.copy(endingPoint.current);
+                setAxisGuide({
+                    origin: [startingPoint.current.x, startingPoint.current.z],
+                    endOrigin: snappedLocal,
+                    y: startingPoint.current.y,
+                    angleLabel: getNearestAxisAngleLabel([startingPoint.current.x, startingPoint.current.z], snappedLocal, startingPoint.current.y),
+                });
                 const currentFenceEnd = [snappedLocal[0], snappedLocal[1]];
                 if (previousFenceEnd &&
                     (currentFenceEnd[0] !== previousFenceEnd[0] || currentFenceEnd[1] !== previousFenceEnd[1])) {
@@ -376,6 +417,7 @@ const StraightFenceTool = () => {
                 }));
                 cursorRef.current.position.set(snappedPoint[0], event.localPosition[1], snappedPoint[1]);
                 setDraftMeasurement(null);
+                setAxisGuide(null);
             }
         };
         const onGridClick = (event) => {
@@ -397,9 +439,18 @@ const StraightFenceTool = () => {
                 startingPoint.current.set(snappedStart[0], event.localPosition[1], snappedStart[1]);
                 endingPoint.current.copy(startingPoint.current);
                 buildingState.current = 1;
+                const draftPreview = useFloorplanDraftPreview.getState();
+                draftPreview.setFenceDraftStart(snappedStart);
+                draftPreview.setFenceDraftEnd(snappedStart);
                 triggerSFX('sfx:structure-build-start');
                 previewRef.current.visible = true;
                 setDraftMeasurement(null);
+                setAxisGuide({
+                    origin: snappedStart,
+                    endOrigin: null,
+                    y: event.localPosition[1],
+                    angleLabel: null,
+                });
             }
             else {
                 const angleLocked = isAngleSnapActive();
@@ -415,7 +466,8 @@ const StraightFenceTool = () => {
                 const dz = snappedEnd[1] - startingPoint.current.z;
                 if (dx * dx + dz * dz < 0.01 * 0.01)
                     return;
-                const createdFence = createFenceOnCurrentLevel([startingPoint.current.x, startingPoint.current.z], snappedEnd);
+                const pointed = pointedSurfaceFor(cameraRef.current, event);
+                const createdFence = createFenceOnCurrentLevel([startingPoint.current.x, startingPoint.current.z], snappedEnd, { supportCap: pointed ? pointed.elevation : null });
                 if (!createdFence)
                     return;
                 // The new segment is now a real node — make it an alignment target
@@ -435,10 +487,20 @@ const StraightFenceTool = () => {
                 useSegmentDraftChain.getState().setChainStart('fence', [nextStart[0], nextStart[1]]);
                 startingPoint.current.set(nextStart[0], event.localPosition[1], nextStart[1]);
                 endingPoint.current.copy(startingPoint.current);
+                const draftPreview = useFloorplanDraftPreview.getState();
+                draftPreview.setFenceDraftEnd(null);
+                draftPreview.setFenceDraftStart(nextStart);
+                draftPreview.setFenceDraftEnd(nextStart);
                 cursorRef.current?.position.copy(startingPoint.current);
                 previewRef.current.visible = false;
                 buildingState.current = 1;
                 setDraftMeasurement(null);
+                setAxisGuide({
+                    origin: nextStart,
+                    endOrigin: null,
+                    y: event.localPosition[1],
+                    angleLabel: null,
+                });
             }
         };
         const onCancel = () => {
@@ -454,11 +516,15 @@ const StraightFenceTool = () => {
             emitter.off('grid:move', onGridMove);
             emitter.off('grid:click', onGridClick);
             emitter.off('tool:cancel', onCancel);
+            clearPlacementSurface();
             useSegmentDraftChain.getState().clear('fence');
             useAlignmentGuides.getState().clear();
+            const draftPreview = useFloorplanDraftPreview.getState();
+            draftPreview.setFenceDraftStart(null);
+            draftPreview.setFenceDraftEnd(null);
         };
     }, [unit]);
-    return (_jsxs("group", { children: [_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)))] }))] }));
+    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)))] }))] }));
 };
 const SPLINE_PREVIEW_COLOR = '#8381ed';
 const SPLINE_PREVIEW_SEGMENTS = 40;
@@ -468,13 +534,23 @@ const SplineFenceDraft = () => {
         : FENCE_PREVIEW_HEIGHT;
     const [draftPoints, setDraftPoints] = useState([]);
     const [cursor, setCursor] = useState(null);
+    // Building-local Y of the grid plane (rides the pointed surface — see
+    // `pointedSurfaceFor`), so the spline preview draws on the deck top when
+    // the curve is being laid out on one.
+    const [liftY, setLiftY] = useState(0);
+    const camera = useThree((state) => state.camera);
+    const cameraRef = useRef(camera);
+    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 draftRef = useRef(draftPoints);
     draftRef.current = draftPoints;
-    // Mirror the draft length into the HUD store so the "finish curve" hint only
-    // shows once drafting has started; always clear it when the tool unmounts.
+    // Mirror the full transient curve so additional preview surfaces observe
+    // the same snapped control points as the local preview.
     useEffect(() => {
-        useFenceCurveDraft.getState().setPointCount(draftPoints.length);
-    }, [draftPoints]);
+        useFenceCurveDraft.getState().setDraft(draftPoints, cursor);
+    }, [cursor, draftPoints]);
     useEffect(() => () => useFenceCurveDraft.getState().reset(), []);
     useEffect(() => () => useEditor.getState().setToolDefaults('fence', null), []);
     useEffect(() => {
@@ -487,7 +563,9 @@ const SplineFenceDraft = () => {
         const commit = () => {
             const points = draftRef.current;
             if (points.length >= 2) {
-                const created = createSplineFenceOnCurrentLevel(points);
+                const created = createSplineFenceOnCurrentLevel(points, undefined, {
+                    supportCap: supportCapRef.current,
+                });
                 if (created) {
                     triggerSFX('sfx:item-place');
                     // Once the new curve fence is selected for direct editing, leave
@@ -500,10 +578,20 @@ const SplineFenceDraft = () => {
             setDraftPoints([]);
             setCursor(null);
         };
+        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]);
+        };
         const onMove = (event) => {
+            trackPointedSurface(event);
             setCursor(snapPoint([event.localPosition[0], event.localPosition[2]]));
         };
         const onClick = (event) => {
+            trackPointedSurface(event);
             if (event.nativeEvent.detail >= 2) {
                 commit();
                 return;
@@ -530,6 +618,7 @@ const SplineFenceDraft = () => {
             emitter.off('grid:move', onMove);
             emitter.off('grid:click', onClick);
             emitter.off('tool:cancel', onCancel);
+            clearPlacementSurface();
             window.removeEventListener('keydown', onKeyDown);
         };
     }, []);
@@ -538,26 +627,8 @@ const SplineFenceDraft = () => {
         if (previewPoints.length < 2)
             return null;
         const sampled = sampleFenceSpline(previewPoints, getTwoPointFenceCurveTangents(previewPoints), SPLINE_PREVIEW_SEGMENTS);
-        return new BufferGeometry().setFromPoints(sampled.map((point) => new Vector3(point.x, previewHeight, point.y)));
-    }, [previewHeight, previewPoints]);
-    return (_jsxs("group", { children: [cursor && _jsx(CursorSphere, { height: previewHeight, position: [cursor[0], 0, cursor[1]] }), draftPoints.map((point, index) => (_jsxs("mesh", { layers: EDITOR_LAYER, position: [point[0], previewHeight, point[1]], children: [_jsx("sphereGeometry", { args: [0.07, 16, 12] }), _jsx("meshBasicMaterial", { color: SPLINE_PREVIEW_COLOR, depthTest: false })] }, `fence-spline-pt-${index}`))), curveGeometry && (_jsx("line", { frustumCulled: false, geometry: curveGeometry, layers: EDITOR_LAYER, renderOrder: 2, children: _jsx("lineBasicNodeMaterial", { color: SPLINE_PREVIEW_COLOR, depthTest: false, depthWrite: false, linewidth: 2, opacity: 0.95, transparent: true }) }))] }));
+        return new BufferGeometry().setFromPoints(sampled.map((point) => new Vector3(point.x, liftY + previewHeight, point.y)));
+    }, [liftY, previewHeight, previewPoints]);
+    return (_jsxs("group", { children: [cursor && _jsx(CursorSphere, { height: previewHeight, position: [cursor[0], liftY, cursor[1]] }), draftPoints.map((point, index) => (_jsxs("mesh", { layers: EDITOR_LAYER, position: [point[0], liftY + previewHeight, point[1]], children: [_jsx("sphereGeometry", { args: [0.07, 16, 12] }), _jsx("meshBasicMaterial", { color: SPLINE_PREVIEW_COLOR, depthTest: false })] }, `fence-spline-pt-${index}`))), curveGeometry && (_jsx("line", { frustumCulled: false, geometry: curveGeometry, layers: EDITOR_LAYER, renderOrder: 2, children: _jsx("lineBasicNodeMaterial", { color: SPLINE_PREVIEW_COLOR, depthTest: false, depthWrite: false, linewidth: 2, opacity: 0.95, transparent: true }) }))] }));
 };
-function DraftAngleArc({ arc, color }) {
-    const geometry = useMemo(() => {
-        const segmentCount = Math.max(8, Math.ceil((Math.abs(arc.endAngle - arc.startAngle) / Math.PI) * DRAFT_ANGLE_ARC_SEGMENTS));
-        const points = Array.from({ length: segmentCount + 1 }, (_, index) => {
-            const t = index / segmentCount;
-            const angle = arc.startAngle + (arc.endAngle - arc.startAngle) * t;
-            return new Vector3(arc.center[0] + Math.cos(angle) * arc.radius, arc.y, arc.center[1] + Math.sin(angle) * arc.radius);
-        });
-        return new BufferGeometry().setFromPoints(points);
-    }, [arc]);
-    return (_jsx("line", { frustumCulled: false, geometry: geometry, layers: EDITOR_LAYER, renderOrder: 2, children: _jsx("lineBasicNodeMaterial", { color: color, depthTest: false, depthWrite: false, linewidth: 2, opacity: 0.95, transparent: true }) }));
-}
-function DraftMeasurementLabel({ color, label, position, shadowColor, }) {
-    return (_jsx(Html, { center: true, position: position, style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsx("div", { className: "whitespace-nowrap font-bold font-mono text-[15px]", style: {
-                color,
-                textShadow: `-1.5px -1.5px 0 ${shadowColor}, 1.5px -1.5px 0 ${shadowColor}, -1.5px 1.5px 0 ${shadowColor}, 1.5px 1.5px 0 ${shadowColor}, 0 0 4px ${shadowColor}, 0 0 4px ${shadowColor}`,
-            }, children: label }) }));
-}
 export default FenceTool;

package/dist/hvac-equipment/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/hvac-equipment/tool.tsx"],"names":[],"mappings":"AAqBA;;;;;;;GAOG;AACH,QAAA,MAAM,iBAAiB,0CAoGtB,CAAA;AAED,eAAe,iBAAiB,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/hvac-equipment/tool.tsx"],"names":[],"mappings":"AA2BA;;;;;;;GAOG;AACH,QAAA,MAAM,iBAAiB,0CAyGtB,CAAA;AAED,eAAe,iBAAiB,CAAA"}

package/dist/hvac-equipment/tool.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { emitter, HvacEquipmentNode, useScene } from '@pascal-app/core';
+import { emitter, HvacEquipmentNode, resolveSupportSlabPatch, useScene, } from '@pascal-app/core';
 import { isGridSnapActive, isMagneticSnapActive, triggerSFX, useEditor } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
@@ -65,9 +65,14 @@ const HvacEquipmentTool = () => {
                 name: 'Furnace',
                 position,
                 rotation: yawRef.current,
+                parentId: activeLevelId,
             });
-            useScene.getState().createNode(unit, activeLevelId);
-            useViewer.getState().setSelection({ selectedIds: [unit.id] });
+            const committedUnit = HvacEquipmentNode.parse({
+                ...unit,
+                ...resolveSupportSlabPatch(unit, useScene.getState().nodes),
+            });
+            useScene.getState().createNode(committedUnit, activeLevelId);
+            useViewer.getState().setSelection({ selectedIds: [committedUnit.id] });
             triggerSFX('sfx:item-place');
         };
         const onKeyDown = (e) => {

package/dist/index.d.ts

@@ -22,6 +22,7 @@ export { bakeCabinetAnimationClip, type CabinetPlacementType, cabinetDefinition,
 export { ceilingDefinition } from './ceiling';
 export { chimneyDefinition } from './chimney';
 export { columnDefinition } from './column';
+export { constructionDimensionDefinition } from './construction-dimension';
 export { cupolaDefinition } from './cupola';
 export { doorDefinition } from './door';
 export { dormerDefinition } from './dormer';
@@ -55,6 +56,7 @@ export { solarPanelDefinition } from './solar-panel';
 export { spawnDefinition } from './spawn';
 export { stairDefinition } from './stair';
 export { stairSegmentDefinition } from './stair-segment';
+export { structuralGridDefinition } from './structural-grid';
 export { turbineVentDefinition } from './turbine-vent';
 export { wallDefinition } from './wall';
 export { windowDefinition } from './window';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -4,6 +4,7 @@ import { cabinetDefinition, cabinetModuleDefinition } from './cabinet';
 import { ceilingDefinition } from './ceiling';
 import { chimneyDefinition } from './chimney';
 import { columnDefinition } from './column';
+import { constructionDimensionDefinition } from './construction-dimension';
 import { cupolaDefinition } from './cupola';
 import { doorDefinition } from './door';
 import { dormerDefinition } from './dormer';
@@ -37,6 +38,7 @@ import { solarPanelDefinition } from './solar-panel';
 import { spawnDefinition } from './spawn';
 import { stairDefinition } from './stair';
 import { stairSegmentDefinition } from './stair-segment';
+import { structuralGridDefinition } from './structural-grid';
 import { turbineVentDefinition } from './turbine-vent';
 import { wallDefinition } from './wall';
 import { windowDefinition } from './window';
@@ -88,6 +90,8 @@ export const builtinPlugin = {
         guideDefinition,
         scanDefinition,
         measurementDefinition,
+        constructionDimensionDefinition,
+        structuralGridDefinition,
         // Roof-mounted accessories (custom renderer + bespoke roof-event tool).
         boxVentDefinition,
         ridgeVentDefinition,
@@ -119,6 +123,7 @@ export { bakeCabinetAnimationClip, cabinetDefinition, cabinetModuleDefinition, p
 export { ceilingDefinition } from './ceiling';
 export { chimneyDefinition } from './chimney';
 export { columnDefinition } from './column';
+export { constructionDimensionDefinition } from './construction-dimension';
 export { cupolaDefinition } from './cupola';
 export { doorDefinition } from './door';
 export { dormerDefinition } from './dormer';
@@ -152,6 +157,7 @@ export { solarPanelDefinition } from './solar-panel';
 export { spawnDefinition } from './spawn';
 export { stairDefinition } from './stair';
 export { stairSegmentDefinition } from './stair-segment';
+export { structuralGridDefinition } from './structural-grid';
 export { turbineVentDefinition } from './turbine-vent';
 export { wallDefinition } from './wall';
 export { windowDefinition } from './window';

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/item/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAKzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AA+HnC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CA0K1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/item/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAMzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AA+HnC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAgL1D,CAAA"}

package/dist/item/definition.js

@@ -1,5 +1,5 @@
 import { getScaledDimensions, } from '@pascal-app/core';
-import { buildItemFloorplan } from './floorplan';
+import { buildItemContextualDimensions, buildItemFloorplan } from './floorplan';
 import { itemFloorplanMoveTarget } from './floorplan-move';
 import { itemPaint } from './paint';
 import { itemParametrics } from './parametrics';
@@ -158,6 +158,11 @@ export const itemDefinition = {
     schema: ItemNode,
     category: 'furnish',
     surfaceRole: 'furnishing',
+    extensions: {
+        'pascal:editor/floorplan': {
+            contextualDimensions: buildItemContextualDimensions,
+        },
+    },
     // Defaults shape is cast: the schema requires a fully-typed `asset`
     // field, but in practice items are always created from the catalog
     // (the asset is supplied at placement time). `createNode` re-parses
@@ -261,6 +266,7 @@ export const itemDefinition = {
         kind: 'parametric',
         module: () => import('./renderer'),
     },
+    preview: () => import('./renderer').then(({ ItemPreview }) => ({ default: ItemPreview })),
     system: {
         module: () => import('./system'),
         // Same priority as the legacy ItemSystem.

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/item/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,mBAAmB,EAIxB,KAAK,QAAQ,EAKd,MAAM,kBAAkB,CAAA;AAkJzB,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CA+BjE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/item/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,mBAAmB,EAIxB,KAAK,QAAQ,EAMd,MAAM,kBAAkB,CAAA;AAkJzB,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CA+BjE,CAAA"}

package/dist/item/floorplan-move.js

@@ -1,4 +1,4 @@
-import { collectAlignmentAnchors, getRoofWallFaceFrame, getScaledDimensions, movingFootprintAnchors, roofFacePointToSegment, useScene, } from '@pascal-app/core';
+import { collectAlignmentAnchors, getRoofWallFaceFrame, getScaledDimensions, movingFootprintAnchors, roofFacePointToSegment, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { applyFloorplanAlignment, isGridSnapActive, isMagneticSnapActive, useEditor, } from '@pascal-app/editor';
 import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
 import { findClosestWallInPlan, snapLocalXToNeighbors } from '../shared/wall-attach-target';
@@ -125,6 +125,7 @@ function buildWallItemSession(node, startLevelId) {
         original: resolveItemPlanPoint(node, useScene.getState().nodes),
         metadata: node.metadata,
     });
+    let lastPatch = null;
     return {
         affectedIds: [node.id],
         apply({ planPoint }) {
@@ -151,25 +152,25 @@ function buildWallItemSession(node, startLevelId) {
             const snappedLocalX = neighborX ?? (step <= 0 ? hit.localX : Math.round(hit.localX / step) * step);
             const halfW = width / 2;
             const clampedX = Math.max(halfW, Math.min(hit.wallLength - halfW, snappedLocalX));
-            useScene.getState().updateNodes([
-                {
-                    id: node.id,
-                    data: {
-                        position: [clampedX, startLocalY, 0],
-                        rotation: [0, hit.itemRotation, 0],
-                        side: hit.side,
-                        parentId: hit.wall.id,
-                        // Re-anchoring to a wall ends any roof-segment hosting; the
-                        // overlay's snapshot restores it if the move is reverted.
-                        roofSegmentId: undefined,
-                        roofFace: undefined,
-                    },
-                },
-            ]);
+            lastPatch = {
+                position: [clampedX, startLocalY, 0],
+                rotation: [0, hit.itemRotation, 0],
+                side: hit.side,
+                parentId: hit.wall.id,
+                roofSegmentId: undefined,
+                roofFace: undefined,
+            };
+            useLiveNodeOverrides.getState().set(node.id, lastPatch);
+            useScene.getState().markDirty(node.id);
         },
         canCommit() {
-            const live = useScene.getState().nodes[node.id];
-            return !!live && live.type === 'item' && !!live.parentId;
+            return !!lastPatch?.parentId;
+        },
+        commit() {
+            if (!lastPatch)
+                return;
+            useLiveNodeOverrides.getState().clear(node.id);
+            useScene.getState().updateNodes([{ id: node.id, data: lastPatch }]);
         },
     };
 }
@@ -190,6 +191,7 @@ function buildFloorItemSession(node, startLevelId, nodes) {
     const resolvePlanPoint = createPlanarMovePointResolver(resolveItemPlanPoint(node, nodes), node);
     // Alignment candidates gathered once — scene is stable during the drag.
     const candidates = collectAlignmentAnchors(nodes, node.id);
+    let lastPatch = null;
     return {
         affectedIds: [node.id],
         apply({ planPoint }) {
@@ -200,22 +202,24 @@ function buildFloorItemSession(node, startLevelId, nodes) {
             const { point: snapped } = applyFloorplanAlignment(gridSnapped, movingFootprintAnchors(node, gridSnapped[0], gridSnapped[1], rotationY), candidates, { applySnap: isMagneticSnapActive() });
             const sourceY = node.position[1];
             const nextPosition = [snapped[0], sourceY, snapped[1]];
-            useScene.getState().updateNodes([
-                {
-                    id: node.id,
-                    data: {
-                        position: nextPosition,
-                        // Keep parent as the level we resolved at session-start. If
-                        // somehow it's null (e.g. orphaned item), fall back to the
-                        // existing parent so we don't write `null` and detach.
-                        parentId: startLevelId ?? node.parentId,
-                    },
-                },
-            ]);
+            lastPatch = {
+                position: nextPosition,
+                // Keep parent as the level we resolved at session-start. If
+                // somehow it's null (e.g. orphaned item), fall back to the
+                // existing parent so we don't write `null` and detach.
+                parentId: startLevelId ?? node.parentId,
+            };
+            useLiveNodeOverrides.getState().set(node.id, lastPatch);
+            useScene.getState().markDirty(node.id);
         },
         canCommit() {
-            const live = useScene.getState().nodes[node.id];
-            return !!live && live.type === 'item';
+            return lastPatch !== null;
+        },
+        commit() {
+            if (!lastPatch)
+                return;
+            useLiveNodeOverrides.getState().clear(node.id);
+            useScene.getState().updateNodes([{ id: node.id, data: lastPatch }]);
         },
     };
 }
@@ -229,6 +233,7 @@ function buildFloorItemSession(node, startLevelId, nodes) {
  */
 function buildSurfaceItemSession(node, startLevelId, targetKind) {
     const resolvePlanPoint = createPlanarMovePointResolver(resolveItemPlanPoint(node, useScene.getState().nodes), node);
+    let lastPatch = null;
     return {
         affectedIds: [node.id],
         apply({ planPoint }) {
@@ -237,19 +242,21 @@ function buildSurfaceItemSession(node, startLevelId, targetKind) {
             const surface = findContainingSurface(snapped, nodes, startLevelId, targetKind);
             const sourceY = node.position[1];
             const nextPosition = [snapped[0], sourceY, snapped[1]];
-            useScene.getState().updateNodes([
-                {
-                    id: node.id,
-                    data: {
-                        position: nextPosition,
-                        parentId: surface ? surface.id : node.parentId,
-                    },
-                },
-            ]);
+            lastPatch = {
+                position: nextPosition,
+                parentId: surface ? surface.id : node.parentId,
+            };
+            useLiveNodeOverrides.getState().set(node.id, lastPatch);
+            useScene.getState().markDirty(node.id);
         },
         canCommit() {
-            const live = useScene.getState().nodes[node.id];
-            return !!live && live.type === 'item';
+            return lastPatch !== null;
+        },
+        commit() {
+            if (!lastPatch)
+                return;
+            useLiveNodeOverrides.getState().clear(node.id);
+            useScene.getState().updateNodes([{ id: node.id, data: lastPatch }]);
         },
     };
 }

package/dist/item/floorplan.d.ts

@@ -1,3 +1,4 @@
 import { type FloorplanGeometry, type GeometryContext, type ItemNode } from '@pascal-app/core';
+export declare function buildItemContextualDimensions(node: ItemNode, ctx: GeometryContext): FloorplanGeometry | null;
 export declare function buildItemFloorplan(node: ItemNode, ctx: GeometryContext): FloorplanGeometry | null;
 //# sourceMappingURL=floorplan.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/item/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAGpB,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AA+IzB,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAmGjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/item/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAGpB,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AAgJzB,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA+C1B;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAmGjG"}

package/dist/item/floorplan.js

@@ -1,4 +1,5 @@
 import { getRoofWallFaceFrame, getScaledDimensions, roofFacePointToSegment, useLiveTransforms, } from '@pascal-app/core';
+import { formatLinearMeasurement, readFloorplanMetricNotationOverride } from '@pascal-app/editor';
 // Plan-space rotation convention used by the legacy `rotatePlanVector`
 // in `editor/src/lib/floorplan/geometry.ts`. This is a CLOCKWISE rotation
 // — the registry-side equivalent of the canonical floor-plan transform
@@ -104,6 +105,54 @@ function resolveItemTransform(item, ctx, cache = new Map()) {
     cache.set(item.id, result);
     return result;
 }
+export function buildItemContextualDimensions(node, ctx) {
+    const transform = resolveItemTransform(node, ctx);
+    if (!transform)
+        return null;
+    const [width, , depth] = getScaledDimensions(node);
+    if (width <= 1e-6 || depth <= 1e-6)
+        return null;
+    const centerLocalZ = node.asset.attachTo === 'wall-side' ? depth / 2 : 0;
+    const [centerOffsetX, centerOffsetY] = rotateVec(0, centerLocalZ, transform.rotation);
+    const cx = transform.x + centerOffsetX;
+    const cy = transform.y + centerOffsetY;
+    const halfWidth = width / 2;
+    const halfDepth = depth / 2;
+    const point = (x, y) => {
+        const [rx, ry] = rotateVec(x, y, transform.rotation);
+        return [cx + rx, cy + ry];
+    };
+    const widthNormal = rotateVec(0, -1, transform.rotation);
+    const depthNormal = rotateVec(1, 0, transform.rotation);
+    const unit = ctx.viewState?.unit ?? 'metric';
+    const metricNotation = readFloorplanMetricNotationOverride(ctx) ?? 'meters';
+    const stroke = ctx.viewState?.palette?.selectedStroke ?? '#2563eb';
+    return {
+        kind: 'group',
+        children: [
+            {
+                kind: 'dimension',
+                start: point(-halfWidth, -halfDepth),
+                end: point(halfWidth, -halfDepth),
+                offsetNormal: widthNormal,
+                offsetDistance: 0.28,
+                extensionOvershoot: 0.08,
+                text: formatLinearMeasurement(width, unit, metricNotation),
+                stroke,
+            },
+            {
+                kind: 'dimension',
+                start: point(halfWidth, -halfDepth),
+                end: point(halfWidth, halfDepth),
+                offsetNormal: depthNormal,
+                offsetDistance: 0.28,
+                extensionOvershoot: 0.08,
+                text: formatLinearMeasurement(depth, unit, metricNotation),
+                stroke,
+            },
+        ],
+    };
+}
 export function buildItemFloorplan(node, ctx) {
     const transform = resolveItemTransform(node, ctx);
     if (!transform)

package/dist/item/renderer.d.ts

@@ -2,5 +2,8 @@ import { type ItemNode } from '@pascal-app/core';
 export declare const ItemRenderer: ({ node: storeNode }: {
     node: ItemNode;
 }) => import("react").JSX.Element;
+export declare const ItemPreview: ({ node }: {
+    node: ItemNode;
+}) => import("react").JSX.Element;
 export default ItemRenderer;
 //# sourceMappingURL=renderer.d.ts.map