@pascal-app/nodes 1.0.0-beta.5 → 1.0.1

package/dist/wall/curve-eligibility.d.ts

@@ -0,0 +1,3 @@
+import type { AnyNode } from '@pascal-app/core';
+export declare function hasWallCurveBlockingChildren(children: readonly AnyNode[]): boolean;
+//# sourceMappingURL=curve-eligibility.d.ts.map

package/dist/wall/curve-eligibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curve-eligibility.d.ts","sourceRoot":"","sources":["../../src/wall/curve-eligibility.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAE/C,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,WAQxE"}

package/dist/wall/curve-eligibility.js

@@ -0,0 +1,10 @@
+export function hasWallCurveBlockingChildren(children) {
+    return children.some((child) => {
+        if (child.type === 'door' || child.type === 'window' || child.type === 'lean-to-extension') {
+            return true;
+        }
+        if (child.type !== 'item')
+            return false;
+        return child.asset?.attachTo === 'wall' || child.asset?.attachTo === 'wall-side';
+    });
+}

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

@@ -1 +1 @@
-{"version":3,"file":"curve-tool.d.ts","sourceRoot":"","sources":["../../src/wall/curve-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAWL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAazB;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAgJtD,CAAA;AAED,eAAe,aAAa,CAAA"}
+{"version":3,"file":"curve-tool.d.ts","sourceRoot":"","sources":["../../src/wall/curve-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAaL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAazB;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAmJtD,CAAA;AAED,eAAe,aAAa,CAAA"}

package/dist/wall/curve-tool.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { acquireSceneHistoryPause, emitter, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallChordFrame, getWallMidpointHandlePoint, normalizeWallCurveOffset, useScene, } from '@pascal-app/core';
+import { acquireSceneHistoryPause, constrainWallCurveOffsetToAvoidIntersections, emitter, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallChordFrame, getWallMidpointHandlePoint, normalizeWallCurveOffset, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { CursorSphere, getSegmentGridStep, markToolCancelConsumed, snapBuildingLocalToWorldGrid, snapScalarToGrid, triggerSFX, useInteractionScope, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useCallback, useEffect, useRef, useState } from 'react';
@@ -32,6 +32,7 @@ export const CurveWallTool = ({ node }) => {
         const originalCurveOffset = originalCurveOffsetRef.current;
         const chord = getWallChordFrame(node);
         const maxCurveOffset = getMaxWallCurveOffset(node);
+        const levelWalls = Object.values(useScene.getState().nodes).filter((candidate) => candidate.type === 'wall' && candidate.parentId === node.parentId);
         let releaseHistory = acquireSceneHistoryPause(useScene);
         let wasFinalized = false;
         const applyPreview = (curveOffset) => {
@@ -45,15 +46,12 @@ export const CurveWallTool = ({ node }) => {
             };
             const handlePoint = getWallMidpointHandlePoint(nextNode);
             setCursorLocalPos([handlePoint.x, 0, handlePoint.y]);
-            useScene.getState().updateNode(nodeId, { curveOffset });
+            useLiveNodeOverrides.getState().set(nodeId, { curveOffset });
             useScene.getState().markDirty(nodeId);
         };
         const restoreOriginal = () => {
-            if (previewOffsetRef.current === originalCurveOffset) {
-                return;
-            }
             previewOffsetRef.current = originalCurveOffset;
-            useScene.getState().updateNode(nodeId, { curveOffset: originalCurveOffset });
+            useLiveNodeOverrides.getState().clear(nodeId);
             useScene.getState().markDirty(nodeId);
         };
         const onGridMove = (event) => {
@@ -67,7 +65,8 @@ export const CurveWallTool = ({ node }) => {
             const offsetFromMidpoint = -((localX - chord.midpoint.x) * chord.normal.x +
                 (localZ - chord.midpoint.y) * chord.normal.y);
             const snappedOffset = snapScalarToGrid(offsetFromMidpoint, snapStep);
-            const nextCurveOffset = normalizeWallCurveOffset(node, Math.max(-maxCurveOffset, Math.min(maxCurveOffset, snappedOffset)));
+            const requestedCurveOffset = normalizeWallCurveOffset(node, Math.max(-maxCurveOffset, Math.min(maxCurveOffset, snappedOffset)));
+            const nextCurveOffset = constrainWallCurveOffsetToAvoidIntersections(node, requestedCurveOffset, levelWalls);
             if (previousCurveOffsetRef.current !== null &&
                 nextCurveOffset !== previousCurveOffsetRef.current) {
                 triggerSFX('sfx:grid-snap');
@@ -84,11 +83,9 @@ export const CurveWallTool = ({ node }) => {
             }
             const curveOffset = previewOffsetRef.current;
             wasFinalized = true;
+            useLiveNodeOverrides.getState().clear(nodeId);
+            useScene.getState().markDirty(nodeId);
             if (curveOffset !== originalCurveOffset) {
-                // Restore original baseline while paused so the next resume+update
-                // registers as a single tracked change (undo reverts to original).
-                useScene.getState().updateNode(nodeId, { curveOffset: originalCurveOffset });
-                useScene.getState().markDirty(nodeId);
                 releaseHistory();
                 useScene.getState().updateNode(nodeId, { curveOffset });
                 useScene.getState().markDirty(nodeId);

package/dist/wall/definition.d.ts

@@ -1,4 +1,4 @@
-import type { NodeDefinition } from '@pascal-app/core';
+import { type NodeDefinition } from '@pascal-app/core';
 import { WallNode } from './schema';
 /**
  * Wall — the Phase 3 stress test of the registry-driven node model.

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/wall/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAejE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGnC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAoI1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/wall/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AAwBzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGnC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CA4J1D,CAAA"}

package/dist/wall/definition.js

@@ -1,6 +1,9 @@
+import { getWallBaseElevationForNodes, getWallEffectiveHeightForNodes, } from '@pascal-app/core';
+import { DRAFTING_SURFACE_EXTENSION_KEY, } from '@pascal-app/editor';
 import { buildWallContextualDimensions } from './contextual-dimensions';
+import { hasWallCurveBlockingChildren } from './curve-eligibility';
 import { buildWallFloorplan, computeWallFloorplanLevelData } from './floorplan';
-import { wallCurveAffordance, wallMoveEndpointAffordance } from './floorplan-affordances';
+import { wallCurveAffordance, wallMoveEndpointAffordance, wallThicknessAffordance, } from './floorplan-affordances';
 import { wallFloorplanMoveTarget } from './floorplan-move';
 import { wallFloorplanSiblingOverrides } from './floorplan-overrides';
 import { matchWallMeasurementFeature, resolveWallMeasurementFeature, wallMeasurementFeatures, } from './measurement';
@@ -27,24 +30,37 @@ import { wallSlots } from './slots';
 export const wallDefinition = {
     kind: 'wall',
     snapProfile: 'structural',
-    schemaVersion: 7,
+    schemaVersion: 8,
     schema: WallNode,
     category: 'structure',
     surfaceRole: 'wall',
     extensions: {
+        [DRAFTING_SURFACE_EXTENSION_KEY]: {
+            kind: 'wall',
+            classifyFace: (node, localNormal) => {
+                if (node?.type !== 'wall')
+                    return null;
+                const dx = node.end[0] - node.start[0];
+                const dz = node.end[1] - node.start[1];
+                const length = Math.hypot(dx, dz);
+                if (length <= 1e-9)
+                    return { face: 'unknown' };
+                const sideDot = localNormal[0] * (-dz / length) + localNormal[2] * (dx / length);
+                if (Math.abs(localNormal[1]) > 0.7)
+                    return { face: 'top' };
+                if (Math.abs(localNormal[1]) < 0.25 && Math.abs(sideDot) > 0.7) {
+                    return { face: 'side', side: sideDot >= 0 ? 'front' : 'back' };
+                }
+                return { face: 'end' };
+            },
+        },
         'pascal:editor/floorplan': {
             contextualDimensions: buildWallContextualDimensions,
             actionMenu: {
-                canCurve: ({ node, nodes }) => !node.children.some((childId) => {
+                canCurve: ({ node, nodes }) => !hasWallCurveBlockingChildren(node.children.flatMap((childId) => {
                     const child = nodes[childId];
-                    if (!child)
-                        return false;
-                    if (child.type === 'door' || child.type === 'window')
-                        return true;
-                    if (child.type !== 'item')
-                        return false;
-                    return child.asset?.attachTo === 'wall' || child.asset?.attachTo === 'wall-side';
-                }),
+                    return child ? [child] : [];
+                })),
             },
         },
     },
@@ -66,6 +82,12 @@ export const wallDefinition = {
         selectable: { hitVolume: 'bbox' },
         // Front + back faces host items (paintings, shelves, switches).
         surfaces: {
+            top: {
+                height: (node, { nodes }) => {
+                    const wall = node;
+                    return (getWallBaseElevationForNodes(wall, nodes) + getWallEffectiveHeightForNodes(wall, nodes));
+                },
+            },
             sides: { faces: 'all' },
         },
         duplicable: true,
@@ -82,7 +104,7 @@ export const wallDefinition = {
         slots: () => wallSlots(),
     },
     relations: {
-        hosts: ['door', 'window', 'item'],
+        hosts: ['door', 'window', 'item', 'lean-to-extension'],
         affectsSpatial: ['slab', 'ceiling', 'zone'],
         linkedBy: 'endpoint-match',
         cascadeDelete: 'descendants',
@@ -131,6 +153,7 @@ export const wallDefinition = {
     floorplanAffordances: {
         'move-endpoint': wallMoveEndpointAffordance,
         curve: wallCurveAffordance,
+        thickness: wallThicknessAffordance,
     },
     floorplanMoveTarget: wallFloorplanMoveTarget,
     floorplanSiblingOverrides: wallFloorplanSiblingOverrides,
@@ -140,7 +163,7 @@ export const wallDefinition = {
     ],
     presentation: {
         label: 'Wall',
-        description: 'A straight or curved wall segment. Hosts doors, windows, and wall-mounted items.',
+        description: 'A straight or curved wall segment. Hosts doors, windows, lean-to extensions, and wall-mounted items.',
         icon: { kind: 'url', src: '/icons/wall.webp' },
         paletteSection: 'structure',
         paletteOrder: 10,

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

@@ -9,5 +9,6 @@ import { type FloorplanAffordance, type WallNode } from '@pascal-app/core';
  * pause / resume around `apply`.
  */
 export declare const wallCurveAffordance: FloorplanAffordance<WallNode>;
+export declare const wallThicknessAffordance: FloorplanAffordance<WallNode>;
 export declare const wallMoveEndpointAffordance: FloorplanAffordance<WallNode>;
 //# sourceMappingURL=floorplan-affordances.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EAQxB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAoFzB;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,CAAC,QAAQ,CAuD7D,CAAA;AAED,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,QAAQ,CA0KpE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,EAUxB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAgGzB;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,CAAC,QAAQ,CAgE7D,CAAA;AAED,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAiCjE,CAAA;AAED,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,QAAQ,CA4KpE,CAAA"}

package/dist/wall/floorplan-affordances.js

@@ -1,23 +1,29 @@
-import { getMaxWallCurveOffset, getWallChordFrame, normalizeWallCurveOffset, runAsSingleSceneHistoryStep, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { constrainWallCurveOffsetToAvoidIntersections, getMaxWallCurveOffset, getWallChordFrame, getWallCurveFrameAt, getWallThickness, normalizeWallCurveOffset, runAsSingleSceneHistoryStep, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { alignFloorplanDraftPoint, getSegmentGridStep, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isSegmentLongEnough, resolveEndpointWallSplit, snapBuildingLocalToWorldGrid, snapScalarToGrid, snapWallDraftPoint, useAlignmentGuides, } from '@pascal-app/editor';
+const MIN_WALL_THICKNESS = 0.05;
 function pointsEqual(a, b) {
     return a[0] === b[0] && a[1] === b[1];
 }
-function collectLevelWalls(nodes, excludeWallId) {
+function collectLevelWalls(nodes, parentId, excludeWallId) {
     const out = [];
     for (const node of Object.values(nodes)) {
-        if (node?.type === 'wall' && node.id !== excludeWallId)
+        if (node?.type === 'wall' &&
+            node.id !== excludeWallId &&
+            (node.parentId ?? null) === parentId) {
             out.push(node);
+        }
     }
     return out;
 }
-function collectLinkedWalls(nodes, draggedWallId, originalStart, originalEnd) {
+function collectLinkedWalls(nodes, draggedWallId, parentId, originalStart, originalEnd) {
     const linked = [];
     for (const node of Object.values(nodes)) {
         if (node?.type !== 'wall')
             continue;
         if (node.id === draggedWallId)
             continue;
+        if ((node.parentId ?? null) !== parentId)
+            continue;
         const wall = node;
         if (pointsEqual(wall.start, originalStart) ||
             pointsEqual(wall.start, originalEnd) ||
@@ -65,7 +71,9 @@ export const wallCurveAffordance = {
                 const offsetFromMidpoint = -((x - chord.midpoint.x) * chord.normal.x +
                     (y - chord.midpoint.y) * chord.normal.y);
                 const snappedOffset = snapScalarToGrid(offsetFromMidpoint, snapStep);
-                const nextCurveOffset = normalizeWallCurveOffset(node, Math.max(-maxOffset, Math.min(maxOffset, snappedOffset)));
+                const requestedCurveOffset = normalizeWallCurveOffset(node, Math.max(-maxOffset, Math.min(maxOffset, snappedOffset)));
+                const sceneNodes = useScene.getState().nodes;
+                const nextCurveOffset = constrainWallCurveOffsetToAvoidIntersections(node, requestedCurveOffset, Object.values(sceneNodes).filter((candidate) => candidate.type === 'wall' && candidate.parentId === node.parentId));
                 lastCurveOffset = nextCurveOffset;
                 // Publish the curve preview as a live override so renderers see
                 // it without zustand churn. Mark the wall dirty so `WallSystem`
@@ -89,13 +97,43 @@ export const wallCurveAffordance = {
         };
     },
 };
+export const wallThicknessAffordance = {
+    start({ node, payload, initialPlanPoint }) {
+        const { side } = payload;
+        const frame = getWallCurveFrameAt(node, 0.5);
+        const outwardX = frame.normal.x * side;
+        const outwardY = frame.normal.y * side;
+        const initialThickness = getWallThickness(node);
+        const wallId = node.id;
+        let lastThickness = initialThickness;
+        return {
+            affectedIds: [wallId],
+            apply({ planPoint }) {
+                const outwardDelta = (planPoint[0] - initialPlanPoint[0]) * outwardX +
+                    (planPoint[1] - initialPlanPoint[1]) * outwardY;
+                const rawThickness = initialThickness + outwardDelta * 2;
+                lastThickness = Math.max(MIN_WALL_THICKNESS, snapScalarToGrid(rawThickness, getSegmentGridStep()));
+                useLiveNodeOverrides.getState().set(wallId, { thickness: lastThickness });
+                useScene.getState().markDirty(wallId);
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene.getState().updateNodes([{ id: wallId, data: { thickness: lastThickness } }]);
+                useLiveNodeOverrides.getState().clear(wallId);
+            },
+        };
+    },
+};
 export const wallMoveEndpointAffordance = {
     start({ node, payload, nodes }) {
         const { endpoint } = payload;
         const fixedPoint = endpoint === 'start' ? [...node.end] : [...node.start];
         const originalStart = [...node.start];
         const originalEnd = [...node.end];
-        const linkedWalls = collectLinkedWalls(nodes, node.id, originalStart, originalEnd);
+        const parentId = (node.parentId ?? null);
+        const linkedWalls = collectLinkedWalls(nodes, node.id, parentId, originalStart, originalEnd);
         const affectedIds = [node.id, ...linkedWalls.map((w) => w.id)];
         const movingOriginal = endpoint === 'start' ? originalStart : originalEnd;
         // Walls attached to the MOVING corner cascade with the drag, but the snap
@@ -123,7 +161,7 @@ export const wallMoveEndpointAffordance = {
                 // the moving corner are excluded (stale coordinates); under
                 // Alt-detach they stay put, so they rejoin the candidate pool.
                 const sceneNodes = useScene.getState().nodes;
-                const walls = collectLevelWalls(sceneNodes, node.id);
+                const walls = collectLevelWalls(sceneNodes, parentId, node.id);
                 const staleWallIds = modifiers.altKey ? [node.id] : [node.id, ...movingLinkedWallIds];
                 // The grid step follows the active snapping mode (`getSegmentGridStep()`
                 // is 0 outside grid mode), so `'lines' / 'angles' / 'off'` no longer
@@ -153,6 +191,7 @@ export const wallMoveEndpointAffordance = {
                     applySnap: isMagneticSnapActive(),
                     bypass: !isAlignmentGuideActive(),
                     excludeIds: staleWallIds,
+                    levelId: parentId,
                 });
                 const primaryStart = endpoint === 'start' ? aligned : fixedPoint;
                 const primaryEnd = endpoint === 'end' ? aligned : fixedPoint;

package/dist/wall/floorplan-move.d.ts

@@ -23,10 +23,9 @@ import { type FloorplanMoveTarget, type WallNode } from '@pascal-app/core';
  * overrides after the write lands so the system reads from the new
  * committed scene state.
  *
- * Auto-slab live preview and ghost bridge SVG previews — visible in
- * the 3D tool — are deliberately deferred. Slab polygons re-derive on
- * commit through the normal scene reactions; bridges appear at commit
- * time. Follow-up work to surface them mid-drag is tracked separately.
+ * Existing automatic slabs and ceilings receive live polygon overrides during
+ * the drag. New surfaces and removals stay deferred until commit because live
+ * overrides cannot represent nodes that do not exist in the scene.
  */
 export declare const wallFloorplanMoveTarget: FloorplanMoveTarget<WallNode>;
 //# sourceMappingURL=floorplan-move.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EAOxB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAmBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAiRjE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,mBAAmB,EAaxB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAqCzB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAuYjE,CAAA"}

package/dist/wall/floorplan-move.js

@@ -1,7 +1,13 @@
-import { getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, planWallMoveJunctions, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { detectSpacesForLevel, getCeilingClampBound, getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, getStoredLevelHeight, planAutoCeilingsForLevel, planAutoSlabsForLevel, planWallMoveJunctions, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { getFloorplanWallThickness, getSegmentGridStep, isSegmentLongEnough, snapScalarToGrid, useWallMoveGhosts, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { buildBridgeWallCreates, buildBridgeWallPreviews, getLinkedWallSnapshots, getWallsAfterUpdates, stripWallIsNewMetadata, } from './move-shared';
+function getLevelSlabs(levelId, nodes) {
+    return Object.values(nodes).filter((entry) => entry?.type === 'slab' && (entry.parentId ?? null) === levelId);
+}
+function getLevelCeilings(levelId, nodes) {
+    return Object.values(nodes).filter((entry) => entry?.type === 'ceiling' && (entry.parentId ?? null) === levelId);
+}
 /**
  * 2D floor-plan move handler for wall.
  *
@@ -26,10 +32,9 @@ import { buildBridgeWallCreates, buildBridgeWallPreviews, getLinkedWallSnapshots
  * overrides after the write lands so the system reads from the new
  * committed scene state.
  *
- * Auto-slab live preview and ghost bridge SVG previews — visible in
- * the 3D tool — are deliberately deferred. Slab polygons re-derive on
- * commit through the normal scene reactions; bridges appear at commit
- * time. Follow-up work to surface them mid-drag is tracked separately.
+ * Existing automatic slabs and ceilings receive live polygon overrides during
+ * the drag. New surfaces and removals stay deferred until commit because live
+ * overrides cannot represent nodes that do not exist in the scene.
  */
 export const wallFloorplanMoveTarget = ({ node }) => {
     const wallId = node.id;
@@ -72,8 +77,75 @@ export const wallFloorplanMoveTarget = ({ node }) => {
     let lastDelta = [0, 0];
     let lastNextStart = originalStart;
     let lastNextEnd = originalEnd;
+    const levelId = node.parentId ?? null;
+    const affectedIds = [wallId, ...linkedOriginals.map((wall) => wall.id)];
+    const affectedIdSet = new Set(affectedIds);
+    const touchedSurfaceIds = new Set();
+    let latestSurfacePlans = null;
+    const planSurfaces = (walls) => {
+        if (!levelId)
+            return null;
+        const sceneState = useScene.getState();
+        const levelWalls = walls.filter((wall) => (wall.parentId ?? null) === levelId);
+        const { roomPolygons } = detectSpacesForLevel(levelId, levelWalls);
+        const slabs = planAutoSlabsForLevel(roomPolygons, getLevelSlabs(levelId, sceneState.nodes));
+        const levelNode = sceneState.nodes[levelId];
+        const ceilings = planAutoCeilingsForLevel(roomPolygons, getLevelCeilings(levelId, sceneState.nodes), {
+            storeyHeight: levelNode?.type === 'level' ? getStoredLevelHeight(levelNode) : undefined,
+            ceilingClampBound: (polygon) => getCeilingClampBound(levelId, sceneState.nodes, polygon),
+        });
+        return { slabs, ceilings };
+    };
+    const publishSurfacePreviews = (walls) => {
+        const plans = planSurfaces(walls);
+        latestSurfacePlans = plans;
+        if (!plans)
+            return;
+        const entries = [];
+        for (const update of plans.slabs.update) {
+            if (update.data.polygon !== undefined) {
+                entries.push([update.id, { polygon: update.data.polygon }]);
+            }
+        }
+        for (const update of plans.ceilings.update) {
+            if (update.data.polygon !== undefined || update.data.height !== undefined) {
+                entries.push([update.id, update.data]);
+            }
+        }
+        const nextIds = new Set(entries.map(([id]) => id));
+        const overrides = useLiveNodeOverrides.getState();
+        const sceneState = useScene.getState();
+        for (const id of touchedSurfaceIds) {
+            if (nextIds.has(id))
+                continue;
+            overrides.clear(id);
+            sceneState.markDirty(id);
+            touchedSurfaceIds.delete(id);
+        }
+        if (entries.length > 0) {
+            overrides.setMany(entries);
+            for (const [id] of entries) {
+                touchedSurfaceIds.add(id);
+                if (!affectedIdSet.has(id)) {
+                    affectedIdSet.add(id);
+                    affectedIds.push(id);
+                }
+                sceneState.markDirty(id);
+            }
+        }
+    };
+    const clearSurfacePreviews = () => {
+        const overrides = useLiveNodeOverrides.getState();
+        const sceneState = useScene.getState();
+        for (const id of touchedSurfaceIds) {
+            overrides.clear(id);
+            sceneState.markDirty(id);
+        }
+        touchedSurfaceIds.clear();
+        latestSurfacePlans = null;
+    };
     const session = {
-        affectedIds: [wallId, ...linkedOriginals.map((w) => w.id)],
+        affectedIds,
         apply({ planPoint }) {
             if (!rawAnchor) {
                 rawAnchor = [planPoint[0], planPoint[1]];
@@ -168,6 +240,7 @@ export const wallFloorplanMoveTarget = ({ node }) => {
                 thickness: getFloorplanWallThickness(wall),
             }));
             useWallMoveGhosts.getState().setBridges(ghostBridges);
+            publishSurfacePreviews([...previewSceneWalls, ...bridgePreviews.map(({ wall }) => wall)]);
             // `WallSystem` only runs its rebuild pass when `dirtyNodes` is
             // non-empty. We're not writing to scene any more, but we still
             // need the system to pick up the live override changes — so
@@ -195,6 +268,7 @@ export const wallFloorplanMoveTarget = ({ node }) => {
                 overrides.clear(wallId);
                 for (const wall of linkedOriginals)
                     overrides.clear(wall.id);
+                clearSurfacePreviews();
                 return;
             }
             const plan = planWallMoveJunctions(linkedOriginals, originalStart, originalEnd, lastNextStart, lastNextEnd);
@@ -232,10 +306,48 @@ export const wallFloorplanMoveTarget = ({ node }) => {
                 existingWalls,
                 wallCount: Object.values(sceneState.nodes).filter((entry) => entry?.type === 'wall').length,
             });
+            const finalWalls = [
+                ...existingWalls,
+                ...bridgeCreates.map((entry) => ({ ...entry.node, parentId: entry.parentId ?? null })),
+            ];
+            const surfacePlans = planSurfaces(finalWalls) ?? latestSurfacePlans;
+            const surfaceUpdates = surfacePlans
+                ? [
+                    ...surfacePlans.slabs.update.map((entry) => ({
+                        id: entry.id,
+                        data: entry.data,
+                    })),
+                    ...surfacePlans.ceilings.update.map((entry) => ({
+                        id: entry.id,
+                        data: entry.data,
+                    })),
+                ]
+                : [];
+            const surfaceCreates = surfacePlans
+                ? [
+                    ...surfacePlans.slabs.create.map((slab) => ({
+                        node: slab,
+                        parentId: levelId,
+                    })),
+                    ...surfacePlans.ceilings.create.map((ceiling) => ({
+                        node: ceiling,
+                        parentId: levelId,
+                    })),
+                ]
+                : [];
+            const surfaceDeletes = surfacePlans
+                ? [
+                    ...surfacePlans.slabs.delete.map((id) => id),
+                    ...surfacePlans.ceilings.delete.map((id) => id),
+                ]
+                : [];
             sceneState.applyNodeChanges({
-                update: commitUpdates,
-                create: bridgeCreates,
-                delete: Array.from(collapsedLinkedWallIds),
+                update: [
+                    ...commitUpdates,
+                    ...surfaceUpdates,
+                ],
+                create: [...bridgeCreates, ...surfaceCreates],
+                delete: Array.from(new Set([...collapsedLinkedWallIds, ...surfaceDeletes])),
             });
             // Drop the live overrides now that the committed scene state
             // matches them — leaving them around would keep the system
@@ -246,6 +358,7 @@ export const wallFloorplanMoveTarget = ({ node }) => {
             overrides.clear(wallId);
             for (const wall of linkedOriginals)
                 overrides.clear(wall.id);
+            clearSurfacePreviews();
             // Swap ghosts → real walls: the bridges we just created render
             // through the registry layer, so the dashed previews aren't
             // needed any more. Clearing here (instead of waiting for the

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAEZ,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAOpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAKL,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAA;AAWlC,QAAA,MAAM,yBAAyB,yDAA0D,CAAA;AAEzF,KAAK,sBAAsB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAA;AAexE,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,aAAa,CAAA;IACrB,cAAc,EAAE,aAAa,CAAA;IAC7B,iCAAiC,EAAE,MAAM,CAAC,sBAAsB,EAAE,6BAA6B,CAAC,CAAA;CACjG,CAAA;AAED,wBAAgB,6BAA6B,CAAC,EAC5C,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,sBAAsB,CAqCzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAoMjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAEZ,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAOpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAKL,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAA;AAYlC,QAAA,MAAM,yBAAyB,yDAA0D,CAAA;AAEzF,KAAK,sBAAsB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAA;AAexE,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,aAAa,CAAA;IACrB,cAAc,EAAE,aAAa,CAAA;IAC7B,iCAAiC,EAAE,MAAM,CAAC,sBAAsB,EAAE,6BAA6B,CAAC,CAAA;CACjG,CAAA;AAED,wBAAgB,6BAA6B,CAAC,EAC5C,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,sBAAsB,CAqCzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAkNjG"}

package/dist/wall/floorplan.js

@@ -2,6 +2,7 @@ import { calculateLevelMiters, getWallCurveFrameAt, getWallCurveLength, getWallM
 import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
 import { constructionDimensionStandard } from '../shared/construction-dimension-standards';
 import { buildCurvedWallConstructionDimensions, buildLevelWallConstructionDimensionPlan, buildWallConstructionDimensions, renderPlannedConstructionDimensions, } from './construction-dimensions';
+import { hasWallCurveBlockingChildren } from './curve-eligibility';
 // Same constants the legacy `getFloorplanWall` uses (editor/lib/floorplan/walls.ts).
 // Slightly exaggerates thin walls so the 2D plan stays legible without
 // drifting from BIM data. Inlined to keep nodes/wall self-contained.
@@ -190,6 +191,20 @@ export function buildWallFloorplan(node, ctx) {
             affordance: 'move-endpoint',
             payload: { wallId: node.id, endpoint: 'end' },
         });
+        const thicknessFrame = getWallCurveFrameAt(self, 0.5);
+        const halfVisibleThickness = getWallThickness(self) / 2;
+        for (const side of [1, -1]) {
+            children.push({
+                kind: 'endpoint-handle',
+                point: [
+                    thicknessFrame.point.x + thicknessFrame.normal.x * halfVisibleThickness * side,
+                    thicknessFrame.point.y + thicknessFrame.normal.y * halfVisibleThickness * side,
+                ],
+                state: 'idle',
+                affordance: 'thickness',
+                payload: { wallId: node.id, side },
+            });
+        }
         // Side move arrows — two directional arrows at the wall midpoint,
         // pointing outward perpendicular to the wall. Mirrors the 3D
         // `WallMoveSideHandles` arrows so users can grab the wall body
@@ -217,11 +232,10 @@ export function buildWallFloorplan(node, ctx) {
             }
         }
         // Curve sagitta handle — teal dot at the wall midpoint that
-        // controls `curveOffset`. Hidden when the wall hosts a door /
-        // window / wall-attached item: bending the wall would tear those
-        // children, so the legacy disables the handle in that case (see
-        // `wallCurveHandles.hasWallChildrenBlockingCurve`).
-        if (!hasCurveBlockingChildren(ctx.children)) {
+        // controls `curveOffset`. Hidden when the wall hosts an opening,
+        // lean-to extension, or wall-attached item because bending the host
+        // would tear the child geometry away from it.
+        if (!hasWallCurveBlockingChildren(ctx.children)) {
             const handle = getWallMidpointHandlePoint(node);
             children.push({
                 kind: 'endpoint-handle',
@@ -271,21 +285,3 @@ function wallDimensionDatumPolicy(reference) {
             return 'wall-face';
     }
 }
-/**
- * Doors, windows, and wall-attached items would tear if the wall bent
- * around them, so the curve sagitta handle hides when any of those
- * children exist. Mirrors the legacy
- * `wallCurveHandles.hasWallChildrenBlockingCurve` check.
- */
-function hasCurveBlockingChildren(children) {
-    for (const child of children) {
-        if (child.type === 'door' || child.type === 'window')
-            return true;
-        if (child.type === 'item') {
-            const attachTo = child.asset?.attachTo;
-            if (attachTo === 'wall' || attachTo === 'wall-side')
-                return true;
-        }
-    }
-    return false;
-}

package/dist/wall/move-shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-shared.d.ts","sourceRoot":"","sources":["../../src/wall/move-shared.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAKd,QAAQ,EACR,KAAK,kBAAkB,EACvB,KAAK,QAAQ,EACb,KAAK,aAAa,EAEnB,MAAM,kBAAkB,CAAA;AAczB,wBAAgB,SAAS,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,WAE3D;AAMD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,CAQvF;AAED,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAA;AAEzC;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IACtB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,aAAa,EAAE,aAAa,CAAA;IAC5B,WAAW,EAAE,aAAa,CAAA;CAC3B,GAAG,kBAAkB,EAAE,CA2CvB;AA0BD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,UAiB/C;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EACpD,OAAO,EAAE,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;CAAE,CAAC,GACzD,QAAQ,EAAE,CASZ;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,WAAW,EAAE,KAAK,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAA;IAC1D,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,aAAa,CAAA;IACtB,aAAa,EAAE,QAAQ,EAAE,CAAA;IACzB,SAAS,EAAE,MAAM,CAAA;CAClB,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,CAAC,CAkClD;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,aAAa,CAAA;IACpB,GAAG,EAAE,aAAa,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,WAAW,EAAE,KAAK,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAA;IAC1D,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,aAAa,CAAA;IACtB,aAAa,EAAE,QAAQ,EAAE,CAAA;CAC1B,GAAG,KAAK,CAAC;IAAE,KAAK,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CAqCrD"}
+{"version":3,"file":"move-shared.d.ts","sourceRoot":"","sources":["../../src/wall/move-shared.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAKd,QAAQ,EACR,KAAK,kBAAkB,EACvB,KAAK,QAAQ,EACb,KAAK,aAAa,EAEnB,MAAM,kBAAkB,CAAA;AAczB,wBAAgB,SAAS,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,WAE3D;AAMD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,CAQvF;AAED,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAA;AAEzC;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IACtB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,aAAa,EAAE,aAAa,CAAA;IAC5B,WAAW,EAAE,aAAa,CAAA;CAC3B,GAAG,kBAAkB,EAAE,CA2CvB;AA4BD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,UAiB/C;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EACpD,OAAO,EAAE,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;CAAE,CAAC,GACzD,QAAQ,EAAE,CASZ;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,WAAW,EAAE,KAAK,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAA;IAC1D,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,aAAa,CAAA;IACtB,aAAa,EAAE,QAAQ,EAAE,CAAA;IACzB,SAAS,EAAE,MAAM,CAAA;CAClB,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,CAAC,CAoClD;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,aAAa,CAAA;IACpB,GAAG,EAAE,aAAa,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,WAAW,EAAE,KAAK,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAA;IAC1D,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,aAAa,CAAA;IACtB,aAAa,EAAE,QAAQ,EAAE,CAAA;CAC1B,GAAG,KAAK,CAAC;IAAE,KAAK,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CAyCrD"}