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

package/dist/window/contextual-dimensions.js

@@ -0,0 +1,7 @@
+import { buildWallHostedOpeningContextualDimensions } from '../wall/contextual-dimensions';
+export function buildWindowContextualDimensions(node, ctx) {
+    return buildWallHostedOpeningContextualDimensions(node, ctx, {
+        showClearancesWhileMoving: true,
+        useExteriorNormal: true,
+    });
+}

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/window/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,cAAc,EAIf,MAAM,kBAAkB,CAAA;AAUzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAwIrC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CA6F9D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/window/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,cAAc,EAIf,MAAM,kBAAkB,CAAA;AAiBzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAkIrC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAqG9D,CAAA"}

package/dist/window/definition.js

@@ -1,7 +1,10 @@
+import { buildWindowFloorplanSchedule, computeWindowFloorplanLevelData, } from '../shared/opening-documentation';
 import { publishOpeningResizeGuides } from '../shared/opening-guides-runtime';
 import { readRoofFaceHeightMax, readRoofFaceWidthMax } from '../shared/roof-opening-host';
 import { buildRoofWallOpeningCut } from '../shared/roof-wall-opening-cut';
+import { readHostWallCeiling } from '../shared/wall-opening-ceiling';
 import { wallFloorplanSiblingOverrides } from '../wall/floorplan-overrides';
+import { buildWindowContextualDimensions } from './contextual-dimensions';
 import { buildWindowFloorplan } from './floorplan';
 import { windowWidthAffordance } from './floorplan-affordances';
 import { windowFloorplanMoveTarget } from './floorplan-move';
@@ -24,12 +27,6 @@ function readWallLength(w, scene) {
         return Number.POSITIVE_INFINITY;
     return Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
 }
-function readWallHeight(w, scene) {
-    if (!w.wallId)
-        return Number.POSITIVE_INFINITY;
-    const wall = scene.get(w.wallId);
-    return wall?.height ?? Number.POSITIVE_INFINITY;
-}
 function windowWidthHandle(side) {
     const sign = side === 'right' ? 1 : -1;
     return {
@@ -88,9 +85,9 @@ function windowHeightHandle(edge) {
             if (roofMax !== null)
                 return Math.max(MIN_WINDOW_HEIGHT, roofMax);
             // Maximum: distance from the anchored edge to the wall's allowed Y
-            // bounds. Top arrow caps at wall.height - bottom; bottom arrow caps
-            // at top (positive Y room above the floor).
-            const wallH = readWallHeight(n, scene);
+            // bounds. Top arrow caps at the wall's resolved ceiling - bottom;
+            // bottom arrow caps at top (positive Y room above the floor).
+            const wallH = readHostWallCeiling(n.wallId, scene);
             const anchored = edge === 'top' ? n.position[1] - n.height / 2 : n.position[1] + n.height / 2;
             return edge === 'top'
                 ? Math.max(MIN_WINDOW_HEIGHT, wallH - anchored)
@@ -154,9 +151,15 @@ export const windowDefinition = {
     kind: 'window',
     snapProfile: 'item',
     facingIndicator: true,
-    schemaVersion: 1,
+    schemaVersion: 2,
     schema: WindowNode,
     category: 'structure',
+    extensions: {
+        'pascal:editor/floorplan': {
+            contextualDimensions: buildWindowContextualDimensions,
+            schedule: buildWindowFloorplanSchedule,
+        },
+    },
     // Same schema-driven defaults trick as door: parse a stub, strip
     // id/type. Window also has many fields with zod `.default()` set.
     defaults: () => {
@@ -191,6 +194,7 @@ export const windowDefinition = {
         kind: 'parametric',
         module: () => import('./renderer'),
     },
+    preview: () => import('./preview'),
     system: {
         module: () => import('./system'),
         priority: 3,
@@ -198,6 +202,7 @@ export const windowDefinition = {
     // Stage C: floor-plan polygon. ctx.parent gives the wall for direction
     // + thickness — same shape as door.
     floorplan: buildWindowFloorplan,
+    computeFloorplanLevelData: computeWindowFloorplanLevelData,
     floorplanDependsOnSiblings: true,
     // Opening symbols position from `ctx.parent` (the host wall); merge the
     // walls' live drag overrides so the symbol tracks a wall / group drag in

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

@@ -12,11 +12,8 @@ import { type FloorplanAffordance, type WindowNode } from '@pascal-app/core';
  *   - `'end'`: arrow at the edge closer to `wall.end`. The wall-start
  *     edge stays fixed.
  *
- * Uses the scene-write preview pattern (writes directly to `useScene`
- * each tick): the registry layer's `effectiveNode` only merges live
- * overrides for walls, so an override-based preview wouldn't show on
- * windows. The dispatcher snapshots / pauses history at start, so
- * per-tick scene writes still collapse to one undoable entry on commit.
+ * Preview state stays in the live override store so the scene graph is
+ * written only once, when the drag commits.
  */
 export declare const windowWidthAffordance: FloorplanAffordance<WindowNode>;
 //# sourceMappingURL=floorplan-affordances.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/window/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAIxB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAMzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,UAAU,CAwEjE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/window/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAKxB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAMzB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,UAAU,CAqEjE,CAAA"}

package/dist/window/floorplan-affordances.js

@@ -1,4 +1,4 @@
-import { useScene, } from '@pascal-app/core';
+import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 const MIN_WINDOW_WIDTH = 0.3;
 /**
  * 2D drag affordance for the window's width side-arrows. Sister to the 3D
@@ -13,11 +13,8 @@ const MIN_WINDOW_WIDTH = 0.3;
  *   - `'end'`: arrow at the edge closer to `wall.end`. The wall-start
  *     edge stays fixed.
  *
- * Uses the scene-write preview pattern (writes directly to `useScene`
- * each tick): the registry layer's `effectiveNode` only merges live
- * overrides for walls, so an override-based preview wouldn't show on
- * windows. The dispatcher snapshots / pauses history at start, so
- * per-tick scene writes still collapse to one undoable entry on commit.
+ * Preview state stays in the live override store so the scene graph is
+ * written only once, when the drag commits.
  */
 export const windowWidthAffordance = {
     start({ node, payload, nodes, initialPlanPoint }) {
@@ -53,20 +50,17 @@ export const windowWidthAffordance = {
                 const newWindowX = anchorX + growDir * (newWidth / 2);
                 lastWidth = newWidth;
                 lastWindowX = newWindowX;
-                useScene.getState().updateNodes([
-                    {
-                        id: windowId,
-                        data: {
-                            width: newWidth,
-                            position: [newWindowX, initialWindowY, initialWindowZ],
-                        },
-                    },
-                ]);
+                useLiveNodeOverrides.getState().set(windowId, {
+                    width: newWidth,
+                    position: [newWindowX, initialWindowY, initialWindowZ],
+                });
+                useScene.getState().markDirty(windowId);
             },
             canCommit() {
                 return true;
             },
             commit() {
+                useLiveNodeOverrides.getState().clear(windowId);
                 useScene.getState().updateNodes([
                     {
                         id: windowId,

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/window/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAOxB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAmBzB;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CAgPrE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/window/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAOxB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAmBzB;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CAiPrE,CAAA"}

package/dist/window/floorplan-move.js

@@ -152,7 +152,7 @@ export const windowFloorplanMoveTarget = ({ node }) => {
                     nodes,
                 });
             const snappedLocalX = neighborX ?? snapToHalf(hit.localX);
-            const { clampedX, clampedY } = clampToWall(hit.wall, snappedLocalX, startLocalY, node.width, node.height);
+            const { clampedX, clampedY } = clampToWall(hit.wall, snappedLocalX, startLocalY, node.width, node.height, nodes);
             // One click per real position step, keyed on the SNAPPED along-wall value
             // so it ticks only when the window actually moves to a new cell.
             tickGridStep(clampedX);

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/window/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EAEjB,eAAe,EAEf,UAAU,EACX,MAAM,kBAAkB,CAAA;AAGzB;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAmJ1B"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/window/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EAEjB,eAAe,EAEf,UAAU,EACX,MAAM,kBAAkB,CAAA;AAQzB;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA4J1B"}

package/dist/window/floorplan.js

@@ -1,3 +1,5 @@
+import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
+import { buildOpeningMarkAnnotation, } from '../shared/opening-documentation';
 import { buildOpeningPlacementDimensions } from '../shared/opening-placement-dimensions';
 /**
  * Stage C floor-plan builder for window. Mirrors the legacy
@@ -84,6 +86,7 @@ export function buildWindowFloorplan(node, ctx) {
             strokeWidth: showSelectedChrome ? 1.9 : 1.25,
             vectorEffect: 'non-scaling-stroke',
             strokeLinejoin: 'round',
+            metadata: floorplanGeometryMetadata({ annotationObstacle: 'bounds' }),
         },
         // Inset glass-pane outline.
         {
@@ -142,10 +145,13 @@ export function buildWindowFloorplan(node, ctx) {
     }
     // Placement-measurement dimensions when actively moving — same
     // contract as door (see `nodes/src/door/floorplan.ts`).
-    if (view?.moving) {
+    if (view?.moving && readFloorplanContext(ctx).automaticDimensions) {
         for (const dim of buildOpeningPlacementDimensions(node, ctx)) {
             children.push(dim);
         }
     }
+    const markAnnotation = buildOpeningMarkAnnotation(node, wall, ctx.levelData, { stroke: showSelectedChrome ? '#f97316' : '#334155' });
+    if (markAnnotation)
+        children.push(markAnnotation);
     return { kind: 'group', children };
 }

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

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/window/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAYL,UAAU,EACX,MAAM,kBAAkB,CAAA;AAqDzB;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CA0/BlD,CAAA;AAED,eAAe,cAAc,CAAA"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/window/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAYL,UAAU,EACX,MAAM,kBAAkB,CAAA;AAqDzB;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAigClD,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/window/move-tool.js

@@ -174,7 +174,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             const y = movingWindowNode.position[1];
             return y > 0.1 ? y : DEFAULT_WINDOW_SILL_M + movingWindowNode.height / 2;
         };
-        const getSlabElevation = (wallEvent) => spatialGridManager.getSlabElevationForWall(wallEvent.node.parentId ?? '', wallEvent.node.start, wallEvent.node.end);
+        const getSlabElevation = (wallEvent) => spatialGridManager.getSlabElevationForWall(wallEvent.node.parentId ?? '', wallEvent.node.start, wallEvent.node.end, wallEvent.node.curveOffset ?? 0, wallEvent.node.thickness, wallEvent.node.supportSlabId);
         const hideCursor = () => {
             if (cursorGroupRef.current)
                 cursorGroupRef.current.visible = false;
@@ -256,7 +256,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 // component lives in `snapToHalf` (itself mode-aware).
                 applySnap: isMagneticSnapActive(),
             });
-            const { clampedX, clampedY } = clampToWall(event.node, localX, targetLocalY, movingWindowNode.width, movingWindowNode.height);
+            const { clampedX, clampedY } = clampToWall(event.node, localX, targetLocalY, movingWindowNode.width, movingWindowNode.height, useScene.getState().nodes);
             const valid = !hasWallChildOverlap(event.node.id, clampedX, clampedY, movingWindowNode.width, movingWindowNode.height, movingWindowNode.id);
             return {
                 wallNode: event.node,
@@ -838,7 +838,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             if (hostWall?.type === 'wall') {
                 const wallAngle = Math.atan2(hostWall.end[1] - hostWall.start[1], hostWall.end[0] - hostWall.start[0]);
                 const ghostYaw = movingWindowNode.rotation[1] - wallAngle;
-                const seedPos = wallLocalToWorld(hostWall, movingWindowNode.position[0], movingWindowNode.position[1], getLevelYOffset(), spatialGridManager.getSlabElevationForWall(hostWall.parentId ?? '', hostWall.start, hostWall.end));
+                const seedPos = wallLocalToWorld(hostWall, movingWindowNode.position[0], movingWindowNode.position[1], getLevelYOffset(), spatialGridManager.getSlabElevationForWall(hostWall.parentId ?? '', hostWall.start, hostWall.end, hostWall.curveOffset ?? 0, hostWall.thickness, hostWall.supportSlabId));
                 publishPlacementSurface(new Vector3(...seedPos), new Vector3(Math.sin(ghostYaw), 0, Math.cos(ghostYaw)));
                 // Claim the pointer for the wall so the floor free-follow stands down for
                 // the first frames after grab. Otherwise the first `grid:move` (the window

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/window/panel.tsx"],"names":[],"mappings":"AA4FA,MAAM,CAAC,OAAO,UAAU,WAAW,uCAw0BlC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/window/panel.tsx"],"names":[],"mappings":"AA6FA,MAAM,CAAC,OAAO,UAAU,WAAW,uCAy1BlC"}

package/dist/window/panel.js

@@ -5,6 +5,7 @@ import { ActionButton, ActionGroup, cn, PanelSection, PanelWrapper, SegmentedCon
 import { useViewer } from '@pascal-app/viewer';
 import { Copy, FlipHorizontal2, Move, Trash2 } from 'lucide-react';
 import { useCallback, useRef } from 'react';
+import { OpeningDocumentationFields } from '../shared/opening-documentation-fields';
 function isSameWindowValue(current, next) {
     if (typeof current === 'number' && typeof next === 'number') {
         return Math.abs(current - next) < 1e-6;
@@ -153,6 +154,8 @@ export default function WindowPanel() {
             parentId: node.parentId,
             width: node.width,
             height: node.height,
+            roughOpeningWidth: node.roughOpeningWidth,
+            roughOpeningHeight: node.roughOpeningHeight,
             windowType: node.windowType,
             operationState: node.operationState,
             awningDirection: node.awningDirection,
@@ -314,7 +317,7 @@ export default function WindowPanel() {
                     }), options: [
                         { value: 'window', label: 'Window' },
                         { value: 'opening', label: 'Opening' },
-                    ], value: node.openingKind ?? 'window' }) }), showWindowTypeSection && (_jsxs(PanelSection, { title: "Window Type", children: [_jsx("div", { className: "grid grid-cols-2 gap-2 px-1 pt-1", children: windowTypeOptions.map((option) => {
+                    ], value: node.openingKind ?? 'window' }) }), _jsx(PanelSection, { title: "Documentation", children: _jsx(OpeningDocumentationFields, { constructionType: node.constructionType, dimensionReference: node.dimensionReference, finishOpeningHeight: node.finishOpeningHeight, finishOpeningWidth: node.finishOpeningWidth, mark: node.mark, masonryOpeningHeight: node.masonryOpeningHeight, masonryOpeningWidth: node.masonryOpeningWidth, onChange: handleUpdate, roughOpeningHeight: node.roughOpeningHeight, roughOpeningWidth: node.roughOpeningWidth }) }), showWindowTypeSection && (_jsxs(PanelSection, { title: "Window Type", children: [_jsx("div", { className: "grid grid-cols-2 gap-2 px-1 pt-1", children: windowTypeOptions.map((option) => {
                             const isSelected = displayedWindowType === option.value;
                             return (_jsx("button", { className: cn('flex min-h-12 items-center rounded-lg border px-3 py-2.5 text-left text-xs transition-colors', isSelected
                                     ? 'border-orange-400/60 bg-orange-400/10 text-foreground'

package/dist/window/schema.d.ts

@@ -1,2 +1,2 @@
-export { WindowNode } from '@pascal-app/core';
+export { WindowConstructionType, WindowDimensionReference, WindowNode, } from '@pascal-app/core';
 //# sourceMappingURL=schema.d.ts.map

package/dist/window/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/window/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/window/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,wBAAwB,EACxB,UAAU,GACX,MAAM,kBAAkB,CAAA"}

package/dist/window/schema.js

@@ -1 +1 @@
-export { WindowNode } from '@pascal-app/core';
+export { WindowConstructionType, WindowDimensionReference, WindowNode, } from '@pascal-app/core';

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/window/tool.tsx"],"names":[],"mappings":"AA6EA;;;;;;;;;GASG;AACH,QAAA,MAAM,UAAU,EAAE,KAAK,CAAC,EAuqBvB,CAAA;AAED,eAAe,UAAU,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/window/tool.tsx"],"names":[],"mappings":"AAgFA;;;;;;;;;GASG;AACH,QAAA,MAAM,UAAU,EAAE,KAAK,CAAC,EA6uBvB,CAAA;AAED,eAAe,UAAU,CAAA"}

package/dist/window/tool.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { emitter, isCurvedWall, sceneRegistry, spatialGridManager, useScene, WindowNode, } from '@pascal-app/core';
-import { calculateCursorRotation, calculateItemRotation, EDITOR_LAYER, getSideFromNormal, isMagneticSnapActive, isValidWallSideFace, snapToHalf, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, } from '@pascal-app/editor';
+import { emitter, isCurvedWall, sceneRegistry, spatialGridManager, useScene, WallNode as WallNodeSchema, WindowNode, } from '@pascal-app/core';
+import { calculateCursorRotation, calculateItemRotation, EDITOR_LAYER, getSideFromNormal, isMagneticSnapActive, isValidWallSideFace, snapToHalf, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, usePlacementPreview, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { BoxGeometry, EdgesGeometry, Vector3 } from 'three';
@@ -58,6 +58,36 @@ const WindowTool = () => {
     const frameDepthRef = useRef(ghostStub.frameDepth);
     useEffect(() => {
         useScene.temporal.getState().pause();
+        const ownedPreviewIds = new Set();
+        const fallbackPreview = WindowNode.parse({
+            position: [0, 0, 0],
+            rotation: [0, 0, 0],
+            side: 'front',
+        });
+        const fallbackWallId = WallNodeSchema.parse({
+            end: [1, 0],
+            start: [0, 0],
+            thickness: 0.1,
+        }).id;
+        const publishPlacementPreview = (node, parentNode) => {
+            ownedPreviewIds.add(node.id);
+            usePlacementPreview.getState().set(node, parentNode);
+        };
+        const clearPlacementPreview = () => {
+            const current = usePlacementPreview.getState().node;
+            if (current && ownedPreviewIds.has(current.id))
+                usePlacementPreview.getState().clear();
+        };
+        const publishDraftPreview = (parentNode) => {
+            const draft = draftRef.current;
+            if (!draft)
+                return;
+            const live = useScene.getState().nodes[draft.id];
+            if (live?.type !== 'window')
+                return;
+            draftRef.current = live;
+            publishPlacementPreview(live, parentNode);
+        };
         let hostKind = null;
         // timeStamp of the most recent wall/roof mesh event. A wall/roof hover and
         // the grid raycast from the SAME pointermove share the source DOM event's
@@ -78,16 +108,20 @@ const WindowTool = () => {
             const id = getLevelId();
             return id ? (sceneRegistry.nodes.get(id)?.position.y ?? 0) : 0;
         };
-        const getSlabElevationForWall = (wall) => spatialGridManager.getSlabElevationForWall(wall.parentId ?? '', wall.start, wall.end);
+        const getSlabElevationForWall = (wall) => spatialGridManager.getSlabElevationForWall(wall.parentId ?? '', wall.start, wall.end, wall.curveOffset ?? 0, wall.thickness, wall.supportSlabId);
         const markHostDirty = (hostId) => {
             useScene.getState().dirtyNodes.add(hostId);
         };
         const destroyDraft = () => {
-            if (!draftRef.current)
+            const draft = draftRef.current;
+            if (!draft) {
+                clearPlacementPreview();
                 return;
-            const wallId = draftRef.current.parentId;
-            useScene.getState().deleteNode(draftRef.current.id);
+            }
+            const wallId = draft.parentId;
+            useScene.getState().deleteNode(draft.id);
             draftRef.current = null;
+            clearPlacementPreview();
             // Rebuild wall so it removes the cutout from the deleted draft
             if (wallId)
                 markHostDirty(wallId);
@@ -99,6 +133,7 @@ const WindowTool = () => {
             clearOpeningGuides3D();
             setFallbackPose(null);
             useFacingPose.getState().clear();
+            clearPlacementPreview();
         };
         // Alignment candidates — anchors of every alignable object; refreshed
         // after each placement. A window aligns by the plan position of its centre
@@ -138,6 +173,23 @@ const WindowTool = () => {
                 floorY,
                 side: sideFlip ? 'back' : 'front',
             });
+            const halfWidth = fallbackPreview.width / 2 + 0.5;
+            const wall = WallNodeSchema.parse({
+                end: [position[0] + halfWidth, position[2]],
+                id: fallbackWallId,
+                start: [position[0] - halfWidth, position[2]],
+                thickness: 0.1,
+            });
+            const ghost = WindowNode.parse({
+                ...fallbackPreview,
+                metadata: { isTransient: true },
+                parentId: wall.id,
+                position: [halfWidth, FALLBACK_SILL_LIFT + fallbackPreview.height / 2, 0],
+                rotation: [0, sideFlip ? Math.PI : 0, 0],
+                side: sideFlip ? 'back' : 'front',
+                wallId: wall.id,
+            });
+            publishPlacementPreview(ghost, wall);
             useAlignmentGuides.getState().clear();
             clearOpeningGuides3D();
             // Off-host (invalid) floating ghost — no direction triangle.
@@ -191,7 +243,7 @@ const WindowTool = () => {
                 width,
                 height,
             });
-            const { clampedX, clampedY } = clampToWall(wall, localX, localY, width, height);
+            const { clampedX, clampedY } = clampToWall(wall, localX, localY, width, height, useScene.getState().nodes);
             const valid = !hasWallChildOverlap(wall.id, clampedX, clampedY, width, height, ignoreId);
             return { clampedX, clampedY, valid };
         };
@@ -236,6 +288,7 @@ const WindowTool = () => {
                     roofFace: undefined,
                 });
             }
+            publishDraftPreview(wall);
             updateCursor(wallLocalToWorld(wall, clampedX, clampedY, getLevelYOffset(), getSlabElevationForWall(wall)), cursorRotationY, valid, -clampedY);
             if (draftRef.current) {
                 publishOpeningGuidesForWallEvent({
@@ -258,6 +311,7 @@ const WindowTool = () => {
             const draft = draftRef.current;
             if (!draft)
                 return;
+            clearPlacementPreview();
             draftRef.current = null;
             hostKind = null;
             useScene.getState().deleteNode(draft.id);
@@ -438,6 +492,7 @@ const WindowTool = () => {
                 useScene.getState().createNode(node, segment.id);
                 draftRef.current = node;
             }
+            publishDraftPreview(segment);
             // Opening guides are wall-specific; clear them while over a roof face.
             clearOpeningGuides3D();
             updateRoofCursor(target, event.node);
@@ -454,6 +509,7 @@ const WindowTool = () => {
                 return;
             const { segment, face, position } = target;
             const draft = draftRef.current;
+            clearPlacementPreview();
             draftRef.current = null;
             hostKind = null;
             useScene.getState().deleteNode(draft.id);
@@ -549,6 +605,7 @@ const WindowTool = () => {
         return () => {
             destroyDraft();
             hideCursor();
+            clearPlacementPreview();
             useAlignmentGuides.getState().clear();
             clearOpeningGuides3D();
             useScene.temporal.getState().resume();

package/dist/window/window-math.d.ts

@@ -1,4 +1,4 @@
-import type { WallNode } from '@pascal-app/core';
+import type { AnyNode, AnyNodeId, WallNode } from '@pascal-app/core';
 /**
  * Default sill height (metres from the floor to the BOTTOM of a window) for a
  * fresh window that has no wall-face height yet — the off-wall ghost and the
@@ -16,9 +16,13 @@ export declare const DEFAULT_WINDOW_SILL_M = 0.5;
  */
 export declare function wallLocalToWorld(wallNode: WallNode, localX: number, localY: number, levelYOffset?: number, slabElevation?: number): [number, number, number];
 /**
- * Clamps window center position so it stays fully within wall bounds.
+ * Clamps window center position so it stays fully within wall bounds. The Y
+ * ceiling is the wall's RESOLVED top (storey plane for plane-bound walls,
+ * stored height for explicit ones, minus the elected slab base) — `nodes` is
+ * required because a plane-bound wall's top lives on its level, not on the
+ * wall record.
  */
-export declare function clampToWall(wallNode: WallNode, localX: number, localY: number, width: number, height: number): {
+export declare function clampToWall(wallNode: WallNode, localX: number, localY: number, width: number, height: number, nodes: Readonly<Record<AnyNodeId, AnyNode>>): {
     clampedX: number;
     clampedY: number;
 };

package/dist/window/window-math.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"window-math.d.ts","sourceRoot":"","sources":["../../src/window/window-math.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEhD;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAA;AAExC;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,YAAY,SAAI,EAChB,aAAa,SAAI,GAChB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAU1B;AAED;;GAEG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CASxC;AAED;;;;GAIG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA"}
+{"version":3,"file":"window-math.d.ts","sourceRoot":"","sources":["../../src/window/window-math.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAGpE;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAA;AAExC;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,YAAY,SAAI,EAChB,aAAa,SAAI,GAChB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAU1B;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CASxC;AAED;;;;GAIG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA"}

package/dist/window/window-math.js

@@ -1,3 +1,4 @@
+import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
 /**
  * Default sill height (metres from the floor to the BOTTOM of a window) for a
  * fresh window that has no wall-face height yet — the off-wall ghost and the
@@ -22,13 +23,17 @@ export function wallLocalToWorld(wallNode, localX, localY, levelYOffset = 0, sla
     ];
 }
 /**
- * Clamps window center position so it stays fully within wall bounds.
+ * Clamps window center position so it stays fully within wall bounds. The Y
+ * ceiling is the wall's RESOLVED top (storey plane for plane-bound walls,
+ * stored height for explicit ones, minus the elected slab base) — `nodes` is
+ * required because a plane-bound wall's top lives on its level, not on the
+ * wall record.
  */
-export function clampToWall(wallNode, localX, localY, width, height) {
+export function clampToWall(wallNode, localX, localY, width, height, nodes) {
     const dx = wallNode.end[0] - wallNode.start[0];
     const dz = wallNode.end[1] - wallNode.start[1];
     const wallLength = Math.sqrt(dx * dx + dz * dz);
-    const wallHeight = wallNode.height ?? 2.5;
+    const wallHeight = resolveWallOpeningCeiling(wallNode, nodes);
     const clampedX = Math.max(width / 2, Math.min(wallLength - width / 2, localX));
     const clampedY = Math.max(height / 2, Math.min(wallHeight - height / 2, localY));
     return { clampedX, clampedY };

package/dist/zone/contextual-dimensions.d.ts

@@ -0,0 +1,3 @@
+import { type FloorplanGeometry, type GeometryContext, type ZoneNode } from '@pascal-app/core';
+export declare function buildZoneContextualDimensions(node: ZoneNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=contextual-dimensions.d.ts.map

package/dist/zone/contextual-dimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextual-dimensions.d.ts","sourceRoot":"","sources":["../../src/zone/contextual-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAc1B"}

package/dist/zone/contextual-dimensions.js

@@ -0,0 +1,43 @@
+import { resolveAutoZonePolygon, } from '@pascal-app/core';
+import { formatAreaLabel } from '@pascal-app/editor';
+export function buildZoneContextualDimensions(node, ctx) {
+    const polygon = resolveAutoZonePolygon(node, ctx.resolve);
+    if (polygon.length < 3)
+        return null;
+    const { area, centroid } = polygonAreaAndCentroid(polygon);
+    if (area <= 1e-6)
+        return null;
+    return {
+        kind: 'dimension-label',
+        appearance: 'outlined',
+        cx: centroid[0],
+        cy: centroid[1],
+        text: formatAreaLabel(area, ctx.viewState?.unit ?? 'metric', 1),
+        angle: 0,
+    };
+}
+function polygonAreaAndCentroid(points) {
+    let twiceSignedArea = 0;
+    let weightedX = 0;
+    let weightedY = 0;
+    for (let index = 0; index < points.length; index += 1) {
+        const current = points[index];
+        const next = points[(index + 1) % points.length];
+        const cross = current[0] * next[1] - next[0] * current[1];
+        twiceSignedArea += cross;
+        weightedX += (current[0] + next[0]) * cross;
+        weightedY += (current[1] + next[1]) * cross;
+    }
+    const area = Math.abs(twiceSignedArea) / 2;
+    if (Math.abs(twiceSignedArea) <= 1e-9) {
+        const sum = points.reduce((acc, point) => [acc[0] + point[0], acc[1] + point[1]], [0, 0]);
+        return {
+            area,
+            centroid: [sum[0] / points.length, sum[1] / points.length],
+        };
+    }
+    return {
+        area,
+        centroid: [weightedX / (3 * twiceSignedArea), weightedY / (3 * twiceSignedArea)],
+    };
+}

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/zone/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAYzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAwE1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/zone/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAezB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CA8E1D,CAAA"}

package/dist/zone/definition.js

@@ -1,10 +1,12 @@
 import { resolveAutoZonePolygon, ZoneNode as ZoneNodeSchema, } from '@pascal-app/core';
 import { polygonMeasurementFeatures } from '../shared/polygon-measurement';
+import { buildZoneContextualDimensions } from './contextual-dimensions';
 import { buildZoneFloorplan } from './floorplan';
 import { zoneAddVertexAffordance, zoneDeleteVertexAffordance, zoneMoveEdgeAffordance, zoneMoveVertexAffordance, } from './floorplan-affordances';
 import { zoneFloorplanMoveTarget } from './floorplan-move';
 import { zoneParametrics } from './parametrics';
 import { zoneQuickMeasurement } from './quick-measurement';
+import { buildRoomFloorplanSchedule } from './room-documentation';
 import { ZoneNode } from './schema';
 /**
  * Zone — Stage A. Custom-behavior escape hatch: zone uses TSL shader
@@ -15,9 +17,15 @@ import { ZoneNode } from './schema';
 export const zoneDefinition = {
     kind: 'zone',
     snapProfile: 'structural',
-    schemaVersion: 1,
+    schemaVersion: 2,
     schema: ZoneNode,
     category: 'site',
+    extensions: {
+        'pascal:editor/floorplan': {
+            contextualDimensions: buildZoneContextualDimensions,
+            schedule: buildRoomFloorplanSchedule,
+        },
+    },
     defaults: () => {
         const stub = ZoneNodeSchema.parse({ id: 'zone_default', type: 'zone' });
         const { id: _id, type: _type, ...rest } = stub;