From fb4ac2b87467dac52521bd49b80b0ebfd0c2b595 Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 15:08:19 -0400
Subject: [PATCH 01/27] fix(capture): round armed FOV, add Alt slow modifier
 for the drone camera

armCaptureFov stored the live camera FOV verbatim, so fractional pose FOVs
printed float tails in the HUD and left the reset button enabled. Both
writers now share clampCaptureFov.

Alt holds the drone at 0.2x speed and look sensitivity for fine framing;
Shift stays the boost.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 .../editor/first-person-controls.tsx          | 28 +++++++++++++++++--
 .../editor/snapshot-capture-overlay.tsx       |  1 +
 packages/editor/src/store/use-editor.tsx      | 16 ++++++-----
 3 files changed, 35 insertions(+), 10 deletions(-)

diff --git a/packages/editor/src/components/editor/first-person-controls.tsx b/packages/editor/src/components/editor/first-person-controls.tsx
index f05e37595..953a88b00 100644
--- a/packages/editor/src/components/editor/first-person-controls.tsx
+++ b/packages/editor/src/components/editor/first-person-controls.tsx
@@ -94,6 +94,7 @@ const LOOK_SENSITIVITY = 0.002
 // constant is an exponential approach rate, not a linear acceleration.
 const DRONE_SPEED = 7
 const DRONE_RUN_MULTIPLIER = 3
+const DRONE_SLOW_MULTIPLIER = 0.2
 const DRONE_SMOOTHING = 12
 const CONTROLLER_CENTER_FROM_EYE = 0.85
 const DOOR_INTERACTION_DISTANCE = 2.5
@@ -675,6 +676,7 @@ export const FirstPersonControls = () => {
   const hudLabelFrameRef = useRef(HUD_LABEL_SAMPLE_FRAMES - 1)
   const crouchKeyRef = useRef(false)
   const droneAscendKeyRef = useRef(false)
+  const droneSlowKeyRef = useRef(false)
   const droneDescendKeyRef = useRef(false)
   const droneVelocityRef = useRef(new Vector3())
   const suspendRef = useRef(false)
@@ -1164,10 +1166,15 @@ export const FirstPersonControls = () => {
       // Shutter hold: the shot is rendering — a mouse twitch must not pan it.
       if (useEditor.getState().captureShutterHold) return
 
-      yawRef.current -= e.movementX * LOOK_SENSITIVITY
+      const lookSensitivity =
+        LOOK_SENSITIVITY *
+        (useEditor.getState().firstPersonMovementMode === 'drone' && droneSlowKeyRef.current
+          ? DRONE_SLOW_MULTIPLIER
+          : 1)
+      yawRef.current -= e.movementX * lookSensitivity
       pitchRef.current = Math.max(
         -(Math.PI / 2 - 0.05),
-        Math.min(Math.PI / 2 - 0.05, pitchRef.current - e.movementY * LOOK_SENSITIVITY),
+        Math.min(Math.PI / 2 - 0.05, pitchRef.current - e.movementY * lookSensitivity),
       )
     }
 
@@ -1280,6 +1287,10 @@ export const FirstPersonControls = () => {
         event.preventDefault()
         event.stopPropagation()
         if (!suspendRef.current) droneAscendKeyRef.current = true
+      } else if ((event.code === 'AltLeft' || event.code === 'AltRight') && isDroneMode) {
+        event.preventDefault()
+        event.stopPropagation()
+        if (!suspendRef.current) droneSlowKeyRef.current = true
       } else if (event.code === 'Escape') {
         event.preventDefault()
         event.stopPropagation()
@@ -1336,6 +1347,9 @@ export const FirstPersonControls = () => {
       if (event.code === 'KeyE' && !suspendRef.current) {
         droneAscendKeyRef.current = false
       }
+      if ((event.code === 'AltLeft' || event.code === 'AltRight') && !suspendRef.current) {
+        droneSlowKeyRef.current = false
+      }
       applyMovementKey(event, false)
     }
 
@@ -1344,6 +1358,7 @@ export const FirstPersonControls = () => {
         crouchKeyRef.current = false
         droneAscendKeyRef.current = false
         droneDescendKeyRef.current = false
+        droneSlowKeyRef.current = false
       }
     }
 
@@ -1617,7 +1632,14 @@ export const FirstPersonControls = () => {
     if (droneDesiredVelocity.lengthSq() > 0) {
       droneDesiredVelocity
         .normalize()
-        .multiplyScalar(DRONE_SPEED * (movement.run ? DRONE_RUN_MULTIPLIER : 1))
+        .multiplyScalar(
+          DRONE_SPEED *
+            (droneSlowKeyRef.current
+              ? DRONE_SLOW_MULTIPLIER
+              : movement.run
+                ? DRONE_RUN_MULTIPLIER
+                : 1),
+        )
     }
 
     droneVelocityRef.current.lerp(droneDesiredVelocity, 1 - Math.exp(-step * DRONE_SMOOTHING))
diff --git a/packages/editor/src/components/editor/snapshot-capture-overlay.tsx b/packages/editor/src/components/editor/snapshot-capture-overlay.tsx
index f97b8d98f..226df5742 100644
--- a/packages/editor/src/components/editor/snapshot-capture-overlay.tsx
+++ b/packages/editor/src/components/editor/snapshot-capture-overlay.tsx
@@ -159,6 +159,7 @@ const CAMERA_NAV_HINTS: Record<CaptureCameraNav, readonly CameraNavHint[] | null
     { keys: ['Space', 'E'], action: 'up' },
     { keys: ['Q'], action: 'down' },
     { keys: ['Shift'], action: 'boost' },
+    { keys: ['Alt'], action: 'slow' },
     { keys: ['Wheel'], action: 'lens' },
     { keys: ['P', 'Esc'], action: 'free cursor' },
     { keys: ['Click', 'Enter'], action: 'shoot' },
diff --git a/packages/editor/src/store/use-editor.tsx b/packages/editor/src/store/use-editor.tsx
index 338d872f0..c64d6ef15 100644
--- a/packages/editor/src/store/use-editor.tsx
+++ b/packages/editor/src/store/use-editor.tsx
@@ -116,6 +116,10 @@ export type FirstPersonMovementMode = 'walk' | 'drone'
 export const CAPTURE_FOV_MIN = 15
 export const CAPTURE_FOV_MAX = 110
 
+function clampCaptureFov(fov: number): number {
+  return Math.min(Math.max(Math.round(fov), CAPTURE_FOV_MIN), CAPTURE_FOV_MAX)
+}
+
 export type Phase = 'site' | 'structure' | 'furnish'
 
 /**
@@ -1485,14 +1489,12 @@ const useEditor = create<EditorState>()(
       captureFovBaseline: null,
       setCaptureFov: (fov) =>
         set({
-          captureFov: Math.min(Math.max(Math.round(fov), CAPTURE_FOV_MIN), CAPTURE_FOV_MAX),
+          captureFov: clampCaptureFov(fov),
         }),
-      armCaptureFov: (fov) =>
-        set(
-          fov === null
-            ? { captureFov: null, captureFovBaseline: null }
-            : { captureFov: fov, captureFovBaseline: fov },
-        ),
+      armCaptureFov: (fov) => {
+        const captureFov = fov === null ? null : clampCaptureFov(fov)
+        set({ captureFov, captureFovBaseline: captureFov })
+      },
       captureShutterHold: false,
       setCaptureShutterHold: (hold) => set({ captureShutterHold: hold }),
       workspaceMode: 'edit' as WorkspaceMode,

From 66ca8534b53945877e5b9b6958a8b4ac7a661a97 Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 15:13:06 -0400
Subject: [PATCH 02/27] fix(roof): keep the gable shell base on the wall top

The CSG degeneracy guard enforced its 5 cm minimum by lowering the shell
base, which for wallHeight-0 room roofs put the gable 4 cm inside the
wall and z-fought its faces. Raise the eave instead; mirror the floor in
the opening-placement frame and the shed inset panel.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 .../schema/nodes/roof-segment-walls.test.ts   |  9 +++++
 .../src/schema/nodes/roof-segment-walls.ts    |  6 ++-
 .../src/systems/roof/roof-system.test.ts      | 39 ++++++++++++++++++-
 .../viewer/src/systems/roof/roof-system.tsx   |  9 ++---
 4 files changed, 54 insertions(+), 9 deletions(-)

diff --git a/packages/core/src/schema/nodes/roof-segment-walls.test.ts b/packages/core/src/schema/nodes/roof-segment-walls.test.ts
index 61c087f55..8b6004f82 100644
--- a/packages/core/src/schema/nodes/roof-segment-walls.test.ts
+++ b/packages/core/src/schema/nodes/roof-segment-walls.test.ts
@@ -23,6 +23,15 @@ function segment(overrides: Partial<RoofSegmentNode> = {}): RoofSegmentNode {
 }
 
 describe('roof wall face frames', () => {
+  test('zero-height gable profiles keep their base at zero and raise the eave to five centimeters', () => {
+    const face = getRoofSegmentWallFace(segment({ wallHeight: 0 }), 'right')
+
+    expect(Math.min(...face.profile.map(([, v]) => v))).toBe(0)
+    expect(face.profile[2]?.[1]).toBe(0.05)
+    expect(face.profile[4]?.[1]).toBe(0.05)
+    expect(face.profile[3]?.[1]).toBeCloseTo(0.05 + 3.05 * Math.tan((40 * Math.PI) / 180))
+  })
+
   test('frame z = 0 lands on the nominal footprint (wall mid-plane)', () => {
     const seg = segment()
     // front face, u at the face middle, v = 1, mid-plane.
diff --git a/packages/core/src/schema/nodes/roof-segment-walls.ts b/packages/core/src/schema/nodes/roof-segment-walls.ts
index d6fa9c5bc..5595a2a8b 100644
--- a/packages/core/src/schema/nodes/roof-segment-walls.ts
+++ b/packages/core/src/schema/nodes/roof-segment-walls.ts
@@ -16,7 +16,9 @@ import { getDutchRoofMetrics, getSegmentSlopeFrame } from './roof-segment'
  * (`getVol(wallThickness / 2, 0, 0, …)`): the volume is the segment
  * footprint extended outward by `wallThickness / 2`, which drops the eave
  * line by `(wallThickness / 2) · tanθ` and raises the ridge by the same
- * amount so the apex stays at `wallHeight + activeRh`.
+ * amount so the apex stays at `wallHeight + activeRh` unless the eave
+ * hits the CSG minimum. The base stays at 0; the eave is raised to at
+ * least 0.05 above it to avoid sinking the shell into the supporting wall.
  */
 
 export type RoofWallFaceId = 'front' | 'back' | 'right' | 'left'
@@ -76,7 +78,7 @@ function getWallVolumeFrame(node: SegmentWallInputs): WallVolumeFrame {
   const autoDrop = (wallThickness / 2) * tanTheta
   const wV = Math.max(0.01, node.width + wallThickness)
   const dV = Math.max(0.01, node.depth + wallThickness)
-  const eaveY = Math.max(0.01, node.wallHeight - autoDrop)
+  const eaveY = Math.max(0.05, node.wallHeight - autoDrop)
   let rh = activeRh
   if (activeRh > 0) {
     rh = activeRh + autoDrop
diff --git a/packages/viewer/src/systems/roof/roof-system.test.ts b/packages/viewer/src/systems/roof/roof-system.test.ts
index 910a44550..657de52b6 100644
--- a/packages/viewer/src/systems/roof/roof-system.test.ts
+++ b/packages/viewer/src/systems/roof/roof-system.test.ts
@@ -3,7 +3,40 @@
 import { describe, expect, test } from 'bun:test'
 import { type AnyNode, RoofNode, RoofSegmentNode } from '@pascal-app/core'
 import * as THREE from 'three'
-import { generateRoofSegmentGeometry } from './roof-system'
+import { Evaluator, SUBTRACTION } from 'three-bvh-csg'
+import { generateRoofSegmentGeometry, getRoofSegmentBrushes } from './roof-system'
+
+describe('roof system gable geometry', () => {
+  test('keeps a zero-height gable wall shell exactly on its base', () => {
+    const segment = RoofSegmentNode.parse({
+      roofType: 'gable',
+      width: 8,
+      depth: 6,
+      wallHeight: 0,
+      wallThickness: 0.1,
+      pitch: 40,
+    })
+    const brushes = getRoofSegmentBrushes(segment)
+    expect(brushes).not.toBeNull()
+    if (!brushes) return
+
+    const shell = new Evaluator().evaluate(brushes.wallBrush, brushes.innerBrush, SUBTRACTION)
+    try {
+      brushes.wallBrush.geometry.computeBoundingBox()
+      expect(brushes.wallBrush.geometry.boundingBox!.min.y).toBe(0)
+      expect(shell.geometry.getAttribute('position').count).toBeGreaterThan(0)
+      shell.geometry.computeBoundingBox()
+      expect(shell.geometry.boundingBox!.min.y).toBeCloseTo(0, 12)
+    } finally {
+      shell.geometry.dispose()
+      brushes.wallBrush.geometry.dispose()
+      brushes.innerBrush.geometry.dispose()
+      brushes.deckSlab.geometry.dispose()
+      brushes.shinSlab.geometry.dispose()
+      brushes.rakeBoards?.dispose()
+    }
+  })
+})
 
 describe('roof system shed geometry', () => {
   function inspectShedGeometry(segment: RoofSegmentNode) {
@@ -179,9 +212,11 @@ describe('roof system shed geometry', () => {
       shedInsetEndPanels: true,
       wallShell: 'omit',
     })
-    const { geometry, roofSideX, sideInfillNormals, sideInfillX } = inspectShedGeometry(segment)
+    const { geometry, roofSideX, sideInfillNormals, sideInfillX, wallVertexYs } =
+      inspectShedGeometry(segment)
 
     expect(sideInfillNormals).toHaveLength(2)
+    expect(Math.min(...wallVertexYs)).toBeCloseTo(0.05, 5)
     expect(Math.max(...sideInfillX.map((x) => Math.abs(x)))).toBeCloseTo(infillHalfWidth, 5)
     expect(Math.max(...sideInfillX.map((x) => Math.abs(x)))).toBeGreaterThan(span / 2)
     expect(Math.max(...sideInfillX.map((x) => Math.abs(x)))).toBeLessThan(span / 2 + leftOverhang)
diff --git a/packages/viewer/src/systems/roof/roof-system.tsx b/packages/viewer/src/systems/roof/roof-system.tsx
index 3c4b966c0..a9a26324c 100644
--- a/packages/viewer/src/systems/roof/roof-system.tsx
+++ b/packages/viewer/src/systems/roof/roof-system.tsx
@@ -1380,7 +1380,8 @@ export function getRoofSegmentBrushes(node: RoofSegmentNode): RoofSegmentBrushSe
     const dV = Math.max(0.01, depth + 2 * wExt)
 
     const autoDrop = wExt * tanTheta
-    const whV = Math.max(0.01, wallHeight - autoDrop + vOffset)
+    // Raise the top for CSG safety; sinking the base overlaps the supporting wall.
+    const whV = Math.max(baseY + 0.05, wallHeight - autoDrop + vOffset)
 
     let rhV = activeRh
     if (activeRh > 0) {
@@ -1388,8 +1389,6 @@ export function getRoofSegmentBrushes(node: RoofSegmentNode): RoofSegmentBrushSe
       if (roofType === 'shed') rhV = activeRh + 2 * autoDrop
     }
 
-    const safeBaseY = Math.min(baseY, whV - 0.05)
-
     let structuralI = baseI
     if (isVoid) {
       structuralI += deckThickness
@@ -1401,7 +1400,7 @@ export function getRoofSegmentBrushes(node: RoofSegmentNode): RoofSegmentBrushSe
       d: dV,
       wh: whV,
       rh: rhV,
-      baseY: safeBaseY,
+      baseY,
       insets: { dutchI: structuralI },
       baseW: width,
       baseD: depth,
@@ -3589,7 +3588,7 @@ function createShedInsetEndPanelGeometry(node: RoofSegmentNode): THREE.BufferGeo
   })
   const wallOuterOffset = node.wallThickness / 2
   const autoDrop = wallOuterOffset * tanTheta
-  const wh = Math.max(0.01, node.wallHeight - autoDrop)
+  const wh = Math.max(0.05, node.wallHeight - autoDrop)
   const rh = activeRh > 0 ? activeRh + 2 * autoDrop : activeRh
 
   const faces = getRoofModuleFaces({

From bd7aa7264405ab5f62710456988544024f4698bb Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 15:13:23 -0400
Subject: [PATCH 03/27] feat(editor): Cmd/Ctrl+S saves instead of opening the
 browser dialog

Capture-phase, always-on listener so the page-save dialog never appears.
Hosts can take the chord over via onSaveShortcut; the default flushes the
autosave through the existing executeSave path.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 .../editor/src/components/editor/index.tsx    | 11 ++++++-
 .../keyboard-shortcuts-dialog.tsx             |  1 +
 packages/editor/src/hooks/use-auto-save.ts    | 26 +++++++++++++--
 .../editor/src/hooks/use-save-shortcut.ts     | 33 +++++++++++++++++++
 packages/nodes/src/block/selection.tsx        |  2 +-
 5 files changed, 69 insertions(+), 4 deletions(-)
 create mode 100644 packages/editor/src/hooks/use-save-shortcut.ts

diff --git a/packages/editor/src/components/editor/index.tsx b/packages/editor/src/components/editor/index.tsx
index d6544ee25..7c964c26e 100644
--- a/packages/editor/src/components/editor/index.tsx
+++ b/packages/editor/src/components/editor/index.tsx
@@ -34,6 +34,7 @@ import { ViewerOverlay } from '../../components/viewer-overlay'
 import { ViewerZoneSystem } from '../../components/viewer-zone-system'
 import { type SaveStatus, useAutoSave } from '../../hooks/use-auto-save'
 import { useKeyboard } from '../../hooks/use-keyboard'
+import { useSaveShortcut } from '../../hooks/use-save-shortcut'
 import { type ActivePaintMaterial, hasActivePaintMaterial } from '../../lib/material-paint'
 import {
   applySceneGraphToEditor,
@@ -194,6 +195,11 @@ export interface EditorProps {
   // Persistence — defaults to localStorage when omitted
   onLoad?: () => Promise<SceneGraph | null>
   onSave?: (scene: SceneGraph, options?: { keepalive?: boolean }) => Promise<void>
+  /**
+   * Cmd/Ctrl+S. Defaults to flushing the autosave; hosts with a richer save
+   * (the community version checkpoint) take the chord over.
+   */
+  onSaveShortcut?: () => void
   onDirty?: () => void
   onSaveStatusChange?: (status: SaveStatus) => void
 
@@ -1229,6 +1235,7 @@ function EditorContent({
   projectId,
   onLoad,
   onSave,
+  onSaveShortcut,
   onDirty,
   onSaveStatusChange,
   previewScene,
@@ -1249,13 +1256,15 @@ function EditorContent({
 
   useKeyboard({ isVersionPreviewMode, disabled: isFirstPersonMode || isStudioMode })
 
-  const { isLoadingSceneRef } = useAutoSave({
+  const { isLoadingSceneRef, saveNow } = useAutoSave({
     onSave,
     onDirty,
     onSaveStatusChange,
     isVersionPreviewMode,
   })
 
+  useSaveShortcut(onSaveShortcut ?? saveNow)
+
   const [isSceneLoading, setIsSceneLoading] = useState(false)
   const [hasLoadedInitialScene, setHasLoadedInitialScene] = useState(false)
   // A failed `onLoad` is shown as an error with a retry, never as an empty
diff --git a/packages/editor/src/components/ui/sidebar/panels/settings-panel/keyboard-shortcuts-dialog.tsx b/packages/editor/src/components/ui/sidebar/panels/settings-panel/keyboard-shortcuts-dialog.tsx
index b81d279ff..ccc4b031a 100644
--- a/packages/editor/src/components/ui/sidebar/panels/settings-panel/keyboard-shortcuts-dialog.tsx
+++ b/packages/editor/src/components/ui/sidebar/panels/settings-panel/keyboard-shortcuts-dialog.tsx
@@ -59,6 +59,7 @@ const SHORTCUT_CATEGORIES: ShortcutCategory[] = [
       { keys: ['Delete / Backspace'], action: 'Delete selected objects' },
       { keys: ['Cmd/Ctrl', 'Z'], action: 'Undo' },
       { keys: ['Cmd/Ctrl', 'Shift', 'Z'], action: 'Redo' },
+      { keys: ['Cmd/Ctrl', 'S'], action: 'Save' },
     ],
   },
   {
diff --git a/packages/editor/src/hooks/use-auto-save.ts b/packages/editor/src/hooks/use-auto-save.ts
index a64e6a047..adf1d3e8d 100644
--- a/packages/editor/src/hooks/use-auto-save.ts
+++ b/packages/editor/src/hooks/use-auto-save.ts
@@ -94,7 +94,10 @@ export function useAutoSave({
   onDirty,
   onSaveStatusChange,
   isVersionPreviewMode = false,
-}: UseAutoSaveOptions): { isLoadingSceneRef: MutableRefObject<boolean> } {
+}: UseAutoSaveOptions): {
+  isLoadingSceneRef: MutableRefObject<boolean>
+  saveNow: () => void
+} {
   const saveTimeoutRef = useRef<NodeJS.Timeout | undefined>(undefined)
   const isSavingRef = useRef(false)
   // Starts TRUE: the scene is "loading" from mount until the Editor's load
@@ -339,5 +342,24 @@ export function useAutoSave({
     setSaveStatus('saved')
   }, [isVersionPreviewMode, setSaveStatus])
 
-  return { isLoadingSceneRef }
+  // Imperative flush for the save shortcut: drop the debounce and write now,
+  // through the same `executeSave` so the wipe guard and status callbacks stay
+  // in the loop. A write already in flight only arms the follow-up.
+  const saveNow = useCallback(() => {
+    if (isLoadingSceneRef.current) return
+
+    if (saveTimeoutRef.current) {
+      clearTimeout(saveTimeoutRef.current)
+      saveTimeoutRef.current = undefined
+    }
+
+    if (isSavingRef.current) {
+      pendingSaveRef.current = true
+      return
+    }
+
+    executeSaveRef.current?.()
+  }, [])
+
+  return { isLoadingSceneRef, saveNow }
 }
diff --git a/packages/editor/src/hooks/use-save-shortcut.ts b/packages/editor/src/hooks/use-save-shortcut.ts
new file mode 100644
index 000000000..ad738c52e
--- /dev/null
+++ b/packages/editor/src/hooks/use-save-shortcut.ts
@@ -0,0 +1,33 @@
+'use client'
+
+import { useEffect, useRef } from 'react'
+
+/**
+ * Claims Cmd/Ctrl+S for the app's save.
+ *
+ * Capture phase and ungated on purpose: the browser's "Save page" dialog must
+ * never appear anywhere in the editor — including first-person, studio mode and
+ * while focus sits in an input, where people still expect the chord to save.
+ * `e.code` keeps it on the physical S key across keyboard layouts.
+ */
+export function useSaveShortcut(onSave: () => void) {
+  const onSaveRef = useRef(onSave)
+
+  useEffect(() => {
+    onSaveRef.current = onSave
+  }, [onSave])
+
+  useEffect(() => {
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if (!(e.metaKey || e.ctrlKey) || e.altKey || e.shiftKey) return
+      if (e.code !== 'KeyS') return
+
+      e.preventDefault()
+      e.stopPropagation()
+      onSaveRef.current()
+    }
+
+    window.addEventListener('keydown', handleKeyDown, true)
+    return () => window.removeEventListener('keydown', handleKeyDown, true)
+  }, [])
+}
diff --git a/packages/nodes/src/block/selection.tsx b/packages/nodes/src/block/selection.tsx
index 87d420ebf..7d326ce0b 100644
--- a/packages/nodes/src/block/selection.tsx
+++ b/packages/nodes/src/block/selection.tsx
@@ -3453,7 +3453,7 @@ function BlockEditor({
         } else if (actions.hasSelection) {
           actions.beginKeyboardTransformModal('rotate')
         }
-      } else if (key === 's') {
+      } else if (key === 's' && !(event.ctrlKey || event.metaKey)) {
         if (actions.hasSelection) {
           if (!actions.beginUniformScaleModal()) {
             playBlockSfx('tool-select')

From d9c709e5a9581ee9b81f20abbc97d6980cf087db Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 15:17:21 -0400
Subject: [PATCH 04/27] fix(tools): anchor composite presets at their footprint
 centre, lift previews to the level

Fresh (absolute) placement mapped the cursor to the node origin, so a
cabinet run landed |bounds.center| away from the pointer. Subtract the
rotated centre and keep it under the cursor across R/T. The registry
mover's box/sphere now ride the target level's stacked Y like the other
placement tools.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 .../registry/move-registry-node-tool.tsx      | 103 ++++++++++-----
 .../src/lib/planar-cursor-placement.test.ts   | 118 ++++++++++++++++++
 .../editor/src/lib/planar-cursor-placement.ts |  28 ++++-
 3 files changed, 219 insertions(+), 30 deletions(-)

diff --git a/packages/editor/src/components/tools/registry/move-registry-node-tool.tsx b/packages/editor/src/components/tools/registry/move-registry-node-tool.tsx
index 186820870..7b62a4473 100644
--- a/packages/editor/src/components/tools/registry/move-registry-node-tool.tsx
+++ b/packages/editor/src/components/tools/registry/move-registry-node-tool.tsx
@@ -11,6 +11,7 @@ import {
   collectAlignmentAnchors,
   createSceneApi,
   emitter,
+  findLevelAncestorId,
   footprintAABBFrom,
   type GridEvent,
   type GroupMoveSnapResult,
@@ -33,12 +34,16 @@ import {
   useScene,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
-import { useThree } from '@react-three/fiber'
+import { useFrame, useThree } from '@react-three/fiber'
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import type { Group } from 'three'
 import { markToolCancelConsumed } from '../../../hooks/use-keyboard'
 import { commitFreshPlacementSubtree } from '../../../lib/fresh-planar-placement'
 import { stripPlacementMetadataFlags } from '../../../lib/placement-metadata'
-import { resolvePrioritizedPlanarCursorPosition } from '../../../lib/planar-cursor-placement'
+import {
+  offsetPlanPositionByLocalCenter,
+  resolvePrioritizedPlanarCursorPosition,
+} from '../../../lib/planar-cursor-placement'
 import { resolveAttachmentPreviewRotation } from '../../../lib/rigid-plan-svg-transform'
 import { movementSfxStepKey } from '../../../lib/sfx/movement-tick'
 import { sfxEmitter } from '../../../lib/sfx-bus'
@@ -95,20 +100,6 @@ type DragBoundsOverride = {
   centerY?: number
 }
 
-function offsetPlanPositionByLocalCenter(
-  position: [number, number, number],
-  center: [number, number, number],
-  rotationY: number,
-): [number, number, number] {
-  const cos = Math.cos(rotationY)
-  const sin = Math.sin(rotationY)
-  return [
-    position[0] + center[0] * cos + center[2] * sin,
-    position[1] + center[1],
-    position[2] - center[0] * sin + center[2] * cos,
-  ]
-}
-
 /**
  * Alignment anchors for the moving node. When the kind declares
  * `capabilities.dragBounds` with an off-origin `center` (a composite cabinet
@@ -233,6 +224,20 @@ const ALIGNMENT_THRESHOLD_M = 0.08
 type ClickTriggerEvent = GridEvent | NodeEvent<AnyNode>
 
 export function MoveRegistryNodeTool({ node }: { node: AnyNode }) {
+  const previewGroupRef = useRef<Group>(null)
+  useFrame(() => {
+    if (!previewGroupRef.current) return
+    const nodes = useScene.getState().nodes
+    const parentId = nodes[node.id]?.parentId ?? node.parentId
+    const parent = parentId ? nodes[parentId as AnyNodeId] : undefined
+    // Building-parented kinds already preview in the tool group's frame.
+    const levelId =
+      (parentId ? findLevelAncestorId(parentId as AnyNodeId, nodes) : null) ??
+      (parent?.type === 'building' ? null : useViewer.getState().selection.levelId)
+    previewGroupRef.current.position.y = levelId
+      ? (sceneRegistry.nodes.get(levelId)?.position.y ?? 0)
+      : 0
+  })
   // Live camera ref — the pointer-surface cap reconstructs the cursor world
   // ray (camera → grid hit) to find which walking surface is aimed at.
   const camera = useThree((s) => s.camera)
@@ -702,12 +707,23 @@ export function MoveRegistryNodeTool({ node }: { node: AnyNode }) {
 
       const magnetic = isMagneticSnapActive()
       const attachmentEnabled = magnetic || isGridSnapActive()
+      const absolute = useAbsoluteCursorPlacement || cursorAttached
+      const centerOffset: [number, number, number] =
+        absolute && dragBounds?.center
+          ? offsetPlanPositionByLocalCenter(
+              [0, 0, 0],
+              dragBounds.center,
+              previewRotationY(freeRotationRef.current),
+            )
+          : [0, 0, 0]
       let attachmentRotationY: number | null = null
       const resolved = resolvePrioritizedPlanarCursorPosition({
         cursor: [rawX, rawZ],
         original: [originalPlanPosition[0], originalPlanPosition[2]],
         anchor: dragAnchorRef.current,
-        mode: useAbsoluteCursorPlacement || cursorAttached ? 'absolute' : 'relative',
+        mode: absolute ? 'absolute' : 'relative',
+        localCenter: dragBounds?.center,
+        rotationY: previewRotationY(freeRotationRef.current),
         // Snap follows the mode (raw in Off via snapToGridStep); Alt = force only.
         snap: gridSnapPositionConfig ? undefined : snapToGridStep,
         snapPoint:
@@ -715,7 +731,12 @@ export function MoveRegistryNodeTool({ node }: { node: AnyNode }) {
             ? ([planX, planZ]) => {
                 const snappedPosition = gridSnapPositionConfig({
                   node,
-                  candidatePosition: canonicalPositionFromPlan(planX, originalPosition[1], planZ),
+                  // Kind-owned grid hooks exchange origins and apply their own footprint offsets.
+                  candidatePosition: canonicalPositionFromPlan(
+                    planX - centerOffset[0],
+                    originalPosition[1],
+                    planZ - centerOffset[2],
+                  ),
                   candidateRotation: freeRotationRef.current,
                   movingIds: [node.id as AnyNodeId],
                   nodes: useScene.getState().nodes as Record<string, AnyNode>,
@@ -729,7 +750,10 @@ export function MoveRegistryNodeTool({ node }: { node: AnyNode }) {
                   snappedPosition,
                   freeRotationRef.current,
                 )
-                return [snappedPlanPosition[0], snappedPlanPosition[2]]
+                return [
+                  snappedPlanPosition[0] + centerOffset[0],
+                  snappedPlanPosition[2] + centerOffset[2],
+                ]
               }
             : undefined,
         resolveAttachment:
@@ -738,7 +762,8 @@ export function MoveRegistryNodeTool({ node }: { node: AnyNode }) {
                 const snapArgs: Parameters<NonNullable<typeof groupMoveSnapPoseConfig>>[0] = {
                   node,
                   candidatePosition: canonicalPositionFromPlan(planX, originalPosition[1], planZ),
-                  candidateRotation: rotationRef.current,
+                  candidateRotation:
+                    absolute && dragBounds?.center ? freeRotationRef.current : rotationRef.current,
                   movingIds: [node.id as AnyNodeId],
                   nodes: useScene.getState().nodes as Record<string, AnyNode>,
                   levelId:
@@ -1119,10 +1144,28 @@ export function MoveRegistryNodeTool({ node }: { node: AnyNode }) {
       )
       if (nextFreeRotation === null) return
       sfxEmitter.emit('sfx:item-rotate')
+      let position = lastCursorRef.current
+      if (
+        hasMovedRef.current &&
+        (useAbsoluteCursorPlacement || cursorAttached) &&
+        dragBounds?.center
+      ) {
+        const planCenter = offsetPlanPositionByLocalCenter(
+          getVisualPosition(position),
+          dragBounds.center,
+          previewRotationY(rotationRef.current),
+        )
+        const planOrigin = offsetPlanPositionByLocalCenter(
+          planCenter,
+          [-dragBounds.center[0], 0, -dragBounds.center[2]],
+          previewRotationY(nextFreeRotation),
+        )
+        position = canonicalPositionFromPlan(planOrigin[0], position[1], planOrigin[2])
+        lastCursorRef.current = position
+      }
       freeRotationRef.current = nextFreeRotation
       rotationRef.current = freeRotationRef.current
       setCursorRotationY(previewRotationY(rotationRef.current))
-      const position = lastCursorRef.current
       const visualPosition = getVisualPosition(position)
       setCursorPosition(visualPosition)
       applyMeshPose(position)
@@ -1255,12 +1298,14 @@ export function MoveRegistryNodeTool({ node }: { node: AnyNode }) {
 
   if (boxDimensions && !dragBounds?.center) {
     return (
-      <PlacementBox
-        dimensions={boxDimensions}
-        position={cursorPosition}
-        rotationY={cursorRotationY}
-        valid={valid}
-      />
+      <group ref={previewGroupRef}>
+        <PlacementBox
+          dimensions={boxDimensions}
+          position={cursorPosition}
+          rotationY={cursorRotationY}
+          valid={valid}
+        />
+      </group>
     )
   }
 
@@ -1270,7 +1315,7 @@ export function MoveRegistryNodeTool({ node }: { node: AnyNode }) {
       : cursorPosition
 
   return (
-    <>
+    <group ref={previewGroupRef}>
       <CursorSphere color="#a78bfa" height={2.5} position={dragCenterPosition} />
       <DragBoundingBox
         center={dragBounds?.center}
@@ -1281,6 +1326,6 @@ export function MoveRegistryNodeTool({ node }: { node: AnyNode }) {
         rotationY={cursorRotationY}
         size={dragBounds?.size}
       />
-    </>
+    </group>
   )
 }
diff --git a/packages/editor/src/lib/planar-cursor-placement.test.ts b/packages/editor/src/lib/planar-cursor-placement.test.ts
index f49c53398..8089ff77c 100644
--- a/packages/editor/src/lib/planar-cursor-placement.test.ts
+++ b/packages/editor/src/lib/planar-cursor-placement.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, test } from 'bun:test'
 import {
+  offsetPlanPositionByLocalCenter,
   resolvePlanarCursorPosition,
   resolvePrioritizedPlanarCursorPosition,
 } from './planar-cursor-placement'
@@ -7,6 +8,83 @@ import {
 const snapHalf = (value: number) => Math.round(value / 0.5) * 0.5
 
 describe('resolvePlanarCursorPosition', () => {
+  test('absolute mode puts the unrotated footprint centre at the snapped cursor', () => {
+    const result = resolvePlanarCursorPosition({
+      cursor: [4.24, 2.26],
+      original: [0, 0],
+      anchor: null,
+      mode: 'absolute',
+      localCenter: [1.3, 0.5, 0.2],
+      snap: snapHalf,
+    })
+
+    expect(result.point).toEqual([2.7, 2.3])
+    expect(result.anchor).toBeNull()
+  })
+
+  test('absolute mode snaps the centre before deriving the rotated origin', () => {
+    const proposals: [number, number][] = []
+    const localCenter: [number, number, number] = [1.3, 0.5, 0.2]
+    const result = resolvePlanarCursorPosition({
+      cursor: [4.24, 2.26],
+      original: [0, 0],
+      anchor: null,
+      mode: 'absolute',
+      localCenter,
+      rotationY: Math.PI / 2,
+      snapPoint: (point) => {
+        proposals.push(point)
+        return [snapHalf(point[0]), snapHalf(point[1])]
+      },
+    })
+
+    expect(proposals).toEqual([[4.24, 2.26]])
+    expect(result.point[0]).toBeCloseTo(3.8)
+    expect(result.point[1]).toBeCloseTo(3.8)
+    const centre = offsetPlanPositionByLocalCenter(
+      [result.point[0], 0, result.point[1]],
+      localCenter,
+      Math.PI / 2,
+    )
+    expect(centre[0]).toBeCloseTo(4)
+    expect(centre[2]).toBeCloseTo(2.5)
+  })
+
+  test('absolute mode follows the unsnapped cursor at an oblique rotation', () => {
+    const localCenter: [number, number, number] = [1.5, 0.5, -0.3]
+    const result = resolvePlanarCursorPosition({
+      cursor: [-2.13, 6.27],
+      original: [0, 0],
+      anchor: null,
+      mode: 'absolute',
+      localCenter,
+      rotationY: -Math.PI / 4,
+    })
+    const centre = offsetPlanPositionByLocalCenter(
+      [result.point[0], 0, result.point[1]],
+      localCenter,
+      -Math.PI / 4,
+    )
+
+    expect(centre[0]).toBeCloseTo(-2.13)
+    expect(centre[2]).toBeCloseTo(6.27)
+  })
+
+  test('relative mode ignores the footprint centre and rotation', () => {
+    const result = resolvePlanarCursorPosition({
+      cursor: [4.9, 5.2],
+      original: [10, 20],
+      anchor: [4.1, 6.1],
+      mode: 'relative',
+      localCenter: [1.3, 0.5, 0.2],
+      rotationY: Math.PI / 2,
+      snap: snapHalf,
+    })
+
+    expect(result.point).toEqual([11, 19])
+    expect(result.anchor).toEqual([4.1, 6.1])
+  })
+
   test('absolute mode places the point directly at the snapped cursor', () => {
     const result = resolvePlanarCursorPosition({
       cursor: [1.24, -2.26],
@@ -103,6 +181,46 @@ describe('resolvePlanarCursorPosition', () => {
 })
 
 describe('resolvePrioritizedPlanarCursorPosition', () => {
+  test('attachment receives the corrected raw origin and returns the final origin', () => {
+    const proposals: [number, number][] = []
+    const result = resolvePrioritizedPlanarCursorPosition({
+      cursor: [4.24, 2.26],
+      original: [0, 0],
+      anchor: null,
+      mode: 'absolute',
+      localCenter: [1.3, 0.5, 0.2],
+      rotationY: Math.PI / 2,
+      snapPoint: () => {
+        throw new Error('Grid snapping must not run after attachment')
+      },
+      resolveAttachment: (proposal) => {
+        proposals.push(proposal)
+        return [3, 5]
+      },
+    })
+
+    expect(proposals).toHaveLength(1)
+    expect(proposals[0]![0]).toBeCloseTo(4.04)
+    expect(proposals[0]![1]).toBeCloseTo(3.56)
+    expect(result.point).toEqual([3, 5])
+    expect(result.attachmentSnapped).toBe(true)
+  })
+
+  test('snaps the footprint centre when attachment declines the corrected origin', () => {
+    const result = resolvePrioritizedPlanarCursorPosition({
+      cursor: [4.24, 2.26],
+      original: [0, 0],
+      anchor: null,
+      mode: 'absolute',
+      localCenter: [1.3, 0.5, 0.2],
+      snapPoint: ([x, z]) => [snapHalf(x), snapHalf(z)],
+      resolveAttachment: () => null,
+    })
+
+    expect(result.point).toEqual([2.7, 2.3])
+    expect(result.attachmentSnapped).toBe(false)
+  })
+
   test('wall attachment receives the raw proposal and wins over grid snapping', () => {
     const attachmentProposals: [number, number][] = []
     const result = resolvePrioritizedPlanarCursorPosition({
diff --git a/packages/editor/src/lib/planar-cursor-placement.ts b/packages/editor/src/lib/planar-cursor-placement.ts
index 2bd61203f..df1a077aa 100644
--- a/packages/editor/src/lib/planar-cursor-placement.ts
+++ b/packages/editor/src/lib/planar-cursor-placement.ts
@@ -7,6 +7,8 @@ type ResolvePlanarCursorPositionArgs = {
   original: PlanarPoint
   anchor: PlanarPoint | null
   mode: PlanarCursorPlacementMode
+  localCenter?: [number, number, number]
+  rotationY?: number
   snap?: (value: number) => number
   snapPoint?: (point: PlanarPoint) => PlanarPoint
 }
@@ -26,18 +28,42 @@ type ResolvePrioritizedPlanarCursorPositionResult = ResolvePlanarCursorPositionR
 
 const identity = (value: number) => value
 
+export function offsetPlanPositionByLocalCenter(
+  position: [number, number, number],
+  center: [number, number, number],
+  rotationY: number,
+): [number, number, number] {
+  const cos = Math.cos(rotationY)
+  const sin = Math.sin(rotationY)
+  return [
+    position[0] + center[0] * cos + center[2] * sin,
+    position[1] + center[1],
+    position[2] - center[0] * sin + center[2] * cos,
+  ]
+}
+
 export function resolvePlanarCursorPosition({
   cursor,
   original,
   anchor,
   mode,
+  localCenter,
+  rotationY = 0,
   snap = identity,
   snapPoint,
 }: ResolvePlanarCursorPositionArgs): ResolvePlanarCursorPositionResult {
   if (mode === 'absolute') {
     const proposal: PlanarPoint = [cursor[0], cursor[1]]
+    const snapped: PlanarPoint = snapPoint?.(proposal) ?? [snap(cursor[0]), snap(cursor[1])]
+    const origin: [number, number, number] = localCenter
+      ? offsetPlanPositionByLocalCenter(
+          [snapped[0], 0, snapped[1]],
+          [-localCenter[0], 0, -localCenter[2]],
+          rotationY,
+        )
+      : [snapped[0], 0, snapped[1]]
     return {
-      point: snapPoint?.(proposal) ?? [snap(cursor[0]), snap(cursor[1])],
+      point: [origin[0], origin[2]],
       anchor,
     }
   }

From c4a15351152be56a2ec67a41e92a87886428f0f0 Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 15:28:47 -0400
Subject: [PATCH 05/27] fix(stair): follow the storey height from the elected
 base

Level-destination stairs returned the full floor-to-floor height even
when a slab lifted their base, so the top overshot the storey plane. The
resolver now subtracts the elected base for both destinations. The panel
exposes Follows storey / Custom rise for level stairs, and the stair tool
and landing toggle seed from the storey instead of a 2.5 m constant.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 .../core/src/systems/stair/stair-rise.test.ts | 141 +++++++++++++++---
 packages/core/src/systems/stair/stair-rise.ts |  42 +++---
 .../src/components/tools/stair/stair-tool.tsx |  25 ++--
 packages/nodes/src/stair-segment/panel.tsx    |  15 +-
 packages/nodes/src/stair/panel.tsx            |  68 ++++-----
 wiki/architecture/vertical-model.md           |   2 +-
 6 files changed, 207 insertions(+), 86 deletions(-)

diff --git a/packages/core/src/systems/stair/stair-rise.test.ts b/packages/core/src/systems/stair/stair-rise.test.ts
index 8a2e78e7a..d4939b81e 100644
--- a/packages/core/src/systems/stair/stair-rise.test.ts
+++ b/packages/core/src/systems/stair/stair-rise.test.ts
@@ -95,6 +95,27 @@ function buildDeckScene(options: {
   return { deck, stair, nodes }
 }
 
+function registerStairFootprint() {
+  registerNode({
+    kind: 'stair',
+    schemaVersion: 1,
+    schema: z.object({ type: z.literal('stair') }) as never,
+    category: 'structure',
+    defaults: () => ({}) as never,
+    capabilities: {
+      floorPlaced: {
+        footprints: (node) => [
+          {
+            position: (node as StairNodeType).position,
+            dimensions: [1, 1, 2] as [number, number, number],
+            rotation: [0, 0, 0] as [number, number, number],
+          },
+        ],
+      },
+    },
+  } as AnyNodeDefinition)
+}
+
 function buildLevelSceneWithSegments(options: {
   levelHeight: number
   totalRise?: number
@@ -349,24 +370,7 @@ describe('deck-attached rise with a floor-lifted base', () => {
   ]
 
   beforeEach(() => {
-    registerNode({
-      kind: 'stair',
-      schemaVersion: 1,
-      schema: z.object({ type: z.literal('stair') }) as never,
-      category: 'structure',
-      defaults: () => ({}) as never,
-      capabilities: {
-        floorPlaced: {
-          footprints: (node) => [
-            {
-              position: (node as StairNodeType).position,
-              dimensions: [1, 1, 2] as [number, number, number],
-              rotation: [0, 0, 0] as [number, number, number],
-            },
-          ],
-        },
-      },
-    } as AnyNodeDefinition)
+    registerStairFootprint()
   })
 
   function makeFloorSlab(elevation: number) {
@@ -497,3 +501,104 @@ describe('deck-attached rise with a floor-lifted base', () => {
     expect(resolveStairTotalRise(stair, nodes)).toBeCloseTo(1.25)
   })
 })
+
+// A level-destination stair climbs to the storey plane above, which is an
+// absolute level-local height — so a slab that lifts the stair's own base eats
+// into the rise. Without the subtraction the last step overshoots the floor
+// above by the slab's thickness (and a tall storey used to be missed entirely).
+describe('level rise with a floor-lifted base', () => {
+  const FLOOR_POLYGON: Array<[number, number]> = [
+    [-5, -5],
+    [5, -5],
+    [5, 5],
+    [-5, 5],
+  ]
+
+  beforeEach(() => {
+    registerStairFootprint()
+  })
+
+  function buildLiftedLevelScene(options: {
+    levelHeight: number
+    floorElevation?: number | null
+    totalRise?: number
+    segments?: Array<{ id: string; segmentType: 'stair' | 'landing'; height: number }>
+  }) {
+    const scene = buildLevelSceneWithSegments({
+      levelHeight: options.levelHeight,
+      totalRise: options.totalRise,
+      segments: options.segments ?? [],
+    })
+    if (options.floorElevation == null) return { ...scene, floor: null }
+
+    const floor = SlabNode.parse({
+      id: 'slab_floor',
+      type: 'slab',
+      polygon: FLOOR_POLYGON,
+      elevation: options.floorElevation,
+      thickness: 0.05,
+    })
+    spatialGridManager.handleNodeCreated(floor as AnyNode, 'level_1')
+    return {
+      ...scene,
+      floor,
+      nodes: { ...scene.nodes, [floor.id]: floor } as Record<string, AnyNode>,
+    }
+  }
+
+  it('lands the last step on the storey plane: rise = floor-to-floor − elected base', () => {
+    const { stair, nodes } = buildLiftedLevelScene({ levelHeight: 5.3, floorElevation: 0.05 })
+    const base = getFloorPlacedElevation({
+      node: stair,
+      nodes,
+      position: stair.position,
+      rotation: stair.rotation,
+      levelId: 'level_1',
+    })
+    expect(base).toBeCloseTo(0.05)
+    const rise = resolveStairTotalRise(stair, nodes)
+    expect(rise).toBeCloseTo(5.25)
+    expect(base + rise).toBeCloseTo(5.3)
+  })
+
+  it('keeps the full storey height when the stair stands on bare ground', () => {
+    const { stair, nodes } = buildLiftedLevelScene({ levelHeight: 5.3, floorElevation: null })
+    expect(resolveStairTotalRise(stair, nodes)).toBeCloseTo(5.3)
+  })
+
+  it('lets an explicit totalRise win over the base-adjusted storey rise', () => {
+    const { stair, nodes } = buildLiftedLevelScene({
+      levelHeight: 5.3,
+      floorElevation: 0.05,
+      totalRise: 2.7,
+    })
+    expect(resolveStairTotalRise(stair, nodes)).toBe(2.7)
+  })
+
+  it('converges a straight flight to the base-adjusted storey rise', () => {
+    const { nodes } = buildLiftedLevelScene({
+      levelHeight: 5.3,
+      floorElevation: 0.05,
+      segments: [{ id: 'sseg_1', segmentType: 'stair', height: 2.5 }],
+    })
+    const updates = syncStairRises(nodes)
+    expect(updates).toHaveLength(1)
+    expect(updates[0]?.id).toBe('sseg_1' as never)
+    expect((updates[0]?.data as { height?: number }).height).toBeCloseTo(5.25)
+  })
+
+  it('re-converges after the base slab elevation changes', () => {
+    const scene = buildLiftedLevelScene({
+      levelHeight: 2.5,
+      floorElevation: 0.05,
+      segments: [{ id: 'sseg_1', segmentType: 'stair', height: 2.45 }],
+    })
+    expect(syncStairRises(scene.nodes)).toEqual([])
+    const movedFloor = { ...scene.floor, elevation: 0.3 }
+    const nodes = { ...scene.nodes, slab_floor: movedFloor as AnyNode }
+    spatialGridManager.handleNodeUpdated(movedFloor as AnyNode, 'level_1')
+    const updates = syncStairRises(nodes)
+    expect(updates).toHaveLength(1)
+    expect((updates[0]?.data as { height?: number }).height).toBeCloseTo(2.2)
+  })
+})
diff --git a/packages/core/src/systems/stair/stair-rise.ts b/packages/core/src/systems/stair/stair-rise.ts
index f67a07755..3e62daf6b 100644
--- a/packages/core/src/systems/stair/stair-rise.ts
+++ b/packages/core/src/systems/stair/stair-rise.ts
@@ -10,32 +10,30 @@ export function resolveStairTotalRise(stair: StairNode, nodes: Record<string, An
     (node) => node.type === 'level' && node.children.includes(stair.id),
   )
 
+  // Both destinations are absolute level-local heights, while the stair's own
+  // base may be lifted onto a floor slab by the floor-stack
+  // (`FloorElevationSystem` / `syncStairGroupElevation` put the group at
+  // `position[1] + elected slab elevation`). The rise is measured from that
+  // base, so subtract it — electing the base exactly the way the visual
+  // systems do (persisted `supportSlabId` honored, uncapped election
+  // otherwise) keeps base + rise landing precisely on the destination surface.
+  const baseElevation = getFloorStackedPosition({
+    node: stair,
+    nodes,
+    position: stair.position,
+    rotation: stair.rotation,
+    levelId: level?.id ?? null,
+  })[1]
+
   if (stair.deckSlabId) {
+    // The deck's `elevation` IS its walking surface (level-local). A stale
+    // reference (deck gone) falls through to the level-derived rise.
     const deck = nodes[stair.deckSlabId]
-    // The deck's `elevation` IS its walking surface (level-local), but the
-    // stair's own base may be lifted onto a floor slab by the floor-stack
-    // (`FloorElevationSystem` / `syncStairGroupElevation` put the group at
-    // `position[1] + elected slab elevation`). The rise is measured from
-    // that base, so subtract it — electing the base exactly the way the
-    // visual systems do (persisted `supportSlabId` honored, uncapped
-    // election otherwise) keeps base + rise landing precisely on the deck's
-    // walking surface. A stale reference (deck gone) falls through to the
-    // level-derived rise.
-    if (deck?.type === 'slab') {
-      const baseElevation = getFloorStackedPosition({
-        node: stair,
-        nodes,
-        position: stair.position,
-        rotation: stair.rotation,
-        levelId: level?.id ?? null,
-      })[1]
-      return (deck.elevation ?? 0.05) - baseElevation
-    }
+    if (deck?.type === 'slab') return (deck.elevation ?? 0.05) - baseElevation
   }
 
-  return level?.type === 'level'
-    ? getLevelFloorToFloorHeight(level.id, nodes as Record<AnyNodeId, AnyNode>)
-    : DEFAULT_LEVEL_HEIGHT
+  if (level?.type !== 'level') return DEFAULT_LEVEL_HEIGHT
+  return getLevelFloorToFloorHeight(level.id, nodes as Record<AnyNodeId, AnyNode>) - baseElevation
 }
 
 const RISE_SYNC_EPSILON = 1e-4
diff --git a/packages/editor/src/components/tools/stair/stair-tool.tsx b/packages/editor/src/components/tools/stair/stair-tool.tsx
index a07de846c..9d68d491f 100644
--- a/packages/editor/src/components/tools/stair/stair-tool.tsx
+++ b/packages/editor/src/components/tools/stair/stair-tool.tsx
@@ -2,8 +2,10 @@ import {
   type AnyNode,
   collectAlignmentAnchors,
   createSurfaceOpeningPreviewController,
+  DEFAULT_LEVEL_HEIGHT,
   emitter,
   type GridEvent,
+  getLevelFloorToFloorHeight,
   type LevelNode,
   movingAlignmentAnchors,
   type NodeEvent,
@@ -50,7 +52,6 @@ import {
   DEFAULT_SPIRAL_TOP_LANDING_MODE,
   DEFAULT_STAIR_ATTACHMENT_SIDE,
   DEFAULT_STAIR_FILL_TO_FLOOR,
-  DEFAULT_STAIR_HEIGHT,
   DEFAULT_STAIR_LENGTH,
   DEFAULT_STAIR_OPENING_OFFSET,
   DEFAULT_STAIR_RAILING_HEIGHT,
@@ -71,8 +72,8 @@ type MoveTriggerEvent = GridEvent | NodeEvent<AnyNode>
  * Generates the step-profile geometry for the ghost preview.
  * Same algorithm as StairSystem's generateStairSegmentGeometry.
  */
-function createStairPreviewGeometry(): THREE.BufferGeometry {
-  const riserHeight = DEFAULT_STAIR_HEIGHT / DEFAULT_STAIR_STEP_COUNT
+function createStairPreviewGeometry(rise: number): THREE.BufferGeometry {
+  const riserHeight = rise / DEFAULT_STAIR_STEP_COUNT
   const treadDepth = DEFAULT_STAIR_LENGTH / DEFAULT_STAIR_STEP_COUNT
 
   const shape = new THREE.Shape()
@@ -103,14 +104,16 @@ function createStairPreviewGeometry(): THREE.BufferGeometry {
 }
 
 /**
- * Creates a default straight stair segment.
+ * Creates a default straight stair segment climbing `rise` — the storey it is
+ * dropped on, not a constant: the placed stair has no explicit `totalRise`, so
+ * this is the height `syncStairRises` immediately converges it to anyway.
  */
-function createDefaultStairSegment() {
+function createDefaultStairSegment(rise: number) {
   return StairSegmentNode.parse({
     segmentType: 'stair',
     width: DEFAULT_STAIR_WIDTH,
     length: DEFAULT_STAIR_LENGTH,
-    height: DEFAULT_STAIR_HEIGHT,
+    height: rise,
     stepCount: DEFAULT_STAIR_STEP_COUNT,
     attachmentSide: DEFAULT_STAIR_ATTACHMENT_SIDE,
     fillToFloor: DEFAULT_STAIR_FILL_TO_FLOOR,
@@ -178,7 +181,7 @@ function commitStairPlacement(
 
   const stairCount = Object.values(nodes).filter((n) => n.type === 'stair').length
   const name = `Staircase ${stairCount + 1}`
-  const segment = createDefaultStairSegment()
+  const segment = createDefaultStairSegment(getLevelFloorToFloorHeight(placementLevelId, nodes))
 
   const destinationPlan = resolveStairDestinationLevel({
     createMissing: true,
@@ -248,7 +251,11 @@ export const StairTool: React.FC = () => {
   const lastCanonicalPositionRef = useRef<[number, number, number] | null>(null)
   const currentLevelId = useViewer((state) => state.selection.levelId)
 
-  const previewGeometry = useMemo(() => createStairPreviewGeometry(), [])
+  const previewRise = useScene((state) =>
+    currentLevelId ? getLevelFloorToFloorHeight(currentLevelId, state.nodes) : DEFAULT_LEVEL_HEIGHT,
+  )
+  const previewGeometry = useMemo(() => createStairPreviewGeometry(previewRise), [previewRise])
+  useEffect(() => () => previewGeometry.dispose(), [previewGeometry])
 
   useEffect(() => {
     if (!currentLevelId) return
@@ -280,7 +287,7 @@ export const StairTool: React.FC = () => {
         nodes,
       })
       const nextLevelId = destinationPlan?.toLevel.id ?? placementLevelId
-      const segment = createDefaultStairSegment()
+      const segment = createDefaultStairSegment(getLevelFloorToFloorHeight(placementLevelId, nodes))
       const stair = createDefaultStairNode({
         name: 'Staircase Preview',
         levelId: placementLevelId,
diff --git a/packages/nodes/src/stair-segment/panel.tsx b/packages/nodes/src/stair-segment/panel.tsx
index daad0fa4b..698216d33 100644
--- a/packages/nodes/src/stair-segment/panel.tsx
+++ b/packages/nodes/src/stair-segment/panel.tsx
@@ -4,6 +4,8 @@ import {
   type AnyNode,
   type AnyNodeId,
   type AttachmentSide,
+  DEFAULT_LEVEL_HEIGHT,
+  resolveStairTotalRise,
   type StairSegmentNode,
   StairSegmentNode as StairSegmentNodeSchema,
   type StairSegmentType,
@@ -67,6 +69,17 @@ export default function StairSegmentPanel() {
     setSelection({ selectedIds: [] })
   }, [setSelection])
 
+  // Turning a landing back into a flight seeds the rise the parent stair
+  // resolves — a fixed 2.5 m stops halfway up a tall storey, and for a
+  // follows-mode stair it is what `syncStairRises` would converge to anyway.
+  const resolveParentStairRise = useCallback(() => {
+    const sceneNodes = useScene.getState().nodes
+    const parent = node?.parentId ? sceneNodes[node.parentId as AnyNodeId] : undefined
+    return parent?.type === 'stair'
+      ? resolveStairTotalRise(parent, sceneNodes)
+      : DEFAULT_LEVEL_HEIGHT
+  }, [node])
+
   const handleBack = useCallback(() => {
     if (node?.parentId) {
       setSelection({ selectedIds: [node.parentId] })
@@ -136,7 +149,7 @@ export default function StairSegmentPanel() {
               updates.stepCount = 0
               updates.length = 1.0
             } else {
-              updates.height = 2.5
+              updates.height = resolveParentStairRise()
               updates.stepCount = 10
               updates.length = 3.0
             }
diff --git a/packages/nodes/src/stair/panel.tsx b/packages/nodes/src/stair/panel.tsx
index 9500bbce8..e6f135065 100644
--- a/packages/nodes/src/stair/panel.tsx
+++ b/packages/nodes/src/stair/panel.tsx
@@ -331,41 +331,39 @@ export default function StairPanel() {
             </select>
           </div>
 
-          {attachedDeck ? (
-            <div className="space-y-1.5">
-              <div className="px-1 text-[11px] text-muted-foreground uppercase tracking-[0.14em]">
-                Rise
+          <div className="space-y-1.5">
+            <div className="px-1 text-[11px] text-muted-foreground uppercase tracking-[0.14em]">
+              Rise
+            </div>
+            <SegmentedControl
+              onChange={(value) =>
+                handleUpdate(
+                  value === 'custom' ? { totalRise: resolvedRise } : { totalRise: undefined },
+                )
+              }
+              options={[
+                { label: attachedDeck ? 'Follows deck' : 'Follows storey', value: 'follows' },
+                { label: 'Custom rise', value: 'custom' },
+              ]}
+              value={node.totalRise == null ? 'follows' : 'custom'}
+            />
+            {node.totalRise == null ? (
+              <div className="px-1 text-[11px] text-muted-foreground">
+                Currently {resolvedRise} m
               </div>
-              <SegmentedControl
-                onChange={(value) =>
-                  handleUpdate(
-                    value === 'custom' ? { totalRise: resolvedRise } : { totalRise: undefined },
-                  )
-                }
-                options={[
-                  { label: 'Follows deck', value: 'follows' },
-                  { label: 'Custom rise', value: 'custom' },
-                ]}
-                value={node.totalRise == null ? 'follows' : 'custom'}
+            ) : (
+              <MetricControl
+                label="Rise"
+                max={1000}
+                min={0.2}
+                onChange={(value) => handleUpdate({ totalRise: value })}
+                precision={2}
+                step={0.05}
+                unit="m"
+                value={resolvedRise}
               />
-              {node.totalRise == null ? (
-                <div className="px-1 text-[11px] text-muted-foreground">
-                  Currently {resolvedRise} m
-                </div>
-              ) : (
-                <MetricControl
-                  label="Rise"
-                  max={10}
-                  min={0.2}
-                  onChange={(value) => handleUpdate({ totalRise: value })}
-                  precision={2}
-                  step={0.05}
-                  unit="m"
-                  value={resolvedRise}
-                />
-              )}
-            </div>
-          ) : null}
+            )}
+          </div>
 
           {attachedDeck ? null : (
             <>
@@ -463,13 +461,13 @@ export default function StairPanel() {
           />
           <MetricControl
             label="Rise"
-            max={10}
+            max={1000}
             min={0.2}
             onChange={(value) => handleUpdate({ totalRise: value })}
             precision={2}
             step={0.05}
             unit="m"
-            value={Math.round(resolveStairTotalRise(node, nodes) * 100) / 100}
+            value={resolvedRise}
           />
           <MetricControl
             label="Steps"
diff --git a/wiki/architecture/vertical-model.md b/wiki/architecture/vertical-model.md
index 521441d61..fd7c66fee 100644
--- a/wiki/architecture/vertical-model.md
+++ b/wiki/architecture/vertical-model.md
@@ -31,7 +31,7 @@ The invariant, in one sentence:
 | `fence.supportOffset` | Optional level-local delta from the fence's slab host or level plane. It translates the complete fence while preserving height. | Zero offset: the fence sits directly on its host or level plane. |
 | `wall.fillToTerrain` | Extends the wall downward from its authored base to the terrain with independently sampled left/right faces. The wall body height and top stay unchanged. | Fixed base with no terrain infill. |
 | `stair.deckSlabId` | Destination deck: rise follows `deck.elevation − the stair's own elected base` live; cutout sync disabled while attached. | Destination is a level. |
-| `stair.totalRise` | Explicit custom rise (wins over everything). | Follows: derived from the deck or the containing level; `syncStairRises` converges straight-stair segments to the resolved rise. |
+| `stair.totalRise` | Explicit custom rise (wins over everything). | Follows: the deck's `elevation`, else the containing level's floor-to-floor height — each **minus the stair's own elected base**, so a slab under the stair shortens the rise the way it shortens a plane-bound wall; `syncStairRises` converges straight-stair segments to the resolved rise. |
 
 Two schema rules protect these semantics:
 

From 9035df7639a68f65b4ecff055f87db0a2955ad84 Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 15:30:45 -0400
Subject: [PATCH 06/27] fix(item): drop un-hosted items to the floor, draw the
 placement box on the right storey

The floor-path Y was frozen at drag start (#638), so an item pulled off a
shelf kept the shelf height after reparenting. Read the live grid Y
instead. The cursor group, grid surface and facing pose now add the
level mesh's stacked Y, which the building-local tool group lacks.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 .../tools/item/placement-strategies.test.ts   | 39 ++++++++++-
 .../tools/item/use-placement-coordinator.tsx  | 65 ++++++++++++++++---
 2 files changed, 93 insertions(+), 11 deletions(-)

diff --git a/packages/editor/src/components/tools/item/placement-strategies.test.ts b/packages/editor/src/components/tools/item/placement-strategies.test.ts
index b01048dd4..73006ceb0 100644
--- a/packages/editor/src/components/tools/item/placement-strategies.test.ts
+++ b/packages/editor/src/components/tools/item/placement-strategies.test.ts
@@ -1,6 +1,7 @@
 import { beforeEach, describe, expect, test } from 'bun:test'
 import {
   BlockNode,
+  type GridEvent,
   ItemNode,
   type LevelNode,
   type NodeEvent,
@@ -9,7 +10,7 @@ import {
   type WallNode,
 } from '@pascal-app/core'
 import { BufferGeometry, Mesh, MeshBasicMaterial, type Object3D, Vector3 } from 'three'
-import { faceHostStrategy, wallStrategy } from './placement-strategies'
+import { faceHostStrategy, floorStrategy, wallStrategy } from './placement-strategies'
 import type { PlacementContext, SpatialValidators } from './placement-types'
 import { registerTestBlockFaceHost } from './test-face-host'
 
@@ -455,3 +456,39 @@ describe('wallStrategy.move', () => {
     expect(result.cursorPosition[1]).toBeCloseTo(0.4 + 0.05, 6)
   })
 })
+
+describe('floorStrategy.move', () => {
+  function makeGridEvent(x: number, y: number, z: number): GridEvent {
+    return {
+      position: [x, y, z],
+      localPosition: [x, y, z],
+      nativeEvent: {} as GridEvent['nativeEvent'],
+    }
+  }
+
+  test('follows the live grid Y so a raised placement keeps its height', () => {
+    const context = floorItemContext()
+    context.gridPosition.set(0, 0.9, 0)
+
+    const result = floorStrategy.move(context, makeGridEvent(1.25, 0.9, 2.25))
+    if (!result) throw new Error('expected a placement result')
+
+    expect(result.gridPosition[1]).toBe(0.9)
+    expect(result.cursorPosition[1]).toBe(0.9)
+  })
+
+  // `detachItemSurfaceToFloor` zeroes the grid Y when an item is taken off a
+  // host; the floor path must honour that instead of a Y frozen at drag start,
+  // or the item commits floating at the shelf's height.
+  test('drops to the level plane once un-hosting zeroes the grid Y', () => {
+    const context = floorItemContext()
+    context.gridPosition.set(0, 0, 0)
+
+    const result = floorStrategy.move(context, makeGridEvent(1.25, 0.9, 2.25))
+    if (!result) throw new Error('expected a placement result')
+
+    expect(result.gridPosition[1]).toBe(0)
+    expect(result.cursorPosition[1]).toBe(0)
+    expect(result.nodeUpdate?.position?.[1]).toBe(0)
+  })
+})
diff --git a/packages/editor/src/components/tools/item/use-placement-coordinator.tsx b/packages/editor/src/components/tools/item/use-placement-coordinator.tsx
index ccc793d41..b6a66b393 100644
--- a/packages/editor/src/components/tools/item/use-placement-coordinator.tsx
+++ b/packages/editor/src/components/tools/item/use-placement-coordinator.tsx
@@ -6,6 +6,7 @@ import {
   type CeilingEvent,
   collectAlignmentAnchors,
   emitter,
+  findLevelAncestorId,
   type GridEvent,
   getScaledDimensions,
   type ItemEvent,
@@ -193,6 +194,27 @@ function getGridAlignedPreviewNode(item: ItemNode): ItemNode {
   }
 }
 
+/**
+ * Building-local Y of the storey the floor-path ghost belongs to.
+ *
+ * The cursor group is mounted inside ToolManager's building-local group, which
+ * carries no per-floor elevation, while every floor-path position (grid
+ * position, `getFloorVisualPosition`) is LEVEL-local — so on an upper storey the
+ * wireframe and its dimension labels render a floor too low. The wall / ceiling
+ * / item-surface paths don't need this: they convert a world hit through
+ * `worldToBuildingLocal`, which already carries the storey.
+ *
+ * Read off the level mesh (same source as `LevelOffsetGroup`) rather than the
+ * stored elevation so the ghost also follows the exploded-view lerp.
+ */
+function getPlacementLevelY(draft: ItemNode | null | undefined): number {
+  const levelId =
+    (draft ? findLevelAncestorId(draft.id, useScene.getState().nodes) : null) ??
+    useViewer.getState().selection.levelId
+  const levelMesh = levelId ? sceneRegistry.nodes.get(levelId as AnyNodeId) : null
+  return levelMesh ? levelMesh.position.y : 0
+}
+
 // Shared materials for placement cursor - we just change colors, not swap materials
 // Note: EdgesGeometry doesn't work with dashed lines, so using solid lines
 const edgeMaterial = new LineBasicNodeMaterial({
@@ -521,7 +543,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
     if (!asset.attachTo && placementState.current.surface === 'floor') {
       gridPosition.current.y = 0
       if (cursorGroupRef.current) {
-        cursorGroupRef.current.position.y = 0
+        cursorGroupRef.current.position.y = getPlacementLevelY(draftNode.current)
       }
     }
 
@@ -731,7 +753,6 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
 
     // ---- Init draft ----
     configRef.current.initDraft(gridPosition.current)
-    const floorAuthoredY = draftNode.current?.position[1] ?? 0
     const preserveDragOffset = configRef.current.preserveDragOffset === true
     // The host the item was grabbed from + its pre-drag host-local position.
     // Each surface's grab anchor preserves the grab offset only on THAT host,
@@ -890,7 +911,10 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
           }
         }
       } else if (cursorGroupRef.current) {
+        // No registered mesh yet (a just-created draft renders next tick), so
+        // fall back to the level-local grid position lifted onto its storey.
         cursorGroupRef.current.position.copy(gridPosition.current)
+        cursorGroupRef.current.position.y += getPlacementLevelY(draftNode.current)
         cursorGroupRef.current.rotation.y = draftNode.current.rotation[1] ?? 0
       }
     }
@@ -1064,9 +1088,15 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
         useAlignmentGuides.getState().clear()
       }
 
+      // `result.gridPosition[1]` is the LIVE `gridPosition.current.y` — seeded
+      // from the draft's authored Y by `initDraft` (so a block-face / raised
+      // construction-plane item keeps its height) and zeroed by
+      // `detachItemSurfaceToFloor` / `faceHostStrategy.leave` when the item
+      // comes back down. Freezing it at drag start instead left an item taken
+      // off a shelf floating at the shelf's height.
       let gridPos: [number, number, number] = [
         result.gridPosition[0] + alignX,
-        floorAuthoredY,
+        result.gridPosition[1],
         result.gridPosition[2] + alignZ,
       ]
       frozenSupportSlabIdRef.current = undefined
@@ -1104,7 +1134,11 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       if (!draft && asset.attachTo) {
         cursorPosition[1] += getDetachedAttachmentPreviewLift(asset.attachTo)
       }
-      cursorGroupRef.current.position.set(cursorPosition[0], cursorPosition[1], cursorPosition[2])
+      cursorGroupRef.current.position.set(
+        cursorPosition[0],
+        cursorPosition[1] + getPlacementLevelY(draft),
+        cursorPosition[2],
+      )
       // Floor items only rotate on Y; keep the preview box (and the live
       // transform the 2D floorplan mirrors) aligned with the draft's
       // rotation. Without this the box stays at its seed rotation until a
@@ -1684,7 +1718,11 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
         levelId ? { parentId: levelId } : undefined,
       )
       if (cursorGroupRef.current) {
-        cursorGroupRef.current.position.set(...floorVisualPosition)
+        cursorGroupRef.current.position.set(
+          floorVisualPosition[0],
+          floorVisualPosition[1] + getPlacementLevelY(draftNode.current),
+          floorVisualPosition[2],
+        )
       }
 
       const draft = draftNode.current
@@ -2271,8 +2309,11 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
           draft.position = [x, gridPosition.current.y, z]
           if (cursorGroupRef.current) {
             if (surface === 'floor') {
+              const visual = getFloorVisualPosition([x, gridPosition.current.y, z])
               cursorGroupRef.current.position.set(
-                ...getFloorVisualPosition([x, gridPosition.current.y, z]),
+                visual[0],
+                visual[1] + getPlacementLevelY(draft),
+                visual[2],
               )
             } else {
               cursorGroupRef.current.position.x = x
@@ -2601,6 +2642,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
   // moving existing node has no draft here, so the grid reads that case straight
   // off the node's mesh. Cleared when idle.
   const surfaceNormalRef = useRef(new Vector3(0, 1, 0))
+  const surfaceWorldPointRef = useRef(new Vector3())
   const facingForwardRef = useRef(new Vector3(0, 0, 1))
   const facingQuatRef = useRef(new Quaternion())
   const ghostSurfaceQuatRef = useRef(new Quaternion())
@@ -2642,13 +2684,15 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       const fwd = facingForwardRef.current.copy(n)
       if (fwd.lengthSq() > 1e-6) facingYaw = Math.atan2(fwd.x, fwd.z)
       // The forward triangle is a floor aid; drop it to the building-local floor
-      // under the hosted plane.
-      facingY = 0
+      // under the hosted plane — the storey's floor, not world ground.
+      facingY = getPlacementLevelY(draftNode.current)
     } else {
       ghost.getWorldQuaternion(ghostSurfaceQuatRef.current)
       resolveItemPlacementSurfaceNormal(surf, ghostSurfaceQuatRef.current, null, n)
     }
-    publishPlacementSurface(ghost.position, n)
+    // `publishPlacementSurface` is a WORLD-space contract (the grid reads it in
+    // world space), but the ghost lives in the building-local tool group.
+    publishPlacementSurface(ghost.getWorldPosition(surfaceWorldPointRef.current), n)
 
     if (shape.depth > 0) {
       useFacingPose.getState().set({
@@ -2716,7 +2760,8 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
           gridPosition.current.z,
         ])
         mesh.position.y = visualPosition[1]
-        cursorGroupRef.current.position.y = visualPosition[1]
+        cursorGroupRef.current.position.y =
+          visualPosition[1] + getPlacementLevelY(draftNode.current)
       }
     } else if (placementState.current.surface === 'block-face') {
       const rotation = draftNode.current.rotation

From 6cd7f3359fbcf6f4f3315820ca8887bf6512658e Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 15:34:26 -0400
Subject: [PATCH 07/27] fix(selection): keep member rotation when pressing R/T
 mid-drag

translateGroupPatches dropped the snapshots' yaw after a mid-gesture
rotation, so the layout orbited while every item kept its old facing and
the commit wrote the same. Carry rotation for vec3/scalar participants,
pivot every session on the shared mesh-box centre the idle shortcut
uses, and engage an armed session before rotating.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 .../editor-2d/floorplan-group-move.tsx        | 91 ++++++++++++-------
 .../src/components/editor/group-actions.ts    | 75 ++++++---------
 .../src/components/editor/group-move-3d.ts    | 61 ++++++++-----
 .../editor/group-transform-shared.test.ts     | 78 ++++++++++++++++
 .../editor/group-transform-shared.ts          | 81 +++++++++++++++--
 5 files changed, 276 insertions(+), 110 deletions(-)

diff --git a/packages/editor/src/components/editor-2d/floorplan-group-move.tsx b/packages/editor/src/components/editor-2d/floorplan-group-move.tsx
index 0a2280b66..74d954cca 100644
--- a/packages/editor/src/components/editor-2d/floorplan-group-move.tsx
+++ b/packages/editor/src/components/editor-2d/floorplan-group-move.tsx
@@ -39,10 +39,13 @@ import {
   collectParticipants,
   computeGroupBox,
   expandToComponent,
+  type GroupPlanBounds,
+  groupPlanBounds,
   levelFrame,
-  participantExtents,
+  planBoundsCenter,
   rotateGroupPatches,
   rotateGroupSnapshots,
+  rotatePlanBounds,
   translateGroupPatches,
   type Vec2,
 } from '../editor/group-transform-shared'
@@ -112,6 +115,7 @@ export function startFloorplanGroupMove(
     affectedIds: AnyNodeId[]
     candidates: ReturnType<typeof collectAlignmentAnchors>
     restAnchors: ReturnType<typeof bboxCornerAnchors>
+    restBounds: GroupPlanBounds
     restCenter: Vec2
     lastDelta: Vec2 | null
   }
@@ -140,20 +144,16 @@ export function startFloorplanGroupMove(
     // The group aligns as one rigid footprint: its bbox corners + center are
     // the moving anchors. `computeGroupBox` is world-space (the 3D scene stays
     // mounted under every view mode); plan coords are level-frame, so convert.
-    const restBox = computeGroupBox(fullIds)
     const { inverse: frameInv } = levelFrame(levelId)
-    const boxMin = restBox ? restBox.min.clone().applyMatrix4(frameInv) : null
-    const boxMax = restBox ? restBox.max.clone().applyMatrix4(frameInv) : null
-    const restAnchors =
-      boxMin && boxMax
-        ? bboxCornerAnchors(
-            'group-move',
-            Math.min(boxMin.x, boxMax.x),
-            Math.min(boxMin.z, boxMax.z),
-            Math.max(boxMin.x, boxMax.x),
-            Math.max(boxMin.z, boxMax.z),
-          )
-        : []
+    const restBounds = groupPlanBounds(computeGroupBox(fullIds), starts, frameInv)
+    if (!restBounds) return null
+    const restAnchors = bboxCornerAnchors(
+      'group-move',
+      restBounds.minX,
+      restBounds.minZ,
+      restBounds.maxX,
+      restBounds.maxZ,
+    )
 
     for (const id of affectedIds) {
       useLiveTransforms.getState().clear(id)
@@ -169,12 +169,21 @@ export function startFloorplanGroupMove(
       nodeId,
       handle: GROUP_MOVE_DRAG_LABEL,
     })
-    // Rotation pivot for mid-drag R/T — the participant DATA extents' center
-    // (stable across the drag; rotations re-seed around the same point).
-    const ext = participantExtents(starts)
-    const restCenter: Vec2 = ext ? [(ext.minX + ext.maxX) / 2, (ext.minZ + ext.maxZ) / 2] : [0, 0]
+    // Rotation pivot for mid-drag R/T — the START footprint's center, the same
+    // point the 3D body drag, the idle keyboard rotate and the rotate gizmos
+    // orbit. Stable across the drag; rotations re-seed around the same point.
+    const restCenter = planBoundsCenter(restBounds)
 
-    return { starts, links, affectedIds, candidates, restAnchors, restCenter, lastDelta: null }
+    return {
+      starts,
+      links,
+      affectedIds,
+      candidates,
+      restAnchors,
+      restBounds,
+      restCenter,
+      lastDelta: null,
+    }
   }
 
   const applyMove = (e: PointerEvent, s: Session) => {
@@ -241,18 +250,19 @@ export function startFloorplanGroupMove(
   // current delta — the carried group turns exactly like the idle keyboard
   // rotate, and the commit stays a single updateNodes.
   const rotateSession = (s: Session, direction: 1 | -1) => {
-    const rotated = rotateGroupSnapshots(
-      s.starts,
-      s.links,
-      { x: s.restCenter[0], z: s.restCenter[1] },
-      -direction * (Math.PI / 4),
-    )
+    const pivot = { x: s.restCenter[0], z: s.restCenter[1] }
+    const delta = -direction * (Math.PI / 4)
+    const rotated = rotateGroupSnapshots(s.starts, s.links, pivot, delta)
     s.starts = rotated.starts
     s.links = rotated.links
-    const ext = participantExtents(rotated.starts)
-    if (ext) {
-      s.restAnchors = bboxCornerAnchors('group-move', ext.minX, ext.minZ, ext.maxX, ext.maxZ)
-    }
+    s.restBounds = rotatePlanBounds(s.restBounds, pivot, delta)
+    s.restAnchors = bboxCornerAnchors(
+      'group-move',
+      s.restBounds.minX,
+      s.restBounds.minZ,
+      s.restBounds.maxX,
+      s.restBounds.maxZ,
+    )
     sfxEmitter.emit('sfx:item-rotate')
     applyDelta(s, s.lastDelta?.[0] ?? 0, s.lastDelta?.[1] ?? 0)
   }
@@ -358,7 +368,18 @@ export function startFloorplanGroupMove(
   const onKeyDown = (e: KeyboardEvent) => {
     const key = e.key.toLowerCase()
     if ((key === 'r' || key === 't') && !e.metaKey && !e.ctrlKey && !e.altKey && !e.shiftKey) {
-      if (!session) return
+      // Armed but still under the drag threshold: engage first (exactly what
+      // the next pointer-move would do) so the rotation lands inside this
+      // session. Falling through to the global idle arm instead would write
+      // the scene behind snapshots already captured here, and the first
+      // `applyDelta` would republish them — undoing the rotation.
+      if (!session) {
+        session = engage()
+        if (!session) {
+          removeListeners()
+          return
+        }
+      }
       e.preventDefault()
       e.stopPropagation()
       rotateSession(session, key === 'r' ? 1 : -1)
@@ -415,9 +436,13 @@ export function startFloorplanGroupRotate(event: {
   const { starts, links } = collectParticipants(fullIds, nodes, levelId)
   if (starts.length === 0) return false
   const affectedIds: AnyNodeId[] = [...starts.map((s) => s.id), ...links.map((l) => l.id)]
-  const ext = participantExtents(starts)
-  if (!ext) return false
-  const pivot = { x: (ext.minX + ext.maxX) / 2, z: (ext.minZ + ext.maxZ) / 2 }
+  const { inverse: frameInv } = levelFrame(levelId)
+  const bounds = groupPlanBounds(computeGroupBox(fullIds), starts, frameInv)
+  if (!bounds) return false
+  // Same pivot as the dashed box the handles hang off (and as the 3D rotate
+  // gizmo): its centre, not the anchor points' centre.
+  const [pivotX, pivotZ] = planBoundsCenter(bounds)
+  const pivot = { x: pivotX, z: pivotZ }
   const startPlan = clientToPlan(event.clientX, event.clientY)
   if (!startPlan) return false
   // Bearing around the pivot in the plan frame — the same atan2 x→z sense
diff --git a/packages/editor/src/components/editor/group-actions.ts b/packages/editor/src/components/editor/group-actions.ts
index d14e8775a..48ecc0174 100644
--- a/packages/editor/src/components/editor/group-actions.ts
+++ b/packages/editor/src/components/editor/group-actions.ts
@@ -40,9 +40,11 @@ import {
   collectParticipants,
   computeGroupBox,
   expandToComponent,
+  groupPlanBounds,
   levelFrame,
-  participantExtents,
+  planBoundsCenter,
   rotateGroupSnapshots,
+  rotatePlanBounds,
   translateGroupPatches,
   type Vec2,
 } from './group-transform-shared'
@@ -104,46 +106,14 @@ export function startGroupPickUp(
   if (starts.length === 0) return false
   const affectedIds: AnyNodeId[] = [...starts.map((s) => s.id), ...links.map((l) => l.id)]
 
-  // Rest bounds in the level frame. Prefer the mounted meshes' world box
-  // (footprint-accurate), but fall back to the participant DATA when the
-  // meshes aren't up yet — Duplicate starts the pick-up synchronously after
-  // `createNodes`, one frame before the clones' renderers mount.
   const { inverse: frameInv } = levelFrame(levelId)
   const restBox = computeGroupBox(fullIds)
-  let minX = Number.POSITIVE_INFINITY
-  let minZ = Number.POSITIVE_INFINITY
-  let maxX = Number.NEGATIVE_INFINITY
-  let maxZ = Number.NEGATIVE_INFINITY
-  if (restBox) {
-    const boxMin = restBox.min.clone().applyMatrix4(frameInv)
-    const boxMax = restBox.max.clone().applyMatrix4(frameInv)
-    minX = Math.min(boxMin.x, boxMax.x)
-    minZ = Math.min(boxMin.z, boxMax.z)
-    maxX = Math.max(boxMin.x, boxMax.x)
-    maxZ = Math.max(boxMin.z, boxMax.z)
-  } else {
-    const reach = (x: number, z: number) => {
-      minX = Math.min(minX, x)
-      minZ = Math.min(minZ, z)
-      maxX = Math.max(maxX, x)
-      maxZ = Math.max(maxZ, z)
-    }
-    for (const s of starts) {
-      if (s.kind === 'endpoint') {
-        reach(s.start[0], s.start[1])
-        reach(s.end[0], s.end[1])
-      } else if (s.kind === 'polygon') {
-        for (const [x, z] of s.polygon) {
-          reach(x, z)
-        }
-      } else {
-        reach(s.position[0], s.position[2])
-      }
-    }
-  }
-  if (!Number.isFinite(minX)) return false
+  const startBounds = groupPlanBounds(restBox, starts, frameInv)
+  if (!startBounds) return false
+  // Mutable: mid-carry R/T re-seeds the footprint around the same pivot.
+  let restBounds = startBounds
   // Rotation pivot for mid-carry R/T; stable across the whole pick-up.
-  const restCenter: [number, number] = [(minX + maxX) / 2, (minZ + maxZ) / 2]
+  const restCenter = planBoundsCenter(restBounds)
   // Ground plane for the 3D surface: the meshes' base when available, floor
   // level otherwise. Placements live in the level frame, so both surfaces
   // resolve into it before measuring.
@@ -157,7 +127,13 @@ export function startGroupPickUp(
     if (n && !movingIdSet.has(nid)) staticNodes[nid] = n
   }
   const candidates = collectAlignmentAnchors(staticNodes, '', levelId)
-  let restAnchors = bboxCornerAnchors('group-move', minX, minZ, maxX, maxZ)
+  let restAnchors = bboxCornerAnchors(
+    'group-move',
+    restBounds.minX,
+    restBounds.minZ,
+    restBounds.maxX,
+    restBounds.maxZ,
+  )
 
   // Cursor → level-frame plan point, whichever surface the pointer is over.
   const ndc = new Vector2()
@@ -274,18 +250,19 @@ export function startGroupPickUp(
   // the current delta — the carried group turns exactly like the idle
   // keyboard rotate, and the placement stays a single updateNodes.
   const rotateCarried = (direction: 1 | -1) => {
-    const rotated = rotateGroupSnapshots(
-      starts,
-      links,
-      { x: restCenter[0], z: restCenter[1] },
-      -direction * (Math.PI / 4),
-    )
+    const pivot = { x: restCenter[0], z: restCenter[1] }
+    const delta = -direction * (Math.PI / 4)
+    const rotated = rotateGroupSnapshots(starts, links, pivot, delta)
     starts = rotated.starts
     links = rotated.links
-    const ext = participantExtents(rotated.starts)
-    if (ext) {
-      restAnchors = bboxCornerAnchors('group-move', ext.minX, ext.minZ, ext.maxX, ext.maxZ)
-    }
+    restBounds = rotatePlanBounds(restBounds, pivot, delta)
+    restAnchors = bboxCornerAnchors(
+      'group-move',
+      restBounds.minX,
+      restBounds.minZ,
+      restBounds.maxX,
+      restBounds.maxZ,
+    )
     sfxEmitter.emit('sfx:item-rotate')
     applyDelta(lastDelta?.[0] ?? 0, lastDelta?.[1] ?? 0)
   }
diff --git a/packages/editor/src/components/editor/group-move-3d.ts b/packages/editor/src/components/editor/group-move-3d.ts
index 967238daf..aeecefbda 100644
--- a/packages/editor/src/components/editor/group-move-3d.ts
+++ b/packages/editor/src/components/editor/group-move-3d.ts
@@ -32,9 +32,12 @@ import {
   collectParticipants,
   computeGroupBox,
   expandToComponent,
+  type GroupPlanBounds,
+  groupPlanBounds,
   levelFrame,
-  participantExtents,
+  planBoundsCenter,
   rotateGroupSnapshots,
+  rotatePlanBounds,
   translateGroupPatches,
   type Vec2,
 } from './group-transform-shared'
@@ -88,6 +91,7 @@ export function armGroupMove3d(args: {
     affectedIds: AnyNodeId[]
     candidates: ReturnType<typeof collectAlignmentAnchors>
     restAnchors: ReturnType<typeof bboxCornerAnchors>
+    restBounds: GroupPlanBounds
     restCenter: Vec2
     plane: Plane
     startLocal: Vector3
@@ -130,14 +134,14 @@ export function armGroupMove3d(args: {
       if (n && !movingIdSet.has(nid)) staticNodes[nid] = n
     }
     const candidates = collectAlignmentAnchors(staticNodes, '', levelId)
-    const boxMin = restBox.min.clone().applyMatrix4(frameInv)
-    const boxMax = restBox.max.clone().applyMatrix4(frameInv)
+    const restBounds = groupPlanBounds(restBox, starts, frameInv)
+    if (!restBounds) return null
     const restAnchors = bboxCornerAnchors(
       'group-move',
-      Math.min(boxMin.x, boxMax.x),
-      Math.min(boxMin.z, boxMax.z),
-      Math.max(boxMin.x, boxMax.x),
-      Math.max(boxMin.z, boxMax.z),
+      restBounds.minX,
+      restBounds.minZ,
+      restBounds.maxX,
+      restBounds.maxZ,
     )
 
     for (const id of affectedIds) {
@@ -154,9 +158,11 @@ export function armGroupMove3d(args: {
       nodeId,
       handle: GROUP_MOVE_DRAG_LABEL,
     })
-    // Rotation pivot for mid-drag R/T — the participant DATA extents' center.
-    const ext = participantExtents(starts)
-    const restCenter: Vec2 = ext ? [(ext.minX + ext.maxX) / 2, (ext.minZ + ext.maxZ) / 2] : [0, 0]
+    // Rotation pivot for mid-drag R/T — the START footprint's center, the same
+    // point the idle keyboard rotate and the rotate gizmos orbit. Fixed for the
+    // whole session: the snapshots are start placements, and `applyDelta` adds
+    // the live drag delta on top of them.
+    const restCenter = planBoundsCenter(restBounds)
 
     return {
       starts,
@@ -164,6 +170,7 @@ export function armGroupMove3d(args: {
       affectedIds,
       candidates,
       restAnchors,
+      restBounds,
       restCenter,
       plane,
       startLocal,
@@ -245,18 +252,19 @@ export function armGroupMove3d(args: {
   // current delta — the carried group turns exactly like the idle keyboard
   // rotate, and the commit stays a single updateNodes.
   const rotateSession = (s: Session, direction: 1 | -1) => {
-    const rotated = rotateGroupSnapshots(
-      s.starts,
-      s.links,
-      { x: s.restCenter[0], z: s.restCenter[1] },
-      -direction * (Math.PI / 4),
-    )
+    const pivot = { x: s.restCenter[0], z: s.restCenter[1] }
+    const delta = -direction * (Math.PI / 4)
+    const rotated = rotateGroupSnapshots(s.starts, s.links, pivot, delta)
     s.starts = rotated.starts
     s.links = rotated.links
-    const ext = participantExtents(rotated.starts)
-    if (ext) {
-      s.restAnchors = bboxCornerAnchors('group-move', ext.minX, ext.minZ, ext.maxX, ext.maxZ)
-    }
+    s.restBounds = rotatePlanBounds(s.restBounds, pivot, delta)
+    s.restAnchors = bboxCornerAnchors(
+      'group-move',
+      s.restBounds.minX,
+      s.restBounds.minZ,
+      s.restBounds.maxX,
+      s.restBounds.maxZ,
+    )
     sfxEmitter.emit('sfx:item-rotate')
     applyDelta(s, s.lastDelta?.[0] ?? 0, s.lastDelta?.[1] ?? 0)
   }
@@ -369,7 +377,18 @@ export function armGroupMove3d(args: {
   const onKeyDown = (e: KeyboardEvent) => {
     const key = e.key.toLowerCase()
     if ((key === 'r' || key === 't') && !e.metaKey && !e.ctrlKey && !e.altKey && !e.shiftKey) {
-      if (!session) return
+      // Armed but still under the drag threshold: engage first (exactly what
+      // the next pointer-move would do) so the rotation lands inside this
+      // session. Falling through to the global idle arm instead would write
+      // the scene behind snapshots already captured here, and the first
+      // `applyDelta` would republish them — undoing the rotation.
+      if (!session) {
+        session = engage()
+        if (!session) {
+          removeListeners()
+          return
+        }
+      }
       e.preventDefault()
       e.stopPropagation()
       rotateSession(session, key === 'r' ? 1 : -1)
diff --git a/packages/editor/src/components/editor/group-transform-shared.test.ts b/packages/editor/src/components/editor/group-transform-shared.test.ts
index 5b741b45d..ff9bedfd2 100644
--- a/packages/editor/src/components/editor/group-transform-shared.test.ts
+++ b/packages/editor/src/components/editor/group-transform-shared.test.ts
@@ -4,7 +4,10 @@ import { z } from 'zod'
 import {
   classifyParticipant,
   collectParticipants,
+  planBoundsCenter,
   rotateGroupPatches,
+  rotateGroupSnapshots,
+  rotatePlanBounds,
   translateGroupPatches,
 } from './group-transform-shared'
 
@@ -40,6 +43,34 @@ function registerElevatorTestKind() {
   } as AnyNodeDefinition)
 }
 
+// A level holding one of each rigid placement shape: an item ([x,y,z] rotation)
+// and a column (numeric rotation).
+function placedNodes() {
+  return {
+    building_test: { id: 'building_test', type: 'building', children: ['level_test'] },
+    level_test: {
+      id: 'level_test',
+      type: 'level',
+      parentId: 'building_test',
+      children: ['item_chair', 'column_post'],
+    },
+    item_chair: {
+      id: 'item_chair',
+      type: 'item',
+      parentId: 'level_test',
+      position: [1, 0, 3],
+      rotation: [0, 0.5, 0],
+    },
+    column_post: {
+      id: 'column_post',
+      type: 'column',
+      parentId: 'level_test',
+      position: [4, 0, -1],
+      rotation: 1.25,
+    },
+  } as unknown as Record<string, AnyNode>
+}
+
 describe('group transform participants', () => {
   beforeAll(() => {
     registerBuildingScopedTestKind()
@@ -362,6 +393,53 @@ describe('group transform participants', () => {
     expect(lampPatch.position).toEqual([3, 2.4, 2])
   })
 
+  test('translate patches carry the snapshot rotation for vec3 and scalar kinds', () => {
+    const { starts } = collectParticipants(
+      ['item_chair', 'column_post'],
+      placedNodes(),
+      'level_test',
+    )
+    const patches = Object.fromEntries(translateGroupPatches(starts, [], 1, 2))
+
+    expect(patches.item_chair).toEqual({ position: [2, 0, 5], rotation: [0, 0.5, 0] })
+    expect(patches.column_post).toEqual({ position: [5, 0, 1], rotation: 1.25 })
+  })
+
+  test('a mid-drag rotation survives the next translate re-publish', () => {
+    const { starts } = collectParticipants(
+      ['item_chair', 'column_post'],
+      placedNodes(),
+      'level_test',
+    )
+    // What a mid-drag R does: turn the snapshots, then re-apply the live delta.
+    const rotated = rotateGroupSnapshots(starts, [], { x: 0, z: 0 }, Math.PI / 2)
+    const patches = Object.fromEntries(
+      translateGroupPatches(rotated.starts, rotated.links, 1, 2),
+    ) as Record<string, { position: number[]; rotation: number[] | number }>
+
+    // Orbited 90° in the atan2 x→z sense ((x, z) → (-z, x)), then slid.
+    expect(patches.item_chair!.position[0]).toBeCloseTo(-2)
+    expect(patches.item_chair!.position[2]).toBeCloseTo(3)
+    expect(patches.column_post!.position[0]).toBeCloseTo(2)
+    expect(patches.column_post!.position[2]).toBeCloseTo(6)
+    // …and the facings turned with it instead of reverting to the pre-drag yaw.
+    expect((patches.item_chair!.rotation as number[])[1]).toBeCloseTo(0.5 - Math.PI / 2)
+    expect(patches.column_post!.rotation as number).toBeCloseTo(1.25 - Math.PI / 2)
+  })
+
+  test('rotating the plan bounds keeps the footprint centred on the pivot', () => {
+    const bounds = { minX: 0, minZ: 0, maxX: 4, maxZ: 2 }
+    const [pivotX, pivotZ] = planBoundsCenter(bounds)
+    const rotated = rotatePlanBounds(bounds, { x: pivotX, z: pivotZ }, Math.PI / 2)
+
+    expect(rotated.minX).toBeCloseTo(1)
+    expect(rotated.maxX).toBeCloseTo(3)
+    expect(rotated.minZ).toBeCloseTo(-1)
+    expect(rotated.maxZ).toBeCloseTo(3)
+    expect(planBoundsCenter(rotated)[0]).toBeCloseTo(pivotX)
+    expect(planBoundsCenter(rotated)[1]).toBeCloseTo(pivotZ)
+  })
+
   test('supports legacy level-parented elevators already loaded in the editor', () => {
     const nodes = {
       building_test: {
diff --git a/packages/editor/src/components/editor/group-transform-shared.ts b/packages/editor/src/components/editor/group-transform-shared.ts
index 8e077474c..408eb2cc6 100644
--- a/packages/editor/src/components/editor/group-transform-shared.ts
+++ b/packages/editor/src/components/editor/group-transform-shared.ts
@@ -387,12 +387,11 @@ export function rotateGroupSnapshots(
   return { starts: rotatedStarts, links: rotatedLinks }
 }
 
+export type GroupPlanBounds = { minX: number; minZ: number; maxX: number; maxZ: number }
+
 // Level-frame XZ extents of the participant DATA — the mesh-free sibling of
-// `computeGroupBox`, used when meshes aren't mounted yet and to re-seed
-// alignment anchors after a mid-drag rotation.
-export function participantExtents(
-  starts: ParticipantStart[],
-): { minX: number; minZ: number; maxX: number; maxZ: number } | null {
+// `computeGroupBox`, used when meshes aren't mounted yet.
+function participantExtents(starts: ParticipantStart[]): GroupPlanBounds | null {
   let minX = Number.POSITIVE_INFINITY
   let minZ = Number.POSITIVE_INFINITY
   let maxX = Number.NEGATIVE_INFINITY
@@ -419,8 +418,73 @@ export function participantExtents(
   return { minX, minZ, maxX, maxZ }
 }
 
+// The one footprint every group transform measures itself against: the
+// selection's mounted meshes (world box, converted into the level frame) with
+// the participant DATA extents as the fallback when the meshes aren't up yet
+// (Duplicate picks up its clones a frame before their renderers mount). Anchor
+// points alone sit metres inside a wide selection's real footprint, so a
+// gesture that pivots on the data extents orbits a different point than the
+// idle keyboard rotate and the rotate gizmos, which both use the mesh box.
+export function groupPlanBounds(
+  box: Box3 | null,
+  starts: ParticipantStart[],
+  frameInv: Matrix4,
+): GroupPlanBounds | null {
+  if (!box) return participantExtents(starts)
+  const min = box.min.clone().applyMatrix4(frameInv)
+  const max = box.max.clone().applyMatrix4(frameInv)
+  return {
+    minX: Math.min(min.x, max.x),
+    minZ: Math.min(min.z, max.z),
+    maxX: Math.max(min.x, max.x),
+    maxZ: Math.max(min.z, max.z),
+  }
+}
+
+export const planBoundsCenter = (b: GroupPlanBounds): Vec2 => [
+  (b.minX + b.maxX) / 2,
+  (b.minZ + b.maxZ) / 2,
+]
+
+// Re-seed the footprint after a mid-gesture rotation by orbiting the box
+// corners and re-fitting an axis-aligned box. Re-measuring the rotated DATA
+// extents instead would slide the centre off the pivot the snapshots turned
+// around, dragging the alignment anchors away from the group under the cursor.
+export function rotatePlanBounds(
+  b: GroupPlanBounds,
+  center: { x: number; z: number },
+  delta: number,
+): GroupPlanBounds {
+  const cos = Math.cos(delta)
+  const sin = Math.sin(delta)
+  let minX = Number.POSITIVE_INFINITY
+  let minZ = Number.POSITIVE_INFINITY
+  let maxX = Number.NEGATIVE_INFINITY
+  let maxZ = Number.NEGATIVE_INFINITY
+  const corners: Vec2[] = [
+    [b.minX, b.minZ],
+    [b.maxX, b.minZ],
+    [b.maxX, b.maxZ],
+    [b.minX, b.maxZ],
+  ]
+  for (const [x, z] of corners) {
+    const dx = x - center.x
+    const dz = z - center.z
+    const rx = center.x + dx * cos - dz * sin
+    const rz = center.z + dx * sin + dz * cos
+    minX = Math.min(minX, rx)
+    minZ = Math.min(minZ, rz)
+    maxX = Math.max(maxX, rx)
+    maxZ = Math.max(maxZ, rz)
+  }
+  return { minX, minZ, maxX, maxZ }
+}
+
 // Rigid group slide: shift every participant (and each linked neighbour's
-// shared endpoint) by the same level-frame XZ delta. Y and rotations untouched.
+// shared endpoint) by the same level-frame XZ delta. Y is untouched; the
+// snapshot's rotation rides along because a mid-gesture R/T turns the
+// SNAPSHOTS — dropping it here would republish (and commit) the pre-rotation
+// facing, orbiting the layout while every member keeps its old bearing.
 export function translateGroupPatches(
   starts: ParticipantStart[],
   links: LinkedNeighbor[],
@@ -437,7 +501,10 @@ export function translateGroupPatches(
       if (s.holes) patch.holes = s.holes.map((hole) => hole.map(shift))
       patches.push([s.id, patch])
     } else {
-      patches.push([s.id, { position: [s.position[0] + dx, s.position[1], s.position[2] + dz] }])
+      const position: Vec3 = [s.position[0] + dx, s.position[1], s.position[2] + dz]
+      const rotation =
+        s.kind === 'vec3' ? ([s.rotation[0], s.rotation[1], s.rotation[2]] as Vec3) : s.rotation
+      patches.push([s.id, { position, rotation }])
     }
   }
   for (const l of links) {

From 6aadbb3c761446fe2f3dd168cf460091404ba932 Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 15:52:37 -0400
Subject: [PATCH 08/27] chore(deps): three 0.186.0

No removed export is used and every peer range admits r186. Two
adjustments: Renderer.dispose() is async now, so the capability probe
swallows its rejection; and r186's CommonJS entry re-exports the ES
module, which Bun cannot require() while the same process imports three
as ESM. A bun test preload steers fiber/drei/maath/meshline (no exports
map, CJS main) to their module builds, the way bundlers already resolve
them. Types stay on 0.184.1 (0.185 types OOM tsgo).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 apps/editor/bunfig.toml                       |  4 +++
 apps/editor/package.json                      |  2 +-
 apps/ifc-converter/package.json               |  2 +-
 bun.lock                                      | 20 +++++++-------
 bunfig.toml                                   |  4 +++
 package.json                                  |  2 +-
 packages/capture-viewer/bunfig.toml           |  4 +++
 packages/capture-viewer/package.json          |  4 +--
 packages/core/bunfig.toml                     |  4 +++
 packages/core/package.json                    |  2 +-
 packages/editor/bunfig.toml                   |  4 +++
 packages/editor/package.json                  |  2 +-
 packages/nodes/bunfig.toml                    |  4 +++
 packages/nodes/package.json                   |  2 +-
 .../shared/node-batch/source-systems.test.ts  | 27 ++++++++++++++++++-
 packages/viewer/bunfig.toml                   |  4 +++
 packages/viewer/package.json                  |  2 +-
 .../viewer/src/lib/renderer-capability.ts     |  5 ++--
 scripts/bun-esm-resolve.ts                    | 23 ++++++++++++++++
 19 files changed, 99 insertions(+), 22 deletions(-)
 create mode 100644 apps/editor/bunfig.toml
 create mode 100644 bunfig.toml
 create mode 100644 packages/capture-viewer/bunfig.toml
 create mode 100644 packages/core/bunfig.toml
 create mode 100644 packages/editor/bunfig.toml
 create mode 100644 packages/nodes/bunfig.toml
 create mode 100644 packages/viewer/bunfig.toml
 create mode 100644 scripts/bun-esm-resolve.ts

diff --git a/apps/editor/bunfig.toml b/apps/editor/bunfig.toml
new file mode 100644
index 000000000..5c3fa8ef0
--- /dev/null
+++ b/apps/editor/bunfig.toml
@@ -0,0 +1,4 @@
+preload = ["../../scripts/bun-esm-resolve.ts"]
+
+[test]
+preload = ["../../scripts/bun-esm-resolve.ts"]
diff --git a/apps/editor/package.json b/apps/editor/package.json
index 31b4cde8a..09852b125 100644
--- a/apps/editor/package.json
+++ b/apps/editor/package.json
@@ -36,7 +36,7 @@
     "react-dom": "^19.2.4",
     "tailwind-merge": "^3.5.0",
     "tailwindcss": "^4.2.1",
-    "three": "^0.185.0",
+    "three": "^0.186.0",
     "zod": ">=4.5.4 <4.6"
   },
   "devDependencies": {
diff --git a/apps/ifc-converter/package.json b/apps/ifc-converter/package.json
index 67ec77a56..c5798f6e3 100644
--- a/apps/ifc-converter/package.json
+++ b/apps/ifc-converter/package.json
@@ -29,7 +29,7 @@
     "react-dom": "^19.2.4",
     "tailwind-merge": "^3.5.0",
     "tailwindcss": "^4.2.1",
-    "three": "^0.185.0",
+    "three": "^0.186.0",
     "web-ifc": "^0.0.77"
   },
   "devDependencies": {
diff --git a/bun.lock b/bun.lock
index d785effb1..e28a311eb 100644
--- a/bun.lock
+++ b/bun.lock
@@ -52,7 +52,7 @@
         "react-dom": "^19.2.4",
         "tailwind-merge": "^3.5.0",
         "tailwindcss": "^4.2.1",
-        "three": "^0.185.0",
+        "three": "^0.186.0",
         "zod": ">=4.5.4 <4.6",
       },
       "devDependencies": {
@@ -87,7 +87,7 @@
         "react-dom": "^19.2.4",
         "tailwind-merge": "^3.5.0",
         "tailwindcss": "^4.2.1",
-        "three": "^0.185.0",
+        "three": "^0.186.0",
         "web-ifc": "^0.0.77",
       },
       "devDependencies": {
@@ -125,7 +125,7 @@
         "@types/react": "^19.2.2",
         "@types/three": "^0.184.0",
         "react": "^19.2.4",
-        "three": "^0.185.0",
+        "three": "^0.186.0",
         "typescript": "6.0.3",
       },
       "peerDependencies": {
@@ -135,7 +135,7 @@
         "@react-three/drei": "^10",
         "@react-three/fiber": "^9",
         "react": "^18 || ^19",
-        "three": "^0.185",
+        "three": "^0.186",
       },
     },
     "packages/cli": {
@@ -178,7 +178,7 @@
         "@react-three/drei": "^10",
         "@react-three/fiber": "^9",
         "react": "^18 || ^19",
-        "three": "^0.185",
+        "three": "^0.186",
       },
     },
     "packages/editor": {
@@ -244,7 +244,7 @@
         "next": ">=15",
         "react": "^18 || ^19",
         "react-dom": "^18 || ^19",
-        "three": "^0.185",
+        "three": "^0.186",
       },
     },
     "packages/eslint-config": {
@@ -321,7 +321,7 @@
         "@react-three/fiber": "^9",
         "lucide-react": "^1",
         "react": "^18 || ^19",
-        "three": "^0.185",
+        "three": "^0.186",
         "zustand": "^5",
       },
     },
@@ -369,7 +369,7 @@
         "@react-three/fiber": "^9",
         "react": "^18 || ^19",
         "react-dom": "^18 || ^19",
-        "three": "^0.185",
+        "three": "^0.186",
       },
     },
     "tooling/typescript": {
@@ -383,7 +383,7 @@
     "@types/three": "0.184.1",
     "next": "16.3.0",
     "react-grab": "0.1.50",
-    "three": "0.185.1",
+    "three": "0.186.0",
   },
   "packages": {
     "@alloc/quick-lru": ["@alloc/quick-lru@5.2.0", "", {}, "sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw=="],
@@ -1942,7 +1942,7 @@
 
     "tapable": ["tapable@2.3.3", "", {}, "sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A=="],
 
-    "three": ["three@0.185.1", "", {}, "sha512-5aojFCXKwnjBRZvUnt3WFfEcvUJgkN5LlijRFN95hMy8WVkG4I0QNcJE+OuWvuJ0bOdStrbfXn0pkd6/QyiAlg=="],
+    "three": ["three@0.186.0", "", {}, "sha512-cr/fIM2ddMSVbYVgkfD4jLJv7Fh/8ZTjvo+7gQeSVGUZHxpx9FDwoL5iC7hUz/LiRA8wMbqfnb90xKfm1/HHkQ=="],
 
     "three-bvh-csg": ["three-bvh-csg@0.0.18", "", { "peerDependencies": { "three": ">=0.179.0", "three-mesh-bvh": ">=0.9.7" } }, "sha512-M3GCZMmGFgASGuDf+YMamM83nVlD/vdwzVHcYbFxgW+g1S7/nKPiuY00YVHOMbjmJPh8mLevGZL65ItHUuGt2w=="],
 
diff --git a/bunfig.toml b/bunfig.toml
new file mode 100644
index 000000000..5a5c9671f
--- /dev/null
+++ b/bunfig.toml
@@ -0,0 +1,4 @@
+preload = ["./scripts/bun-esm-resolve.ts"]
+
+[test]
+preload = ["./scripts/bun-esm-resolve.ts"]
diff --git a/package.json b/package.json
index 732ddfcbf..614716ae0 100644
--- a/package.json
+++ b/package.json
@@ -46,7 +46,7 @@
     "@types/three": "0.184.1",
     "next": "16.3.0",
     "react-grab": "0.1.50",
-    "three": "0.185.1"
+    "three": "0.186.0"
   },
   "optionalDependencies": {
     "@tailwindcss/oxide-darwin-arm64": "4.3.0",
diff --git a/packages/capture-viewer/bunfig.toml b/packages/capture-viewer/bunfig.toml
new file mode 100644
index 000000000..5c3fa8ef0
--- /dev/null
+++ b/packages/capture-viewer/bunfig.toml
@@ -0,0 +1,4 @@
+preload = ["../../scripts/bun-esm-resolve.ts"]
+
+[test]
+preload = ["../../scripts/bun-esm-resolve.ts"]
diff --git a/packages/capture-viewer/package.json b/packages/capture-viewer/package.json
index 9b7db8a29..d59369f21 100644
--- a/packages/capture-viewer/package.json
+++ b/packages/capture-viewer/package.json
@@ -37,7 +37,7 @@
     "@react-three/drei": "^10",
     "@react-three/fiber": "^9",
     "react": "^18 || ^19",
-    "three": "^0.185"
+    "three": "^0.186"
   },
   "devDependencies": {
     "@pascal-app/capture-protocol": "^1.0.0-beta.4",
@@ -50,7 +50,7 @@
     "@types/react": "^19.2.2",
     "@types/three": "^0.184.0",
     "react": "^19.2.4",
-    "three": "^0.185.0",
+    "three": "^0.186.0",
     "typescript": "6.0.3"
   },
   "keywords": [
diff --git a/packages/core/bunfig.toml b/packages/core/bunfig.toml
new file mode 100644
index 000000000..5c3fa8ef0
--- /dev/null
+++ b/packages/core/bunfig.toml
@@ -0,0 +1,4 @@
+preload = ["../../scripts/bun-esm-resolve.ts"]
+
+[test]
+preload = ["../../scripts/bun-esm-resolve.ts"]
diff --git a/packages/core/package.json b/packages/core/package.json
index 1d6ff58f0..0a1f26ced 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -73,7 +73,7 @@
     "@react-three/drei": "^10",
     "@react-three/fiber": "^9",
     "react": "^18 || ^19",
-    "three": "^0.185"
+    "three": "^0.186"
   },
   "dependencies": {
     "@pascal-app/capture-protocol": "^1.0.0-beta.4",
diff --git a/packages/editor/bunfig.toml b/packages/editor/bunfig.toml
new file mode 100644
index 000000000..5c3fa8ef0
--- /dev/null
+++ b/packages/editor/bunfig.toml
@@ -0,0 +1,4 @@
+preload = ["../../scripts/bun-esm-resolve.ts"]
+
+[test]
+preload = ["../../scripts/bun-esm-resolve.ts"]
diff --git a/packages/editor/package.json b/packages/editor/package.json
index b12dc98a4..d019a2476 100644
--- a/packages/editor/package.json
+++ b/packages/editor/package.json
@@ -20,7 +20,7 @@
     "next": ">=15",
     "react": "^18 || ^19",
     "react-dom": "^18 || ^19",
-    "three": "^0.185"
+    "three": "^0.186"
   },
   "dependencies": {
     "@dnd-kit/core": "^6.3.1",
diff --git a/packages/nodes/bunfig.toml b/packages/nodes/bunfig.toml
new file mode 100644
index 000000000..5c3fa8ef0
--- /dev/null
+++ b/packages/nodes/bunfig.toml
@@ -0,0 +1,4 @@
+preload = ["../../scripts/bun-esm-resolve.ts"]
+
+[test]
+preload = ["../../scripts/bun-esm-resolve.ts"]
diff --git a/packages/nodes/package.json b/packages/nodes/package.json
index 699131dd7..d8a633e57 100644
--- a/packages/nodes/package.json
+++ b/packages/nodes/package.json
@@ -30,7 +30,7 @@
     "@react-three/fiber": "^9",
     "lucide-react": "^1",
     "react": "^18 || ^19",
-    "three": "^0.185",
+    "three": "^0.186",
     "zustand": "^5"
   },
   "devDependencies": {
diff --git a/packages/nodes/src/shared/node-batch/source-systems.test.ts b/packages/nodes/src/shared/node-batch/source-systems.test.ts
index c6d7d69ac..abad14e43 100644
--- a/packages/nodes/src/shared/node-batch/source-systems.test.ts
+++ b/packages/nodes/src/shared/node-batch/source-systems.test.ts
@@ -2,6 +2,28 @@ import { expect, test } from 'bun:test'
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
 import { join, resolve } from 'node:path'
 
+// The probe runs as `bun <file>`, where Bun skips plugin resolution for static
+// imports, so fiber's CJS main still `require("three")`s and three r186's shim
+// warns once. That is the one stderr line the probe tolerates.
+function stripThreeCjsDeprecation(stderr: string) {
+  const start = stderr.indexOf('DeprecationWarning: `require("three")`')
+  if (start === -1) return stderr
+  const lines = stderr.slice(start).split('\n')
+  let end = 1
+  while (end < lines.length) {
+    const line = lines[end].trim()
+    if (
+      line !== '' &&
+      !line.startsWith('at ') &&
+      !line.startsWith('Replace ') &&
+      !line.startsWith('code:')
+    )
+      break
+    end++
+  }
+  return (stderr.slice(0, start) + lines.slice(end).join('\n')).trim()
+}
+
 function sourcePath(path: string) {
   return JSON.stringify(resolve(import.meta.dir, '../../../../..', path))
 }
@@ -51,7 +73,10 @@ function runSourceTest(body: string) {
       stdout: 'pipe',
       stderr: 'pipe',
     })
-    expect({ code: result.exitCode, stderr: result.stderr.toString() }).toEqual({
+    expect({
+      code: result.exitCode,
+      stderr: stripThreeCjsDeprecation(result.stderr.toString()),
+    }).toEqual({
       code: 0,
       stderr: '',
     })
diff --git a/packages/viewer/bunfig.toml b/packages/viewer/bunfig.toml
new file mode 100644
index 000000000..5c3fa8ef0
--- /dev/null
+++ b/packages/viewer/bunfig.toml
@@ -0,0 +1,4 @@
+preload = ["../../scripts/bun-esm-resolve.ts"]
+
+[test]
+preload = ["../../scripts/bun-esm-resolve.ts"]
diff --git a/packages/viewer/package.json b/packages/viewer/package.json
index 4097c35b9..0c135fd6c 100644
--- a/packages/viewer/package.json
+++ b/packages/viewer/package.json
@@ -28,7 +28,7 @@
     "@react-three/fiber": "^9",
     "react": "^18 || ^19",
     "react-dom": "^18 || ^19",
-    "three": "^0.185"
+    "three": "^0.186"
   },
   "dependencies": {
     "three-bvh-csg": "^0.0.18",
diff --git a/packages/viewer/src/lib/renderer-capability.ts b/packages/viewer/src/lib/renderer-capability.ts
index a528fda85..53199d0a0 100644
--- a/packages/viewer/src/lib/renderer-capability.ts
+++ b/packages/viewer/src/lib/renderer-capability.ts
@@ -152,7 +152,8 @@ export async function initializeGpuRenderer<Renderer extends InitializableRender
     return { backend: capability.backend, renderer, status: 'ready' }
   } catch (error) {
     try {
-      renderer?.dispose?.()
+      // r186 made dispose() async; swallow the rejection like the sync throw.
+      Promise.resolve(renderer?.dispose?.()).catch(() => {})
     } catch {}
     if (capability.backend !== 'webgpu') return { error, status: 'unsupported' }
 
@@ -165,7 +166,7 @@ export async function initializeGpuRenderer<Renderer extends InitializableRender
       return { backend: 'webgl', renderer, status: 'ready' }
     } catch (fallbackError) {
       try {
-        renderer?.dispose?.()
+        Promise.resolve(renderer?.dispose?.()).catch(() => {})
       } catch {}
       return { error: fallbackError, status: 'unsupported' }
     }
diff --git a/scripts/bun-esm-resolve.ts b/scripts/bun-esm-resolve.ts
new file mode 100644
index 000000000..cc681e3f6
--- /dev/null
+++ b/scripts/bun-esm-resolve.ts
@@ -0,0 +1,23 @@
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { plugin } from 'bun'
+
+// three r186 turned its CommonJS entry into a re-export of the ES module. Bun
+// cannot require() an ES module that the same process is also importing, so
+// the R3F packages that ship no `exports` map (Bun then takes their CJS `main`)
+// blow up the moment ESM code imports three alongside them. Steer them to the
+// `module` build, which is what every bundler already does. Bun applies this
+// to `bun test`; plain `bun <file>` skips plugin resolution for static imports.
+const CJS_MAIN_THREE_CONSUMERS = /^(@react-three\/fiber|@react-three\/drei|maath|meshline)$/
+
+plugin({
+  name: 'prefer-esm-three-consumers',
+  setup(build) {
+    build.onResolve({ filter: CJS_MAIN_THREE_CONSUMERS }, (args) => {
+      const from = args.importer ? dirname(args.importer) : process.cwd()
+      const manifestPath = Bun.resolveSync(`${args.path}/package.json`, from)
+      const manifest = JSON.parse(readFileSync(manifestPath, 'utf8')) as { module?: string }
+      return manifest.module ? { path: join(dirname(manifestPath), manifest.module) } : undefined
+    })
+  },
+})

From 85cdc902df78ac4ec6775ece2fd4793b14ea1cb6 Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 16:47:37 -0400
Subject: [PATCH 09/27] test: pre-evaluate three in the bun test preload

Bun's plugin onResolve does not run for static imports, so steering the
R3F packages to their module builds never applied in CI (isolated linker)
and the CJS require("three") kept racing the ESM import. Evaluating the
package's own three copy first makes the later require() a cache hit.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 apps/editor/bunfig.toml                       |  4 +--
 bunfig.toml                                   |  4 +--
 packages/capture-viewer/bunfig.toml           |  4 +--
 packages/core/bunfig.toml                     |  4 +--
 packages/editor/bunfig.toml                   |  4 +--
 packages/nodes/bunfig.toml                    |  4 +--
 .../shared/node-batch/source-systems.test.ts  | 27 +------------------
 packages/viewer/bunfig.toml                   |  4 +--
 scripts/bun-esm-resolve.ts                    | 23 ----------------
 scripts/bun-preload-three.ts                  | 10 +++++++
 10 files changed, 25 insertions(+), 63 deletions(-)
 delete mode 100644 scripts/bun-esm-resolve.ts
 create mode 100644 scripts/bun-preload-three.ts

diff --git a/apps/editor/bunfig.toml b/apps/editor/bunfig.toml
index 5c3fa8ef0..eec7d338d 100644
--- a/apps/editor/bunfig.toml
+++ b/apps/editor/bunfig.toml
@@ -1,4 +1,4 @@
-preload = ["../../scripts/bun-esm-resolve.ts"]
+preload = ["../../scripts/bun-preload-three.ts"]
 
 [test]
-preload = ["../../scripts/bun-esm-resolve.ts"]
+preload = ["../../scripts/bun-preload-three.ts"]
diff --git a/bunfig.toml b/bunfig.toml
index 5a5c9671f..958800ceb 100644
--- a/bunfig.toml
+++ b/bunfig.toml
@@ -1,4 +1,4 @@
-preload = ["./scripts/bun-esm-resolve.ts"]
+preload = ["./scripts/bun-preload-three.ts"]
 
 [test]
-preload = ["./scripts/bun-esm-resolve.ts"]
+preload = ["./scripts/bun-preload-three.ts"]
diff --git a/packages/capture-viewer/bunfig.toml b/packages/capture-viewer/bunfig.toml
index 5c3fa8ef0..eec7d338d 100644
--- a/packages/capture-viewer/bunfig.toml
+++ b/packages/capture-viewer/bunfig.toml
@@ -1,4 +1,4 @@
-preload = ["../../scripts/bun-esm-resolve.ts"]
+preload = ["../../scripts/bun-preload-three.ts"]
 
 [test]
-preload = ["../../scripts/bun-esm-resolve.ts"]
+preload = ["../../scripts/bun-preload-three.ts"]
diff --git a/packages/core/bunfig.toml b/packages/core/bunfig.toml
index 5c3fa8ef0..eec7d338d 100644
--- a/packages/core/bunfig.toml
+++ b/packages/core/bunfig.toml
@@ -1,4 +1,4 @@
-preload = ["../../scripts/bun-esm-resolve.ts"]
+preload = ["../../scripts/bun-preload-three.ts"]
 
 [test]
-preload = ["../../scripts/bun-esm-resolve.ts"]
+preload = ["../../scripts/bun-preload-three.ts"]
diff --git a/packages/editor/bunfig.toml b/packages/editor/bunfig.toml
index 5c3fa8ef0..eec7d338d 100644
--- a/packages/editor/bunfig.toml
+++ b/packages/editor/bunfig.toml
@@ -1,4 +1,4 @@
-preload = ["../../scripts/bun-esm-resolve.ts"]
+preload = ["../../scripts/bun-preload-three.ts"]
 
 [test]
-preload = ["../../scripts/bun-esm-resolve.ts"]
+preload = ["../../scripts/bun-preload-three.ts"]
diff --git a/packages/nodes/bunfig.toml b/packages/nodes/bunfig.toml
index 5c3fa8ef0..eec7d338d 100644
--- a/packages/nodes/bunfig.toml
+++ b/packages/nodes/bunfig.toml
@@ -1,4 +1,4 @@
-preload = ["../../scripts/bun-esm-resolve.ts"]
+preload = ["../../scripts/bun-preload-three.ts"]
 
 [test]
-preload = ["../../scripts/bun-esm-resolve.ts"]
+preload = ["../../scripts/bun-preload-three.ts"]
diff --git a/packages/nodes/src/shared/node-batch/source-systems.test.ts b/packages/nodes/src/shared/node-batch/source-systems.test.ts
index abad14e43..c6d7d69ac 100644
--- a/packages/nodes/src/shared/node-batch/source-systems.test.ts
+++ b/packages/nodes/src/shared/node-batch/source-systems.test.ts
@@ -2,28 +2,6 @@ import { expect, test } from 'bun:test'
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
 import { join, resolve } from 'node:path'
 
-// The probe runs as `bun <file>`, where Bun skips plugin resolution for static
-// imports, so fiber's CJS main still `require("three")`s and three r186's shim
-// warns once. That is the one stderr line the probe tolerates.
-function stripThreeCjsDeprecation(stderr: string) {
-  const start = stderr.indexOf('DeprecationWarning: `require("three")`')
-  if (start === -1) return stderr
-  const lines = stderr.slice(start).split('\n')
-  let end = 1
-  while (end < lines.length) {
-    const line = lines[end].trim()
-    if (
-      line !== '' &&
-      !line.startsWith('at ') &&
-      !line.startsWith('Replace ') &&
-      !line.startsWith('code:')
-    )
-      break
-    end++
-  }
-  return (stderr.slice(0, start) + lines.slice(end).join('\n')).trim()
-}
-
 function sourcePath(path: string) {
   return JSON.stringify(resolve(import.meta.dir, '../../../../..', path))
 }
@@ -73,10 +51,7 @@ function runSourceTest(body: string) {
       stdout: 'pipe',
       stderr: 'pipe',
     })
-    expect({
-      code: result.exitCode,
-      stderr: stripThreeCjsDeprecation(result.stderr.toString()),
-    }).toEqual({
+    expect({ code: result.exitCode, stderr: result.stderr.toString() }).toEqual({
       code: 0,
       stderr: '',
     })
diff --git a/packages/viewer/bunfig.toml b/packages/viewer/bunfig.toml
index 5c3fa8ef0..eec7d338d 100644
--- a/packages/viewer/bunfig.toml
+++ b/packages/viewer/bunfig.toml
@@ -1,4 +1,4 @@
-preload = ["../../scripts/bun-esm-resolve.ts"]
+preload = ["../../scripts/bun-preload-three.ts"]
 
 [test]
-preload = ["../../scripts/bun-esm-resolve.ts"]
+preload = ["../../scripts/bun-preload-three.ts"]
diff --git a/scripts/bun-esm-resolve.ts b/scripts/bun-esm-resolve.ts
deleted file mode 100644
index cc681e3f6..000000000
--- a/scripts/bun-esm-resolve.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import { readFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { plugin } from 'bun'
-
-// three r186 turned its CommonJS entry into a re-export of the ES module. Bun
-// cannot require() an ES module that the same process is also importing, so
-// the R3F packages that ship no `exports` map (Bun then takes their CJS `main`)
-// blow up the moment ESM code imports three alongside them. Steer them to the
-// `module` build, which is what every bundler already does. Bun applies this
-// to `bun test`; plain `bun <file>` skips plugin resolution for static imports.
-const CJS_MAIN_THREE_CONSUMERS = /^(@react-three\/fiber|@react-three\/drei|maath|meshline)$/
-
-plugin({
-  name: 'prefer-esm-three-consumers',
-  setup(build) {
-    build.onResolve({ filter: CJS_MAIN_THREE_CONSUMERS }, (args) => {
-      const from = args.importer ? dirname(args.importer) : process.cwd()
-      const manifestPath = Bun.resolveSync(`${args.path}/package.json`, from)
-      const manifest = JSON.parse(readFileSync(manifestPath, 'utf8')) as { module?: string }
-      return manifest.module ? { path: join(dirname(manifestPath), manifest.module) } : undefined
-    })
-  },
-})
diff --git a/scripts/bun-preload-three.ts b/scripts/bun-preload-three.ts
new file mode 100644
index 000000000..d222da213
--- /dev/null
+++ b/scripts/bun-preload-three.ts
@@ -0,0 +1,10 @@
+// three r186's CommonJS entry is `require('./three.module.js')`. Bun cannot
+// require() an ES module that is still loading, and the R3F ecosystem (fiber,
+// drei, maath, meshline, troika) ships CJS mains that require("three") while
+// our sources import it as ESM — so a test file that imports both races and
+// dies with "require() async module is unsupported". Evaluating three first
+// turns the later require() into a cache hit. Resolve from the package under
+// test, not from this file: with the isolated linker each package has its own
+// link and this directory would walk up to a different copy.
+process.noDeprecation = true
+await import(Bun.resolveSync('three', process.cwd()))

From 61f2fafa0263cd284fc17c85a990f39e0eecc5ca Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 17:10:52 -0400
Subject: [PATCH 10/27] fix(roof): lift the inner cutter and deck with the
 shell eave

The 5 cm CSG floor lifted only the outer shell, so a flat zero-height
roof would have ended up with a solid cap under the deck. Compute the
lift once and apply it to every volume.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 .../src/systems/roof/roof-system.test.ts      | 30 +++++++++++++++++++
 .../viewer/src/systems/roof/roof-system.tsx   |  8 +++--
 2 files changed, 36 insertions(+), 2 deletions(-)

diff --git a/packages/viewer/src/systems/roof/roof-system.test.ts b/packages/viewer/src/systems/roof/roof-system.test.ts
index 657de52b6..f167b0469 100644
--- a/packages/viewer/src/systems/roof/roof-system.test.ts
+++ b/packages/viewer/src/systems/roof/roof-system.test.ts
@@ -36,6 +36,36 @@ describe('roof system gable geometry', () => {
       brushes.rakeBoards?.dispose()
     }
   })
+
+  test('lifts the inner cutter with the shell so a flat zero-height roof stays hollow', () => {
+    const segment = RoofSegmentNode.parse({
+      roofType: 'flat',
+      width: 8,
+      depth: 6,
+      wallHeight: 0,
+      wallThickness: 0.1,
+      pitch: 0,
+    })
+    const brushes = getRoofSegmentBrushes(segment)
+    expect(brushes).not.toBeNull()
+    if (!brushes) return
+    try {
+      brushes.wallBrush.geometry.computeBoundingBox()
+      brushes.innerBrush.geometry.computeBoundingBox()
+      expect(brushes.wallBrush.geometry.boundingBox!.min.y).toBe(0)
+      expect(brushes.wallBrush.geometry.boundingBox!.max.y).toBeCloseTo(0.05, 6)
+      expect(brushes.innerBrush.geometry.boundingBox!.max.y).toBeCloseTo(
+        brushes.wallBrush.geometry.boundingBox!.max.y,
+        6,
+      )
+    } finally {
+      brushes.wallBrush.geometry.dispose()
+      brushes.innerBrush.geometry.dispose()
+      brushes.deckSlab.geometry.dispose()
+      brushes.shinSlab.geometry.dispose()
+      brushes.rakeBoards?.dispose()
+    }
+  })
 })
 
 describe('roof system shed geometry', () => {
diff --git a/packages/viewer/src/systems/roof/roof-system.tsx b/packages/viewer/src/systems/roof/roof-system.tsx
index a9a26324c..291c9f098 100644
--- a/packages/viewer/src/systems/roof/roof-system.tsx
+++ b/packages/viewer/src/systems/roof/roof-system.tsx
@@ -1368,6 +1368,11 @@ export function getRoofSegmentBrushes(node: RoofSegmentNode): RoofSegmentBrushSe
   // same ratio). A hardcoded 0.25 desyncs the gablet from the parameter.
   const baseI = Math.min(width, depth) * node.dutchHipWidthRatio
 
+  // Keep the outer shell's CSG prism at least 5 cm tall by lifting its eave,
+  // never by sinking the base (the base is the wall top). Every volume gets
+  // the same lift so the inner cutter and the deck keep their offsets to it.
+  const eaveLift = Math.max(0, 0.05 - (wallHeight - (wallThickness / 2) * tanTheta))
+
   const getVol = (
     wExt: number,
     vOffset: number,
@@ -1380,8 +1385,7 @@ export function getRoofSegmentBrushes(node: RoofSegmentNode): RoofSegmentBrushSe
     const dV = Math.max(0.01, depth + 2 * wExt)
 
     const autoDrop = wExt * tanTheta
-    // Raise the top for CSG safety; sinking the base overlaps the supporting wall.
-    const whV = Math.max(baseY + 0.05, wallHeight - autoDrop + vOffset)
+    const whV = wallHeight - autoDrop + vOffset + eaveLift
 
     let rhV = activeRh
     if (activeRh > 0) {

From 9d79be1514c410af44abca2d712414abf03585dd Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 17:10:52 -0400
Subject: [PATCH 11/27] fix(editor): fall back to the autosave flush when the
 host does not handle Cmd+S

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 packages/editor/src/components/editor/index.tsx | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/packages/editor/src/components/editor/index.tsx b/packages/editor/src/components/editor/index.tsx
index 7c964c26e..8da2bcd69 100644
--- a/packages/editor/src/components/editor/index.tsx
+++ b/packages/editor/src/components/editor/index.tsx
@@ -196,10 +196,11 @@ export interface EditorProps {
   onLoad?: () => Promise<SceneGraph | null>
   onSave?: (scene: SceneGraph, options?: { keepalive?: boolean }) => Promise<void>
   /**
-   * Cmd/Ctrl+S. Defaults to flushing the autosave; hosts with a richer save
-   * (the community version checkpoint) take the chord over.
+   * Cmd/Ctrl+S. Return true when the host handled the save (the community
+   * version checkpoint); anything else falls through to flushing the autosave,
+   * so the chord still saves when the host's control isn't mounted.
    */
-  onSaveShortcut?: () => void
+  onSaveShortcut?: () => boolean | undefined
   onDirty?: () => void
   onSaveStatusChange?: (status: SaveStatus) => void
 
@@ -1263,7 +1264,11 @@ function EditorContent({
     isVersionPreviewMode,
   })
 
-  useSaveShortcut(onSaveShortcut ?? saveNow)
+  const handleSaveShortcut = useCallback(() => {
+    if (onSaveShortcut?.() === true) return
+    saveNow()
+  }, [onSaveShortcut, saveNow])
+  useSaveShortcut(handleSaveShortcut)
 
   const [isSceneLoading, setIsSceneLoading] = useState(false)
   const [hasLoadedInitialScene, setHasLoadedInitialScene] = useState(false)

From 1651ac0d18e393ec64d356c6d2fa8097c01d1c50 Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 17:28:30 -0400
Subject: [PATCH 12/27] fix(roof): floor every prism at 5 cm instead of lifting
 by the shell's eave

A shell-derived lift left overhanging deck cutters with a negative eave.
Clamp each volume's top the way main did, just at 5 cm and without the
base sink, so cutters stay level with the shells they carve.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 packages/viewer/src/systems/roof/roof-system.tsx | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/packages/viewer/src/systems/roof/roof-system.tsx b/packages/viewer/src/systems/roof/roof-system.tsx
index 291c9f098..e2d651e66 100644
--- a/packages/viewer/src/systems/roof/roof-system.tsx
+++ b/packages/viewer/src/systems/roof/roof-system.tsx
@@ -1368,11 +1368,6 @@ export function getRoofSegmentBrushes(node: RoofSegmentNode): RoofSegmentBrushSe
   // same ratio). A hardcoded 0.25 desyncs the gablet from the parameter.
   const baseI = Math.min(width, depth) * node.dutchHipWidthRatio
 
-  // Keep the outer shell's CSG prism at least 5 cm tall by lifting its eave,
-  // never by sinking the base (the base is the wall top). Every volume gets
-  // the same lift so the inner cutter and the deck keep their offsets to it.
-  const eaveLift = Math.max(0, 0.05 - (wallHeight - (wallThickness / 2) * tanTheta))
-
   const getVol = (
     wExt: number,
     vOffset: number,
@@ -1385,7 +1380,10 @@ export function getRoofSegmentBrushes(node: RoofSegmentNode): RoofSegmentBrushSe
     const dV = Math.max(0.01, depth + 2 * wExt)
 
     const autoDrop = wExt * tanTheta
-    const whV = wallHeight - autoDrop + vOffset + eaveLift
+    // Floor every prism at 5 cm so CSG never sees a degenerate volume — by
+    // raising the top, never by sinking the base (the base is the wall top).
+    // One floor for all volumes keeps each cutter level with the shell it carves.
+    const whV = Math.max(0.05, wallHeight - autoDrop + vOffset)
 
     let rhV = activeRh
     if (activeRh > 0) {

From f7f60e4175d24c528940661554d4dcc7ac8fd951 Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 17:46:05 -0400
Subject: [PATCH 13/27] fix(stair): drop the duplicate geometry Rise control

The rise-mode block already exposes the Rise field in custom mode; the
geometry copy wrote totalRise behind the Follows storey toggle.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 packages/nodes/src/stair/panel.tsx | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/packages/nodes/src/stair/panel.tsx b/packages/nodes/src/stair/panel.tsx
index e6f135065..e187c8f3f 100644
--- a/packages/nodes/src/stair/panel.tsx
+++ b/packages/nodes/src/stair/panel.tsx
@@ -459,16 +459,6 @@ export default function StairPanel() {
             unit="m"
             value={Math.round((node.width ?? 1) * 100) / 100}
           />
-          <MetricControl
-            label="Rise"
-            max={1000}
-            min={0.2}
-            onChange={(value) => handleUpdate({ totalRise: value })}
-            precision={2}
-            step={0.05}
-            unit="m"
-            value={resolvedRise}
-          />
           <MetricControl
             label="Steps"
             max={32}

From 91d01e7998c39ae373f50b953dc199e2651d1465 Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 17:46:54 -0400
Subject: [PATCH 14/27] test: import resolveSync explicitly in the three
 preload

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 scripts/bun-preload-three.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/scripts/bun-preload-three.ts b/scripts/bun-preload-three.ts
index d222da213..00bb28137 100644
--- a/scripts/bun-preload-three.ts
+++ b/scripts/bun-preload-three.ts
@@ -1,3 +1,5 @@
+import { resolveSync } from 'bun'
+
 // three r186's CommonJS entry is `require('./three.module.js')`. Bun cannot
 // require() an ES module that is still loading, and the R3F ecosystem (fiber,
 // drei, maath, meshline, troika) ships CJS mains that require("three") while
@@ -7,4 +9,4 @@
 // test, not from this file: with the isolated linker each package has its own
 // link and this directory would walk up to a different copy.
 process.noDeprecation = true
-await import(Bun.resolveSync('three', process.cwd()))
+await import(resolveSync('three', process.cwd()))

From 9dfd816da592547d7d26cd570af6d5b38345fff0 Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 18:04:43 -0400
Subject: [PATCH 15/27] test: skip the three preload where the cwd has no three
 dependency

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 scripts/bun-preload-three.ts | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/scripts/bun-preload-three.ts b/scripts/bun-preload-three.ts
index 00bb28137..25f5243f7 100644
--- a/scripts/bun-preload-three.ts
+++ b/scripts/bun-preload-three.ts
@@ -7,6 +7,11 @@ import { resolveSync } from 'bun'
 // dies with "require() async module is unsupported". Evaluating three first
 // turns the later require() into a cache hit. Resolve from the package under
 // test, not from this file: with the isolated linker each package has its own
-// link and this directory would walk up to a different copy.
+// link and this directory would walk up to a different copy. Packages that do
+// not depend on three have nothing to pre-evaluate.
 process.noDeprecation = true
-await import(resolveSync('three', process.cwd()))
+let threePath: string | null = null
+try {
+  threePath = resolveSync('three', process.cwd())
+} catch {}
+if (threePath) await import(threePath)

From c50f5492d19f1944a7dfaf91c14b63f689a3f126 Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 18:04:43 -0400
Subject: [PATCH 16/27] fix(editor): seed placed stairs from the elected base;
 keep the gesture when R/T cannot engage

The stair tool seeded the flight from the storey height alone, a slab
thickness too tall until syncStairRises caught up; it now subtracts the
drop point's elected base like the resolver. A failed engage() on R/T no
longer tears down the pointer listeners.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 .../editor-2d/floorplan-group-move.tsx        |  6 +++-
 .../src/components/editor/group-move-3d.ts    |  6 +++-
 .../src/components/tools/stair/stair-tool.tsx | 28 ++++++++++++++++---
 3 files changed, 34 insertions(+), 6 deletions(-)

diff --git a/packages/editor/src/components/editor-2d/floorplan-group-move.tsx b/packages/editor/src/components/editor-2d/floorplan-group-move.tsx
index 74d954cca..910097ec7 100644
--- a/packages/editor/src/components/editor-2d/floorplan-group-move.tsx
+++ b/packages/editor/src/components/editor-2d/floorplan-group-move.tsx
@@ -376,7 +376,11 @@ export function startFloorplanGroupMove(
       if (!session) {
         session = engage()
         if (!session) {
-          removeListeners()
+          // No plane hit yet: swallow the chord and keep the gesture armed so
+          // the next pointer-move can still engage; the idle arm must not run
+          // behind the snapshots captured here.
+          e.preventDefault()
+          e.stopPropagation()
           return
         }
       }
diff --git a/packages/editor/src/components/editor/group-move-3d.ts b/packages/editor/src/components/editor/group-move-3d.ts
index aeecefbda..f23614b97 100644
--- a/packages/editor/src/components/editor/group-move-3d.ts
+++ b/packages/editor/src/components/editor/group-move-3d.ts
@@ -385,7 +385,11 @@ export function armGroupMove3d(args: {
       if (!session) {
         session = engage()
         if (!session) {
-          removeListeners()
+          // No plane hit yet: swallow the chord and keep the gesture armed so
+          // the next pointer-move can still engage; the idle arm must not run
+          // behind the snapshots captured here.
+          e.preventDefault()
+          e.stopPropagation()
           return
         }
       }
diff --git a/packages/editor/src/components/tools/stair/stair-tool.tsx b/packages/editor/src/components/tools/stair/stair-tool.tsx
index 9d68d491f..f462eff86 100644
--- a/packages/editor/src/components/tools/stair/stair-tool.tsx
+++ b/packages/editor/src/components/tools/stair/stair-tool.tsx
@@ -5,6 +5,7 @@ import {
   DEFAULT_LEVEL_HEIGHT,
   emitter,
   type GridEvent,
+  getFloorStackedPosition,
   getLevelFloorToFloorHeight,
   type LevelNode,
   movingAlignmentAnchors,
@@ -108,6 +109,23 @@ function createStairPreviewGeometry(rise: number): THREE.BufferGeometry {
  * dropped on, not a constant: the placed stair has no explicit `totalRise`, so
  * this is the height `syncStairRises` immediately converges it to anyway.
  */
+function resolvePlacedStairRise(
+  nodes: Record<string, AnyNode>,
+  levelId: LevelNode['id'],
+  stair: StairNode,
+): number {
+  // Same contract as `resolveStairTotalRise` for a stair that is not in the
+  // scene yet: the storey height minus whatever slab lifts the drop point.
+  const base = getFloorStackedPosition({
+    node: stair,
+    nodes,
+    position: stair.position,
+    rotation: stair.rotation,
+    levelId,
+  })[1]
+  return getLevelFloorToFloorHeight(levelId, nodes) - base
+}
+
 function createDefaultStairSegment(rise: number) {
   return StairSegmentNode.parse({
     segmentType: 'stair',
@@ -181,7 +199,7 @@ function commitStairPlacement(
 
   const stairCount = Object.values(nodes).filter((n) => n.type === 'stair').length
   const name = `Staircase ${stairCount + 1}`
-  const segment = createDefaultStairSegment(getLevelFloorToFloorHeight(placementLevelId, nodes))
+  const seed = createDefaultStairSegment(getLevelFloorToFloorHeight(placementLevelId, nodes))
 
   const destinationPlan = resolveStairDestinationLevel({
     createMissing: true,
@@ -197,10 +215,11 @@ function commitStairPlacement(
       nextLevelId,
       position,
       rotation,
-      segmentId: segment.id,
+      segmentId: seed.id,
     }),
     parentId: placementLevelId,
   })
+  const segment = { ...seed, height: resolvePlacedStairRise(nodes, placementLevelId, stair) }
   const prospectiveNodes = {
     ...nodes,
     [stair.id]: stair,
@@ -287,15 +306,16 @@ export const StairTool: React.FC = () => {
         nodes,
       })
       const nextLevelId = destinationPlan?.toLevel.id ?? placementLevelId
-      const segment = createDefaultStairSegment(getLevelFloorToFloorHeight(placementLevelId, nodes))
+      const seed = createDefaultStairSegment(getLevelFloorToFloorHeight(placementLevelId, nodes))
       const stair = createDefaultStairNode({
         name: 'Staircase Preview',
         levelId: placementLevelId,
         nextLevelId,
         position,
         rotation,
-        segmentId: segment.id,
+        segmentId: seed.id,
       })
+      const segment = { ...seed, height: resolvePlacedStairRise(nodes, placementLevelId, stair) }
       const previewNodes = {
         ...nodes,
         ...(destinationPlan?.createdLevel

From 5526120067cb5fec20443fed91f222d533a5ff83 Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 18:14:10 -0400
Subject: [PATCH 17/27] fix(stair): cap the placed rise by the pointed support
 surface

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 .../src/components/tools/stair/stair-tool.tsx | 26 ++++++++++++++-----
 1 file changed, 20 insertions(+), 6 deletions(-)

diff --git a/packages/editor/src/components/tools/stair/stair-tool.tsx b/packages/editor/src/components/tools/stair/stair-tool.tsx
index f462eff86..8ef800de6 100644
--- a/packages/editor/src/components/tools/stair/stair-tool.tsx
+++ b/packages/editor/src/components/tools/stair/stair-tool.tsx
@@ -113,15 +113,19 @@ function resolvePlacedStairRise(
   nodes: Record<string, AnyNode>,
   levelId: LevelNode['id'],
   stair: StairNode,
+  supportSurface: PointerSupportSurface | null,
 ): number {
   // Same contract as `resolveStairTotalRise` for a stair that is not in the
-  // scene yet: the storey height minus whatever slab lifts the drop point.
+  // scene yet: the storey height minus whatever slab lifts the drop point,
+  // capped by the surface the pointer actually aims at (a floor under an
+  // overlapping deck must not elect the deck).
   const base = getFloorStackedPosition({
     node: stair,
     nodes,
     position: stair.position,
     rotation: stair.rotation,
     levelId,
+    maxElevation: supportSurface?.elevation ?? null,
   })[1]
   return getLevelFloorToFloorHeight(levelId, nodes) - base
 }
@@ -219,7 +223,10 @@ function commitStairPlacement(
     }),
     parentId: placementLevelId,
   })
-  const segment = { ...seed, height: resolvePlacedStairRise(nodes, placementLevelId, stair) }
+  const segment = {
+    ...seed,
+    height: resolvePlacedStairRise(nodes, placementLevelId, stair, supportSurface),
+  }
   const prospectiveNodes = {
     ...nodes,
     [stair.id]: stair,
@@ -291,7 +298,11 @@ export const StairTool: React.FC = () => {
     lastCanonicalPositionRef.current = null
     supportSurfaceRef.current = null
 
-    const buildPreviewScene = (position: [number, number, number], rotation: number) => {
+    const buildPreviewScene = (
+      position: [number, number, number],
+      rotation: number,
+      supportSurface: PointerSupportSurface | null,
+    ) => {
       const nodes = useScene.getState().nodes
       const placementLevelId = resolveStairPlacementLevelId(
         nodes,
@@ -315,7 +326,10 @@ export const StairTool: React.FC = () => {
         rotation,
         segmentId: seed.id,
       })
-      const segment = { ...seed, height: resolvePlacedStairRise(nodes, placementLevelId, stair) }
+      const segment = {
+        ...seed,
+        height: resolvePlacedStairRise(nodes, placementLevelId, stair, supportSurface),
+      }
       const previewNodes = {
         ...nodes,
         ...(destinationPlan?.createdLevel
@@ -346,7 +360,7 @@ export const StairTool: React.FC = () => {
       if (key === lastPreviewKey) return
       lastPreviewKey = key
       useStairBuildPreview.getState().setPreview([position[0], position[2]], rotation)
-      const preview = buildPreviewScene(position, rotation)
+      const preview = buildPreviewScene(position, rotation, supportSurface)
       const frozenPatch =
         preview && supportSurface?.sourceNodeId
           ? resolveFrozenFloorPlacementPatch(preview.stair, preview.previewNodes, {
@@ -415,7 +429,7 @@ export const StairTool: React.FC = () => {
       z: number,
       rotation: number,
     ): ReturnType<typeof resolveAlignment> | null => {
-      const preview = buildPreviewScene([x, 0, z], rotation)
+      const preview = buildPreviewScene([x, 0, z], rotation, supportSurfaceRef.current)
       const moving = preview
         ? movingAlignmentAnchors(preview.stair, preview.previewNodes, x, z, rotation)
         : []

From 71122f6e9d415868596f8006ac45e1fc32d3c334 Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 18:30:52 -0400
Subject: [PATCH 18/27] fix: scale the stair ghost to the placed rise; await
 renderer.dispose() before the WebGL fallback

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 .../editor/src/components/tools/stair/stair-tool.tsx | 12 ++++++++++--
 packages/viewer/src/lib/renderer-capability.ts       |  7 ++++---
 2 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/packages/editor/src/components/tools/stair/stair-tool.tsx b/packages/editor/src/components/tools/stair/stair-tool.tsx
index 8ef800de6..a14b77742 100644
--- a/packages/editor/src/components/tools/stair/stair-tool.tsx
+++ b/packages/editor/src/components/tools/stair/stair-tool.tsx
@@ -280,6 +280,8 @@ export const StairTool: React.FC = () => {
   const previewRise = useScene((state) =>
     currentLevelId ? getLevelFloorToFloorHeight(currentLevelId, state.nodes) : DEFAULT_LEVEL_HEIGHT,
   )
+  const previewRiseRef = useRef(previewRise)
+  previewRiseRef.current = previewRise
   const previewGeometry = useMemo(() => createStairPreviewGeometry(previewRise), [previewRise])
   useEffect(() => () => previewGeometry.dispose(), [previewGeometry])
 
@@ -294,7 +296,10 @@ export const StairTool: React.FC = () => {
     // Reset rotation when tool activates
     rotationRef.current = 0
     useStairBuildPreview.getState().reset()
-    if (previewRef.current) previewRef.current.rotation.y = 0
+    if (previewRef.current) {
+      previewRef.current.rotation.y = 0
+      previewRef.current.scale.y = 1
+    }
     lastCanonicalPositionRef.current = null
     supportSurfaceRef.current = null
 
@@ -339,7 +344,7 @@ export const StairTool: React.FC = () => {
         [segment.id]: { ...segment, parentId: stair.id },
       } as Record<string, AnyNode>
 
-      return { placementLevelId, previewNodes, stair }
+      return { placementLevelId, previewNodes, stair, rise: segment.height }
     }
 
     // The preview rebuild (full-scene copy + destination-level resolution +
@@ -396,6 +401,9 @@ export const StairTool: React.FC = () => {
       if (previewRef.current) {
         previewRef.current.position.set(...visualPosition)
         previewRef.current.rotation.y = rotation
+        // The ghost geometry is built for the storey height; squash it to the
+        // rise the placed flight will get on this surface.
+        previewRef.current.scale.y = preview ? preview.segment.height / previewRiseRef.current : 1
       }
 
       // Forward-facing triangle (editor-side overlay). The run ascends along
diff --git a/packages/viewer/src/lib/renderer-capability.ts b/packages/viewer/src/lib/renderer-capability.ts
index 53199d0a0..0bf90e696 100644
--- a/packages/viewer/src/lib/renderer-capability.ts
+++ b/packages/viewer/src/lib/renderer-capability.ts
@@ -152,8 +152,9 @@ export async function initializeGpuRenderer<Renderer extends InitializableRender
     return { backend: capability.backend, renderer, status: 'ready' }
   } catch (error) {
     try {
-      // r186 made dispose() async; swallow the rejection like the sync throw.
-      Promise.resolve(renderer?.dispose?.()).catch(() => {})
+      // r186 made dispose() async: let it finish before the device is released
+      // and the WebGL fallback starts on the same canvas.
+      await renderer?.dispose?.()
     } catch {}
     if (capability.backend !== 'webgpu') return { error, status: 'unsupported' }
 
@@ -166,7 +167,7 @@ export async function initializeGpuRenderer<Renderer extends InitializableRender
       return { backend: 'webgl', renderer, status: 'ready' }
     } catch (fallbackError) {
       try {
-        Promise.resolve(renderer?.dispose?.()).catch(() => {})
+        await renderer?.dispose?.()
       } catch {}
       return { error: fallbackError, status: 'unsupported' }
     }

From 7aac601a34250911af7c8d7d86b8a92b1ba4371a Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 18:31:26 -0400
Subject: [PATCH 19/27] fix(stair): read the placed rise from the preview scene

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 packages/editor/src/components/tools/stair/stair-tool.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/editor/src/components/tools/stair/stair-tool.tsx b/packages/editor/src/components/tools/stair/stair-tool.tsx
index a14b77742..2d4cf3b70 100644
--- a/packages/editor/src/components/tools/stair/stair-tool.tsx
+++ b/packages/editor/src/components/tools/stair/stair-tool.tsx
@@ -403,7 +403,7 @@ export const StairTool: React.FC = () => {
         previewRef.current.rotation.y = rotation
         // The ghost geometry is built for the storey height; squash it to the
         // rise the placed flight will get on this surface.
-        previewRef.current.scale.y = preview ? preview.segment.height / previewRiseRef.current : 1
+        previewRef.current.scale.y = preview ? preview.rise / previewRiseRef.current : 1
       }
 
       // Forward-facing triangle (editor-side overlay). The run ascends along

From 40eba21ffcac85ce8e59b258ffd299ea5b27990b Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Wed, 9 Sep 2026 18:44:13 -0400
Subject: [PATCH 20/27] fix(selection): re-fit alignment bounds from the start
 footprint after each R/T

Rotating the previous axis-aligned fit inflated the anchors every step.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 .../src/components/editor-2d/floorplan-group-move.tsx    | 7 ++++++-
 packages/editor/src/components/editor/group-actions.ts   | 4 +++-
 packages/editor/src/components/editor/group-move-3d.ts   | 9 ++++++++-
 3 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/packages/editor/src/components/editor-2d/floorplan-group-move.tsx b/packages/editor/src/components/editor-2d/floorplan-group-move.tsx
index 910097ec7..1c63b3a3c 100644
--- a/packages/editor/src/components/editor-2d/floorplan-group-move.tsx
+++ b/packages/editor/src/components/editor-2d/floorplan-group-move.tsx
@@ -115,7 +115,9 @@ export function startFloorplanGroupMove(
     affectedIds: AnyNodeId[]
     candidates: ReturnType<typeof collectAlignmentAnchors>
     restAnchors: ReturnType<typeof bboxCornerAnchors>
+    startBounds: GroupPlanBounds
     restBounds: GroupPlanBounds
+    rotation: number
     restCenter: Vec2
     lastDelta: Vec2 | null
   }
@@ -180,7 +182,9 @@ export function startFloorplanGroupMove(
       affectedIds,
       candidates,
       restAnchors,
+      startBounds: restBounds,
       restBounds,
+      rotation: 0,
       restCenter,
       lastDelta: null,
     }
@@ -255,7 +259,8 @@ export function startFloorplanGroupMove(
     const rotated = rotateGroupSnapshots(s.starts, s.links, pivot, delta)
     s.starts = rotated.starts
     s.links = rotated.links
-    s.restBounds = rotatePlanBounds(s.restBounds, pivot, delta)
+    s.rotation += delta
+    s.restBounds = rotatePlanBounds(s.startBounds, pivot, s.rotation)
     s.restAnchors = bboxCornerAnchors(
       'group-move',
       s.restBounds.minX,
diff --git a/packages/editor/src/components/editor/group-actions.ts b/packages/editor/src/components/editor/group-actions.ts
index 48ecc0174..e2c0d6876 100644
--- a/packages/editor/src/components/editor/group-actions.ts
+++ b/packages/editor/src/components/editor/group-actions.ts
@@ -112,6 +112,7 @@ export function startGroupPickUp(
   if (!startBounds) return false
   // Mutable: mid-carry R/T re-seeds the footprint around the same pivot.
   let restBounds = startBounds
+  let carriedRotation = 0
   // Rotation pivot for mid-carry R/T; stable across the whole pick-up.
   const restCenter = planBoundsCenter(restBounds)
   // Ground plane for the 3D surface: the meshes' base when available, floor
@@ -255,7 +256,8 @@ export function startGroupPickUp(
     const rotated = rotateGroupSnapshots(starts, links, pivot, delta)
     starts = rotated.starts
     links = rotated.links
-    restBounds = rotatePlanBounds(restBounds, pivot, delta)
+    carriedRotation += delta
+    restBounds = rotatePlanBounds(startBounds, pivot, carriedRotation)
     restAnchors = bboxCornerAnchors(
       'group-move',
       restBounds.minX,
diff --git a/packages/editor/src/components/editor/group-move-3d.ts b/packages/editor/src/components/editor/group-move-3d.ts
index f23614b97..3a26251e5 100644
--- a/packages/editor/src/components/editor/group-move-3d.ts
+++ b/packages/editor/src/components/editor/group-move-3d.ts
@@ -91,7 +91,9 @@ export function armGroupMove3d(args: {
     affectedIds: AnyNodeId[]
     candidates: ReturnType<typeof collectAlignmentAnchors>
     restAnchors: ReturnType<typeof bboxCornerAnchors>
+    startBounds: GroupPlanBounds
     restBounds: GroupPlanBounds
+    rotation: number
     restCenter: Vec2
     plane: Plane
     startLocal: Vector3
@@ -170,7 +172,9 @@ export function armGroupMove3d(args: {
       affectedIds,
       candidates,
       restAnchors,
+      startBounds: restBounds,
       restBounds,
+      rotation: 0,
       restCenter,
       plane,
       startLocal,
@@ -257,7 +261,10 @@ export function armGroupMove3d(args: {
     const rotated = rotateGroupSnapshots(s.starts, s.links, pivot, delta)
     s.starts = rotated.starts
     s.links = rotated.links
-    s.restBounds = rotatePlanBounds(s.restBounds, pivot, delta)
+    // Re-fit from the start footprint at the accumulated angle: rotating the
+    // previous axis-aligned fit would inflate the box every step.
+    s.rotation += delta
+    s.restBounds = rotatePlanBounds(s.startBounds, pivot, s.rotation)
     s.restAnchors = bboxCornerAnchors(
       'group-move',
       s.restBounds.minX,

From 4c7439fc4203c07ccfa48b9fadca08e4a152b5a3 Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Thu, 10 Sep 2026 09:44:10 -0400
Subject: [PATCH 21/27] fix(stair): switching to straight materializes a
 flight; level labels use the shared display name

A curved stair switched to straight had no stair-segment child and drew
nothing (and vanished on select). The type change now creates a default
flight in the same history step and the viewer falls back to that flight
for already-broken scenes. Stair and elevator panels label levels the way
the level switcher does, and the rise toggle reads Follows level like walls.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 packages/core/src/index.ts                    |  7 ++
 .../core/src/systems/stair/stair-flight.ts    | 41 ++++++++
 .../systems/stair/stair-edit-system.tsx       |  7 +-
 .../src/components/tools/stair/stair-tool.tsx | 13 ++-
 packages/nodes/src/elevator/panel.tsx         | 13 ++-
 packages/nodes/src/stair/panel.tsx            | 34 ++++---
 packages/nodes/src/stair/stair-type.test.ts   | 94 +++++++++++++++++++
 packages/nodes/src/stair/stair-type.ts        | 47 ++++++++++
 .../viewer/src/systems/stair/stair-system.tsx | 17 ++--
 9 files changed, 235 insertions(+), 38 deletions(-)
 create mode 100644 packages/core/src/systems/stair/stair-flight.ts
 create mode 100644 packages/nodes/src/stair/stair-type.test.ts
 create mode 100644 packages/nodes/src/stair/stair-type.ts

diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 1d250404a..91dfeed97 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -395,12 +395,19 @@ export {
   isSplineFence,
   sampleFenceSpline,
 } from './systems/fence/fence-spline'
+export { resolveRoofElevation, resolveRoofWallTopElevation } from './systems/roof/roof-elevation'
+export { RoofElevationSystem } from './systems/roof/roof-elevation-system'
 export { resolveSlabPlacementElevation } from './systems/slab/slab-placement'
 export {
   clampSlabElevationForWalls,
   getSlabElevationUpperBound,
   type SlabElevationClamp,
 } from './systems/slab/slab-support'
+export {
+  createDefaultStairSegment,
+  createStairFlightFromStair,
+  type StairFlightOverrides,
+} from './systems/stair/stair-flight'
 export { type StairFootprintAABB, stairFootprintAABB } from './systems/stair/stair-footprint'
 export { createSurfaceOpeningPreviewController } from './systems/stair/stair-opening-preview'
 export { syncAutoStairOpenings } from './systems/stair/stair-opening-sync'
diff --git a/packages/core/src/systems/stair/stair-flight.ts b/packages/core/src/systems/stair/stair-flight.ts
new file mode 100644
index 000000000..fcdc7e9c8
--- /dev/null
+++ b/packages/core/src/systems/stair/stair-flight.ts
@@ -0,0 +1,41 @@
+import type { AnyNode, StairNode } from '../../schema'
+import { StairSegmentNode } from '../../schema'
+import { resolveStairTotalRise } from './stair-rise'
+
+const MIN_STAIR_FLIGHT_RISE = 0.1
+const MIN_STAIR_FLIGHT_STEP_COUNT = 2
+
+export type StairFlightOverrides = Partial<
+  Pick<
+    StairSegmentNode,
+    'width' | 'length' | 'height' | 'stepCount' | 'attachmentSide' | 'fillToFloor' | 'thickness'
+  >
+>
+
+/**
+ * The single definition of a default straight flight. Anything left out falls
+ * through to the `StairSegmentNode` schema defaults (length 3 m, 10 steps,
+ * filled to floor) rather than being spelled again per call site, so the stair
+ * tool's seed segment, the flight the panel materializes when a curved stair
+ * becomes straight, and the viewer's fallback body all describe one stair.
+ */
+export function createDefaultStairSegment(overrides: StairFlightOverrides = {}): StairSegmentNode {
+  return StairSegmentNode.parse({ segmentType: 'stair', position: [0, 0, 0], ...overrides })
+}
+
+/**
+ * The flight a straight stair implies from its own fields — used wherever a
+ * straight stair has to stand in for missing `stair-segment` children.
+ */
+export function createStairFlightFromStair(
+  stair: StairNode,
+  nodes: Record<string, AnyNode>,
+): StairSegmentNode {
+  return createDefaultStairSegment({
+    width: stair.width,
+    height: Math.max(resolveStairTotalRise(stair, nodes), MIN_STAIR_FLIGHT_RISE),
+    stepCount: Math.max(MIN_STAIR_FLIGHT_STEP_COUNT, Math.round(stair.stepCount ?? 10)),
+    thickness: stair.thickness,
+    fillToFloor: stair.fillToFloor,
+  })
+}
diff --git a/packages/editor/src/components/systems/stair/stair-edit-system.tsx b/packages/editor/src/components/systems/stair/stair-edit-system.tsx
index 1831aaaa0..08b492a08 100644
--- a/packages/editor/src/components/systems/stair/stair-edit-system.tsx
+++ b/packages/editor/src/components/systems/stair/stair-edit-system.tsx
@@ -67,9 +67,12 @@ export const StairEditSystem = () => {
       const mergedMesh = group.getObjectByName('merged-stair')
       const segmentsWrapper = group.getObjectByName('segments-wrapper')
       const isActive = activeStairIds.has(stairId)
+      // A straight stair with no segment children has an empty wrapper, so
+      // edit mode would hide the merged body and leave nothing on screen.
+      const isEditable = !isCurved && (stairNode?.children?.length ?? 0) > 0
 
-      if (mergedMesh) mergedMesh.visible = !(isActive || isCurved)
-      if (segmentsWrapper) segmentsWrapper.visible = isActive && !isCurved
+      if (mergedMesh) mergedMesh.visible = !((isActive && isEditable) || isCurved)
+      if (segmentsWrapper) segmentsWrapper.visible = isActive && isEditable
 
       if (stairNode?.children?.length) {
         const wasActive = prevActiveStairIds.current.has(stairId)
diff --git a/packages/editor/src/components/tools/stair/stair-tool.tsx b/packages/editor/src/components/tools/stair/stair-tool.tsx
index 2d4cf3b70..71dabb502 100644
--- a/packages/editor/src/components/tools/stair/stair-tool.tsx
+++ b/packages/editor/src/components/tools/stair/stair-tool.tsx
@@ -1,6 +1,7 @@
 import {
   type AnyNode,
   collectAlignmentAnchors,
+  createDefaultStairSegment,
   createSurfaceOpeningPreviewController,
   DEFAULT_LEVEL_HEIGHT,
   emitter,
@@ -14,7 +15,7 @@ import {
   resolveFrozenFloorPlacementPatch,
   resolveSupportSlabPatch,
   StairNode,
-  StairSegmentNode,
+  type StairSegmentNode,
   syncAutoStairOpenings,
   useScene,
 } from '@pascal-app/core'
@@ -130,9 +131,8 @@ function resolvePlacedStairRise(
   return getLevelFloorToFloorHeight(levelId, nodes) - base
 }
 
-function createDefaultStairSegment(rise: number) {
-  return StairSegmentNode.parse({
-    segmentType: 'stair',
+function createSeedStairSegment(rise: number) {
+  return createDefaultStairSegment({
     width: DEFAULT_STAIR_WIDTH,
     length: DEFAULT_STAIR_LENGTH,
     height: rise,
@@ -140,7 +140,6 @@ function createDefaultStairSegment(rise: number) {
     attachmentSide: DEFAULT_STAIR_ATTACHMENT_SIDE,
     fillToFloor: DEFAULT_STAIR_FILL_TO_FLOOR,
     thickness: DEFAULT_STAIR_THICKNESS,
-    position: [0, 0, 0],
   })
 }
 
@@ -203,7 +202,7 @@ function commitStairPlacement(
 
   const stairCount = Object.values(nodes).filter((n) => n.type === 'stair').length
   const name = `Staircase ${stairCount + 1}`
-  const seed = createDefaultStairSegment(getLevelFloorToFloorHeight(placementLevelId, nodes))
+  const seed = createSeedStairSegment(getLevelFloorToFloorHeight(placementLevelId, nodes))
 
   const destinationPlan = resolveStairDestinationLevel({
     createMissing: true,
@@ -322,7 +321,7 @@ export const StairTool: React.FC = () => {
         nodes,
       })
       const nextLevelId = destinationPlan?.toLevel.id ?? placementLevelId
-      const seed = createDefaultStairSegment(getLevelFloorToFloorHeight(placementLevelId, nodes))
+      const seed = createSeedStairSegment(getLevelFloorToFloorHeight(placementLevelId, nodes))
       const stair = createDefaultStairNode({
         name: 'Staircase Preview',
         levelId: placementLevelId,
diff --git a/packages/nodes/src/elevator/panel.tsx b/packages/nodes/src/elevator/panel.tsx
index f716e1b3c..49964283c 100644
--- a/packages/nodes/src/elevator/panel.tsx
+++ b/packages/nodes/src/elevator/panel.tsx
@@ -5,6 +5,7 @@ import {
   type AnyNodeId,
   type ElevatorNode,
   ElevatorNode as ElevatorNodeSchema,
+  getLevelDisplayName,
   type LevelNode,
   requestElevatorLevel,
   useInteractive,
@@ -596,7 +597,7 @@ export default function ElevatorPanel() {
             >
               {levels.map((level) => (
                 <option key={level.id} value={level.id}>
-                  {level.name || `Level ${level.level}`}
+                  {getLevelDisplayName(level)}
                 </option>
               ))}
             </select>
@@ -613,7 +614,7 @@ export default function ElevatorPanel() {
             >
               {levels.map((level) => (
                 <option key={level.id} value={level.id}>
-                  {level.name || `Level ${level.level}`}
+                  {getLevelDisplayName(level)}
                 </option>
               ))}
             </select>
@@ -631,7 +632,7 @@ export default function ElevatorPanel() {
           >
             {defaultLevelOptions.map((level) => (
               <option key={level.id} value={level.id}>
-                {level.name || `Level ${level.level}`}
+                {getLevelDisplayName(level)}
               </option>
             ))}
           </select>
@@ -810,9 +811,7 @@ export default function ElevatorPanel() {
                 className="flex items-center justify-between gap-2 rounded-lg border border-border/45 bg-[#2C2C2E] px-2.5 py-2"
                 key={level.id}
               >
-                <span className="min-w-0 truncate text-sm">
-                  {level.name || `Level ${level.level}`}
-                </span>
+                <span className="min-w-0 truncate text-sm">{getLevelDisplayName(level)}</span>
                 <div className="flex shrink-0 gap-1.5">
                   <button
                     className={`rounded-md border px-2 py-1 text-[11px] transition-colors ${
@@ -866,7 +865,7 @@ export default function ElevatorPanel() {
                 type="button"
               >
                 <span className="flex min-w-0 flex-col">
-                  <span className="truncate text-xs">{level.name || `Level ${level.level}`}</span>
+                  <span className="truncate text-xs">{getLevelDisplayName(level)}</span>
                   {isDisabled ? (
                     <span className="mt-0.5 text-[10px] font-medium uppercase tracking-[0.12em] text-current/65">
                       Disabled
diff --git a/packages/nodes/src/stair/panel.tsx b/packages/nodes/src/stair/panel.tsx
index e187c8f3f..c674f9990 100644
--- a/packages/nodes/src/stair/panel.tsx
+++ b/packages/nodes/src/stair/panel.tsx
@@ -3,8 +3,10 @@
 import {
   type AnyNode,
   type AnyNodeId,
+  getLevelDisplayName,
   type LevelNode,
   resolveStairTotalRise,
+  runAsSingleSceneHistoryStep,
   type SlabNode,
   type StairNode,
   type StairRailingMode,
@@ -18,7 +20,6 @@ import {
 import {
   ActionButton,
   ActionGroup,
-  DEFAULT_SPIRAL_STAIR_SWEEP_ANGLE,
   duplicateStairSubtree,
   getStairLevelOptions,
   MetricControl,
@@ -38,6 +39,7 @@ import { Copy, Move, Plus, Trash2 } from 'lucide-react'
 import { useCallback, useMemo } from 'react'
 import { useShallow } from 'zustand/react/shallow'
 import { getStairDestinationUpdates } from './destination'
+import { getStairTypeChange } from './stair-type'
 
 const RAILING_MODE_OPTIONS: { label: string; value: StairRailingMode }[] = [
   { label: 'None', value: 'none' },
@@ -154,6 +156,18 @@ export default function StairPanel() {
     [handleUpdate],
   )
 
+  const handleStairTypeChange = useCallback(
+    (value: StairType) => {
+      if (!node) return
+      const change = getStairTypeChange(node, value, useScene.getState().nodes)
+      runAsSingleSceneHistoryStep(useScene, () => {
+        updateNode(node.id as AnyNode['id'], change.updates)
+        if (change.segment) createNode(change.segment, node.id as AnyNodeId)
+      })
+    },
+    [node, updateNode, createNode],
+  )
+
   const handleDestinationChange = useCallback(
     (value: string) => {
       if (!node) return
@@ -266,17 +280,7 @@ export default function StairPanel() {
     >
       <PanelSection title="Type">
         <SegmentedControl
-          onChange={(value) =>
-            handleUpdate(
-              value === 'spiral' && node.stairType !== 'spiral'
-                ? {
-                    stairType: value,
-                    sweepAngle: DEFAULT_SPIRAL_STAIR_SWEEP_ANGLE,
-                    position: [node.position[0], 0, node.position[2]],
-                  }
-                : { stairType: value },
-            )
-          }
+          onChange={handleStairTypeChange}
           options={STAIR_TYPE_OPTIONS}
           value={node.stairType ?? 'straight'}
         />
@@ -303,7 +307,7 @@ export default function StairPanel() {
             >
               {levels.map((level) => (
                 <option key={level.id} value={level.id}>
-                  {level.name || `Level ${level.level + 1}`}
+                  {getLevelDisplayName(level)}
                 </option>
               ))}
             </select>
@@ -320,7 +324,7 @@ export default function StairPanel() {
             >
               {levels.map((level) => (
                 <option key={level.id} value={level.id}>
-                  {level.name || `Level ${level.level + 1}`}
+                  {getLevelDisplayName(level)}
                 </option>
               ))}
               {candidateDecks.map((deck) => (
@@ -342,7 +346,7 @@ export default function StairPanel() {
                 )
               }
               options={[
-                { label: attachedDeck ? 'Follows deck' : 'Follows storey', value: 'follows' },
+                { label: attachedDeck ? 'Follows deck' : 'Follows level', value: 'follows' },
                 { label: 'Custom rise', value: 'custom' },
               ]}
               value={node.totalRise == null ? 'follows' : 'custom'}
diff --git a/packages/nodes/src/stair/stair-type.test.ts b/packages/nodes/src/stair/stair-type.test.ts
new file mode 100644
index 000000000..b340707a6
--- /dev/null
+++ b/packages/nodes/src/stair/stair-type.test.ts
@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'bun:test'
+import { type AnyNode, LevelNode, StairNode, StairSegmentNode } from '@pascal-app/core'
+import { getStairTypeChange } from './stair-type'
+
+const LEVEL_ID = 'level_5o2tes0jyuiupp2f'
+const STAIR_ID = 'stair_7yfdirs1t2iqslvi'
+
+function buildScene(overrides: Record<string, unknown> = {}, segmentHeights: number[] = []) {
+  const segments = segmentHeights.map((height, index) =>
+    StairSegmentNode.parse({
+      id: `sseg_${index}`,
+      type: 'stair-segment',
+      segmentType: 'stair',
+      height,
+      parentId: STAIR_ID,
+    }),
+  )
+  const stair = StairNode.parse({
+    id: STAIR_ID,
+    type: 'stair',
+    parentId: LEVEL_ID,
+    position: [9.5, 0, -3.5],
+    stairType: 'curved',
+    width: 0.9,
+    stepCount: 16,
+    thickness: 0.16,
+    fillToFloor: false,
+    totalRise: 3.81,
+    children: segments.map((segment) => segment.id),
+    ...overrides,
+  })
+  const level = LevelNode.parse({
+    id: LEVEL_ID,
+    type: 'level',
+    level: 0,
+    height: 3.5,
+    children: [STAIR_ID],
+  })
+  const nodes: Record<string, AnyNode> = { [level.id]: level, [stair.id]: stair }
+  for (const segment of segments) nodes[segment.id] = segment
+  return { nodes, stair }
+}
+
+describe('getStairTypeChange', () => {
+  it('materializes a flight when a segment-less stair becomes straight', () => {
+    const { nodes, stair } = buildScene()
+    const change = getStairTypeChange(stair, 'straight', nodes)
+
+    expect(change.updates.stairType).toBe('straight')
+    expect(change.segment?.type).toBe('stair-segment')
+    expect(change.segment?.segmentType).toBe('stair')
+    expect(change.segment?.width).toBe(0.9)
+    expect(change.segment?.stepCount).toBe(16)
+    expect(change.segment?.thickness).toBe(0.16)
+    expect(change.segment?.fillToFloor).toBe(false)
+    // Rise from the stair, run from the `StairSegmentNode` schema default.
+    expect(change.segment?.height).toBe(3.81)
+    expect(change.segment?.length).toBe(3)
+  })
+
+  it('follows the storey height when the stair has no explicit rise', () => {
+    const { nodes, stair } = buildScene({ totalRise: undefined })
+    const change = getStairTypeChange(stair, 'straight', nodes)
+
+    expect(change.segment?.height).toBe(3.5)
+  })
+
+  it('leaves an existing flight alone', () => {
+    const { nodes, stair } = buildScene({ stairType: 'curved' }, [2.5])
+    const change = getStairTypeChange(stair, 'straight', nodes)
+
+    expect(change.updates.stairType).toBe('straight')
+    expect(change.segment).toBeNull()
+  })
+
+  it('keeps the segments when a straight stair becomes curved', () => {
+    const { nodes, stair } = buildScene({ stairType: 'straight' }, [2.5])
+    const change = getStairTypeChange(stair, 'curved', nodes)
+
+    expect(change.updates).toEqual({ stairType: 'curved' })
+    expect(change.segment).toBeNull()
+    expect(nodes[STAIR_ID]).toBe(stair)
+  })
+
+  it('seeds the sweep and drops the Y offset when switching to spiral', () => {
+    const { nodes, stair } = buildScene()
+    const change = getStairTypeChange(stair, 'spiral', nodes)
+
+    expect(change.updates.stairType).toBe('spiral')
+    expect(change.updates.sweepAngle).toBeCloseTo((400 * Math.PI) / 180, 10)
+    expect(change.updates.position).toEqual([9.5, 0, -3.5])
+    expect(change.segment).toBeNull()
+  })
+})
diff --git a/packages/nodes/src/stair/stair-type.ts b/packages/nodes/src/stair/stair-type.ts
new file mode 100644
index 000000000..718fd8a81
--- /dev/null
+++ b/packages/nodes/src/stair/stair-type.ts
@@ -0,0 +1,47 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  createStairFlightFromStair,
+  type StairNode,
+  type StairSegmentNode,
+  type StairType,
+} from '@pascal-app/core'
+import { DEFAULT_SPIRAL_STAIR_SWEEP_ANGLE } from '@pascal-app/editor'
+
+export type StairTypeChange = {
+  updates: Partial<StairNode>
+  /** A flight to create under the stair, or null when the stair already has segments. */
+  segment: StairSegmentNode | null
+}
+
+/**
+ * Computes the stair patch for a type switch.
+ *
+ * Straight stairs are drawn from their `stair-segment` children while curved
+ * and spiral stairs are drawn parametrically from the stair's own fields, so a
+ * stair that reaches `straight` without segments has nothing to draw at all.
+ * Switching to straight therefore materializes the flight the stair already
+ * describes. Switching away keeps the segments — they simply go unused until
+ * the stair comes back, which makes the round trip lossless.
+ */
+export function getStairTypeChange(
+  stair: StairNode,
+  nextType: StairType,
+  nodes: Record<string, AnyNode>,
+): StairTypeChange {
+  const updates: Partial<StairNode> =
+    nextType === 'spiral' && stair.stairType !== 'spiral'
+      ? {
+          stairType: nextType,
+          sweepAngle: DEFAULT_SPIRAL_STAIR_SWEEP_ANGLE,
+          position: [stair.position[0], 0, stair.position[2]],
+        }
+      : { stairType: nextType }
+
+  if (nextType !== 'straight') return { updates, segment: null }
+
+  const hasSegment = (stair.children ?? []).some(
+    (childId) => nodes[childId as AnyNodeId]?.type === 'stair-segment',
+  )
+  return { updates, segment: hasSegment ? null : createStairFlightFromStair(stair, nodes) }
+}
diff --git a/packages/viewer/src/systems/stair/stair-system.tsx b/packages/viewer/src/systems/stair/stair-system.tsx
index e63b75fe1..ef3ab9abb 100644
--- a/packages/viewer/src/systems/stair/stair-system.tsx
+++ b/packages/viewer/src/systems/stair/stair-system.tsx
@@ -1,6 +1,7 @@
 import {
   type AnyNode,
   type AnyNodeId,
+  createStairFlightFromStair,
   getEffectiveNode,
   getFloorStackedPosition,
   type StairNode,
@@ -319,18 +320,20 @@ function updateMergedStairGeometry(
     .filter((n): n is StairSegmentNode => n?.type === 'stair-segment')
     .map((n) => getEffectiveNode(n))
 
-  if (segments.length === 0) {
-    replaceMeshGeometry(mergedMesh, createEmptyGeometry())
-    return
-  }
+  // A straight stair with no segments has nothing to merge and would render as
+  // nothing at all — the state a stair authored as curved lands in the moment
+  // it is switched to straight. Draw the flight its own fields describe
+  // instead of vanishing; it is the same flight the panel materializes.
+  const bodySegments =
+    segments.length > 0 ? segments : [createStairFlightFromStair(stairNode, nodes)]
 
   // Compute chained transforms for segments
-  const transforms = computeSegmentTransforms(segments)
+  const transforms = computeSegmentTransforms(bodySegments)
 
   const geometries: THREE.BufferGeometry[] = []
 
-  for (let i = 0; i < segments.length; i++) {
-    const segment = segments[i]!
+  for (let i = 0; i < bodySegments.length; i++) {
+    const segment = bodySegments[i]!
     const transform = transforms[i]!
 
     const absoluteHeight = transform.position[1]

From 558882ab9615df218a815aaceaa097738f30e2c6 Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Thu, 10 Sep 2026 09:44:10 -0400
Subject: [PATCH 22/27] feat(roof): wall-footprint roofs follow their source
 walls' tops

Room roofs computed their elevation once at creation, so a later custom
wall height left the roof at the storey plane. Roofs now remember their
source walls and a core system re-derives position[1] (highest top,
clamped to the level floor) on wall/slab/level edits, history-paused like
the stair rise sync. Moving the roof by hand detaches it.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 .../src/schema/nodes/roof-elevation.test.ts   |  27 +++
 packages/core/src/schema/nodes/roof.ts        |   2 +
 .../roof/roof-elevation-system.test.ts        | 163 ++++++++++++++++++
 .../systems/roof/roof-elevation-system.tsx    | 105 +++++++++++
 .../src/systems/roof/roof-elevation.test.ts   |  95 ++++++++++
 .../core/src/systems/roof/roof-elevation.ts   |  43 +++++
 packages/core/src/utils/clone-scene-graph.ts  |  13 ++
 packages/nodes/src/roof/conical-roof.ts       |  17 +-
 packages/nodes/src/roof/definition.ts         |   3 +-
 packages/nodes/src/roof/panel.tsx             |   2 +-
 packages/nodes/src/roof/roof-footprint.ts     |  37 +---
 packages/nodes/src/roof/tool.tsx              |   1 +
 .../viewer/src/components/viewer/index.tsx    |   2 +
 wiki/architecture/vertical-model.md           |   7 +-
 14 files changed, 470 insertions(+), 47 deletions(-)
 create mode 100644 packages/core/src/schema/nodes/roof-elevation.test.ts
 create mode 100644 packages/core/src/systems/roof/roof-elevation-system.test.ts
 create mode 100644 packages/core/src/systems/roof/roof-elevation-system.tsx
 create mode 100644 packages/core/src/systems/roof/roof-elevation.test.ts
 create mode 100644 packages/core/src/systems/roof/roof-elevation.ts

diff --git a/packages/core/src/schema/nodes/roof-elevation.test.ts b/packages/core/src/schema/nodes/roof-elevation.test.ts
new file mode 100644
index 000000000..eeb5a5ff4
--- /dev/null
+++ b/packages/core/src/schema/nodes/roof-elevation.test.ts
@@ -0,0 +1,27 @@
+import { expect, test } from 'bun:test'
+import { cloneLevelSubtree, cloneSceneGraph } from '../../utils/clone-scene-graph'
+import { LevelNode } from './level'
+import { RoofNode } from './roof'
+import { WallNode } from './wall'
+
+test('roof wall bindings are optional and survive JSON parsing', () => {
+  expect(RoofNode.parse({})).not.toHaveProperty('sourceWallIds')
+  const roof = RoofNode.parse({ sourceWallIds: ['wall_source'] })
+  expect(RoofNode.parse(JSON.parse(JSON.stringify(roof))).sourceWallIds).toEqual(['wall_source'])
+})
+
+test('scene and level clones remap roof source walls', () => {
+  const level = LevelNode.parse({})
+  const wall = WallNode.parse({ parentId: level.id, start: [0, 0], end: [4, 0] })
+  const roof = RoofNode.parse({ parentId: level.id, sourceWallIds: [wall.id] })
+  level.children = [wall.id, roof.id]
+  const nodes = Object.fromEntries([level, wall, roof].map((node) => [node.id, node]))
+  const whole = cloneSceneGraph({ nodes, rootNodeIds: [level.id] })
+  const levelClone = cloneLevelSubtree(nodes, level.id)
+  for (const clonedNodes of [Object.values(whole.nodes), levelClone.clonedNodes]) {
+    const clonedWall = clonedNodes.find((node) => node.type === 'wall')!
+    const clonedRoof = clonedNodes.find((node) => node.type === 'roof')!
+    expect(clonedRoof.sourceWallIds).toEqual([clonedWall.id])
+    expect(clonedWall.id).not.toBe(wall.id)
+  }
+})
diff --git a/packages/core/src/schema/nodes/roof.ts b/packages/core/src/schema/nodes/roof.ts
index cc2ed8491..0c182d9b4 100644
--- a/packages/core/src/schema/nodes/roof.ts
+++ b/packages/core/src/schema/nodes/roof.ts
@@ -40,6 +40,7 @@ export const RoofNode = BaseNode.extend({
   // Rotation around Y axis in radians
   rotation: z.number().default(0),
   support: RoofSupport,
+  sourceWallIds: z.array(z.templateLiteral(['wall_', z.string()])).optional(),
   // Child roof segment IDs
   children: z.array(RoofSegmentNode.shape.id).default([]),
 }).describe(
@@ -50,6 +51,7 @@ export const RoofNode = BaseNode.extend({
   - position: center position of the roof group
   - rotation: rotation around Y axis
   - support: level placement or an explicit roof-surface attachment
+  - sourceWallIds: follows the highest source wall top when present
   - children: array of RoofSegmentNode IDs
   `,
 )
diff --git a/packages/core/src/systems/roof/roof-elevation-system.test.ts b/packages/core/src/systems/roof/roof-elevation-system.test.ts
new file mode 100644
index 000000000..3eb400e3a
--- /dev/null
+++ b/packages/core/src/systems/roof/roof-elevation-system.test.ts
@@ -0,0 +1,163 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { spatialGridManager } from '../../hooks/spatial-grid/spatial-grid-manager'
+import { initSpatialGridSync } from '../../hooks/spatial-grid/spatial-grid-sync'
+import { type AnyNode, type AnyNodeId, LevelNode, RoofNode, SlabNode, WallNode } from '../../schema'
+import {
+  pauseSceneHistory,
+  resumeSceneHistory,
+  type SceneCommit,
+  subscribeSceneCommits,
+} from '../../store/history-control'
+import useScene, { clearSceneHistory } from '../../store/use-scene'
+import { initializeRoofElevationSync } from './roof-elevation-system'
+
+type RafFn = (callback: (time: number) => void) => number
+;(globalThis as unknown as { requestAnimationFrame?: RafFn }).requestAnimationFrame ??= (
+  callback,
+) => {
+  callback(0)
+  return 0
+}
+;(globalThis as unknown as { cancelAnimationFrame?: (id: number) => void }).cancelAnimationFrame ??=
+  () => {}
+
+const originalState = useScene.getState()
+let stopRoofSync = () => {}
+let stopGridSync = () => {}
+let stopCommitSubscription = () => {}
+
+beforeEach(() => {
+  spatialGridManager.clear()
+  useScene.setState({
+    nodes: {},
+    rootNodeIds: [],
+    dirtyNodes: new Set<AnyNodeId>(),
+    readOnly: false,
+  })
+  clearSceneHistory()
+})
+
+afterEach(() => {
+  stopRoofSync()
+  stopGridSync()
+  stopCommitSubscription()
+  spatialGridManager.clear()
+  useScene.setState(originalState)
+  clearSceneHistory()
+})
+
+function setup() {
+  const level = LevelNode.parse({ height: 2.5 })
+  const wall = WallNode.parse({ parentId: level.id, start: [0, 0], end: [4, 0], height: 3 })
+  const roof = RoofNode.parse({
+    parentId: level.id,
+    sourceWallIds: [wall.id],
+    position: [2, 3, 1],
+    rotation: 0.4,
+  })
+  const manual = RoofNode.parse({ parentId: level.id, position: [6, 7, 8] })
+  level.children = [wall.id, roof.id, manual.id]
+  useScene.setState({
+    nodes: Object.fromEntries([level, wall, roof, manual].map((node) => [node.id, node])) as Record<
+      AnyNodeId,
+      AnyNode
+    >,
+    rootNodeIds: [level.id],
+  })
+  clearSceneHistory()
+  stopRoofSync = initializeRoofElevationSync()
+  stopGridSync = initSpatialGridSync()
+  return { level, wall, roof, manual }
+}
+
+function currentRoof(id: RoofNode['id']): RoofNode {
+  return useScene.getState().nodes[id] as RoofNode
+}
+
+describe('RoofElevationSystem', () => {
+  test('a wall height edit moves the roof after one microtask without adding an undo step', async () => {
+    const { wall, roof, manual } = setup()
+    await Promise.resolve()
+    const commits: SceneCommit[] = []
+    stopCommitSubscription = subscribeSceneCommits((commit) => commits.push(commit))
+    useScene.getState().updateNode(wall.id, { height: 4.2 })
+    expect(currentRoof(roof.id).position).toEqual([2, 3, 1])
+    await Promise.resolve()
+    expect(currentRoof(roof.id).position).toEqual([2, 4.2, 1])
+    expect(currentRoof(roof.id).rotation).toBe(0.4)
+    expect(currentRoof(manual.id).position).toEqual([6, 7, 8])
+    expect(useScene.temporal.getState().pastStates).toHaveLength(1)
+    expect(commits).toHaveLength(2)
+    expect((commits[1]?.before.nodes[roof.id] as RoofNode).position[1]).toBe(3)
+    expect((commits[1]?.current.nodes[roof.id] as RoofNode).position[1]).toBe(4.2)
+    expect(commits[1]?.changedNodeIds).toEqual(new Set([roof.id]))
+    useScene.temporal.getState().undo()
+    await Promise.resolve()
+    expect(currentRoof(roof.id).position[1]).toBe(3)
+    useScene.temporal.getState().redo()
+    await Promise.resolve()
+    expect(currentRoof(roof.id).position[1]).toBe(4.2)
+  })
+
+  test('does not publish previews owned by an outer history pause', async () => {
+    const { wall, roof } = setup()
+    await Promise.resolve()
+    const commits: SceneCommit[] = []
+    stopCommitSubscription = subscribeSceneCommits((commit) => commits.push(commit))
+    pauseSceneHistory(useScene)
+    try {
+      useScene.getState().updateNode(wall.id, { height: 4 })
+      await Promise.resolve()
+      expect(currentRoof(roof.id).position[1]).toBe(4)
+      expect(useScene.temporal.getState().isTracking).toBe(false)
+      expect(commits).toHaveLength(0)
+    } finally {
+      resumeSceneHistory(useScene)
+    }
+  })
+
+  test('waits for the slab grid listener and tracks subsequent slab elevation edits', async () => {
+    const { level, roof } = setup()
+    const slab = SlabNode.parse({
+      elevation: 0.5,
+      polygon: [
+        [-1, -1],
+        [5, -1],
+        [5, 2],
+        [-1, 2],
+      ],
+    })
+    useScene.getState().createNode(slab, level.id)
+    await Promise.resolve()
+    expect(currentRoof(roof.id).position[1]).toBe(3.5)
+    useScene.getState().updateNode(slab.id, { elevation: 0.9 })
+    await Promise.resolve()
+    expect(currentRoof(roof.id).position[1]).toBe(3.9)
+  })
+
+  test('keeps a manual Y edit after its wall binding is removed', async () => {
+    const { wall, roof } = setup()
+    await Promise.resolve()
+    useScene.getState().updateNode(roof.id, { sourceWallIds: undefined, position: [2, 9, 1] })
+    useScene.getState().updateNode(wall.id, { height: 5 })
+    await Promise.resolve()
+    expect(currentRoof(roof.id).position[1]).toBe(9)
+    expect(currentRoof(roof.id)).not.toHaveProperty('sourceWallIds')
+  })
+
+  test('coalesces rapid edits, ignores epsilon drift and cancels queued work on disposal', async () => {
+    const { wall, roof } = setup()
+    await Promise.resolve()
+    useScene.getState().updateNode(wall.id, { height: 3.00001 })
+    await Promise.resolve()
+    expect(currentRoof(roof.id).position[1]).toBe(3)
+    useScene.getState().updateNode(wall.id, { height: 4 })
+    useScene.getState().updateNode(wall.id, { height: 5 })
+    await Promise.resolve()
+    expect(currentRoof(roof.id).position[1]).toBe(5)
+    useScene.getState().updateNode(wall.id, { height: 6 })
+    stopRoofSync()
+    await Promise.resolve()
+    expect(currentRoof(roof.id).position[1]).toBe(5)
+  })
+})
diff --git a/packages/core/src/systems/roof/roof-elevation-system.tsx b/packages/core/src/systems/roof/roof-elevation-system.tsx
new file mode 100644
index 000000000..19865441b
--- /dev/null
+++ b/packages/core/src/systems/roof/roof-elevation-system.tsx
@@ -0,0 +1,105 @@
+'use client'
+
+import { useEffect } from 'react'
+import type { AnyNode, AnyNodeId } from '../../schema'
+import {
+  getSceneHistoryPauseDepth,
+  notifySceneCommit,
+  pauseSceneHistory,
+  resumeSceneHistory,
+  type SceneSnapshot,
+} from '../../store/history-control'
+import useScene from '../../store/use-scene'
+import { resolveRoofElevation } from './roof-elevation'
+
+const ROOF_ELEVATION_EPSILON = 1e-4
+
+function sceneSnapshot(): SceneSnapshot {
+  const { nodes, rootNodeIds, collections, materials, installedPlugins } = useScene.getState()
+  return { nodes, rootNodeIds, collections, materials, installedPlugins }
+}
+
+function isElevationRelevant(node: AnyNode | undefined): boolean {
+  return (
+    node?.type === 'roof' ||
+    node?.type === 'wall' ||
+    node?.type === 'slab' ||
+    node?.type === 'level' ||
+    node?.type === 'building' ||
+    node?.type === 'site'
+  )
+}
+
+export function initializeRoofElevationSync(): () => void {
+  let disposed = false
+  let queued = false
+  let syncing = false
+
+  const schedule = () => {
+    if (queued) return
+    queued = true
+    // Wall bases use the spatial grid, whose listener must finish before this pass.
+    queueMicrotask(() => {
+      queued = false
+      if (disposed) return
+      const { nodes, updateNodes, readOnly } = useScene.getState()
+      if (readOnly) return
+      const updates: Array<{ id: AnyNodeId; data: Partial<AnyNode> }> = []
+      for (const node of Object.values(nodes)) {
+        if (node.type !== 'roof') continue
+        const elevation = resolveRoofElevation(node, nodes)
+        if (Math.abs(node.position[1] - elevation) <= ROOF_ELEVATION_EPSILON) continue
+        updates.push({
+          id: node.id,
+          data: { position: [node.position[0], elevation, node.position[2]] },
+        })
+      }
+      if (updates.length === 0) return
+      const before = sceneSnapshot()
+      const publishCommit =
+        useScene.temporal.getState().isTracking && getSceneHistoryPauseDepth() === 0
+      syncing = true
+      pauseSceneHistory(useScene)
+      try {
+        updateNodes(updates)
+      } finally {
+        resumeSceneHistory(useScene)
+        syncing = false
+      }
+      // Deferred writes miss the originating commit; publish the settled roof without
+      // another undo step. An outer pause belongs to a gesture that owns its commit.
+      if (publishCommit) {
+        notifySceneCommit({
+          origin: 'local',
+          before,
+          current: sceneSnapshot(),
+          changedNodeIds: new Set(updates.map(({ id }) => id)),
+        })
+      }
+    })
+  }
+
+  const unsubscribe = useScene.subscribe((state, previous) => {
+    if (syncing || state.nodes === previous.nodes) return
+    const ids = new Set([...Object.keys(state.nodes), ...Object.keys(previous.nodes)])
+    for (const id of ids) {
+      const next = state.nodes[id as AnyNodeId]
+      const prev = previous.nodes[id as AnyNodeId]
+      if (next !== prev && (isElevationRelevant(next) || isElevationRelevant(prev))) {
+        schedule()
+        return
+      }
+    }
+  })
+  schedule()
+
+  return () => {
+    disposed = true
+    unsubscribe()
+  }
+}
+
+export function RoofElevationSystem() {
+  useEffect(initializeRoofElevationSync, [])
+  return null
+}
diff --git a/packages/core/src/systems/roof/roof-elevation.test.ts b/packages/core/src/systems/roof/roof-elevation.test.ts
new file mode 100644
index 000000000..caf69526a
--- /dev/null
+++ b/packages/core/src/systems/roof/roof-elevation.test.ts
@@ -0,0 +1,95 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { spatialGridManager } from '../../hooks/spatial-grid/spatial-grid-manager'
+import { type AnyNode, LevelNode, RoofNode, SlabNode, WallNode } from '../../schema'
+import { resolveRoofElevation } from './roof-elevation'
+
+beforeEach(() => spatialGridManager.clear())
+afterEach(() => spatialGridManager.clear())
+
+function scene(heights: Array<number | undefined>) {
+  const level = LevelNode.parse({ id: 'level_roof_source', height: 2.5, level: 0 })
+  const upper = LevelNode.parse({ id: 'level_roof_target', height: 3, level: 1 })
+  const walls = heights.map((height, index) =>
+    WallNode.parse({
+      parentId: level.id,
+      start: [0, index],
+      end: [4, index],
+      height,
+    }),
+  )
+  const roof = RoofNode.parse({
+    parentId: upper.id,
+    sourceWallIds: walls.map((wall) => wall.id),
+    position: [2, 0, 1],
+  })
+  const nodes: Record<string, AnyNode> = Object.fromEntries(
+    [level, upper, roof, ...walls].map((node) => [node.id, node]),
+  )
+  return { level, upper, walls, roof, nodes }
+}
+
+describe('resolveRoofElevation', () => {
+  test('honors an explicit height above the storey and converts to the roof level frame', () => {
+    const { roof, nodes } = scene([4])
+    expect(resolveRoofElevation(roof, nodes)).toBe(1.5)
+  })
+
+  test('takes the highest top across mixed explicit and plane-bound walls', () => {
+    const { roof, nodes } = scene([3, undefined, 4.5, 2])
+    expect(resolveRoofElevation(roof, nodes)).toBe(2)
+  })
+
+  test('includes the elected slab base and wall support offset', () => {
+    const { level, walls, roof, nodes } = scene([4])
+    const slab = SlabNode.parse({
+      parentId: level.id,
+      elevation: 0.8,
+      polygon: [
+        [-1, -1],
+        [5, -1],
+        [5, 2],
+        [-1, 2],
+      ],
+    })
+    spatialGridManager.handleNodeCreated(slab, level.id)
+    const wall = { ...walls[0]!, supportSlabId: slab.id, supportOffset: 0.2 }
+    expect(resolveRoofElevation(roof, { ...nodes, [wall.id]: wall, [slab.id]: slab })).toBe(2.5)
+  })
+
+  test('does not lift a plane-bound top when its base rises', () => {
+    const { walls, roof, nodes } = scene([undefined])
+    const wall = { ...walls[0]!, supportOffset: 0.6 }
+    expect(resolveRoofElevation(roof, { ...nodes, [wall.id]: wall })).toBe(0)
+  })
+
+  test('clamps tops below the roof level plane to the floor', () => {
+    const { roof, nodes } = scene([2])
+    expect(resolveRoofElevation(roof, nodes)).toBe(0)
+  })
+
+  test('preserves manual Y without a footprint or after all sources disappear', () => {
+    const { roof, nodes } = scene([4])
+    expect(resolveRoofElevation({ ...roof, sourceWallIds: undefined }, nodes)).toBe(0)
+    expect(resolveRoofElevation({ ...roof, sourceWallIds: ['wall_deleted'] }, nodes)).toBe(0)
+    expect(resolveRoofElevation({ ...roof, sourceWallIds: [] }, nodes)).toBe(0)
+  })
+
+  test('ignores missing walls while retaining surviving sources', () => {
+    const { roof, nodes } = scene([4])
+    expect(
+      resolveRoofElevation(
+        { ...roof, sourceWallIds: ['wall_deleted', ...roof.sourceWallIds!] },
+        nodes,
+      ),
+    ).toBe(1.5)
+  })
+
+  test('leaves roof-surface attachments to their own support rule', () => {
+    const { roof, nodes } = scene([4])
+    const attached = RoofNode.parse({
+      ...roof,
+      support: { kind: 'roof', roofSegmentId: 'rseg_host', localPosition: [0, 0] },
+    })
+    expect(resolveRoofElevation(attached, nodes)).toBe(0)
+  })
+})
diff --git a/packages/core/src/systems/roof/roof-elevation.ts b/packages/core/src/systems/roof/roof-elevation.ts
new file mode 100644
index 000000000..1daedcc0e
--- /dev/null
+++ b/packages/core/src/systems/roof/roof-elevation.ts
@@ -0,0 +1,43 @@
+import {
+  getWallBaseElevationForNodes,
+  getWallEffectiveHeightForNodes,
+} from '../../hooks/spatial-grid/spatial-grid-manager'
+import { resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync'
+import type { AnyNode, LevelNode, RoofNode, WallNode } from '../../schema'
+import { getLevelElevations } from '../../services/storey'
+
+export function resolveRoofWallTopElevation(
+  targetLevelId: LevelNode['id'],
+  wall: WallNode,
+  nodes: Readonly<Record<string, AnyNode>>,
+  elevations = getLevelElevations(nodes),
+): number {
+  const sourceLevelY = elevations.get(resolveLevelId(wall, nodes))?.baseY ?? 0
+  const targetLevelY = elevations.get(targetLevelId)?.baseY ?? 0
+  return (
+    sourceLevelY +
+    getWallBaseElevationForNodes(wall, nodes) +
+    getWallEffectiveHeightForNodes(wall, nodes) -
+    targetLevelY
+  )
+}
+
+export function resolveRoofElevation(
+  roof: RoofNode,
+  nodes: Readonly<Record<string, AnyNode>>,
+): number {
+  if (!roof.sourceWallIds?.length || roof.support?.kind === 'roof') return roof.position[1]
+  const levelId = resolveLevelId(roof, nodes)
+  if (nodes[levelId]?.type !== 'level') return roof.position[1]
+  const elevations = getLevelElevations(nodes)
+  let highest: number | undefined
+  for (const id of roof.sourceWallIds) {
+    const wall = nodes[id]
+    if (wall?.type !== 'wall' || nodes[resolveLevelId(wall, nodes)]?.type !== 'level') continue
+    const top = resolveRoofWallTopElevation(levelId as LevelNode['id'], wall, nodes, elevations)
+    highest = highest === undefined ? top : Math.max(highest, top)
+  }
+  // A roof never sinks below its own level's floor plane; a lower-floor wall
+  // top is clamped there, as the creation paths always did.
+  return highest === undefined ? roof.position[1] : Math.max(0, highest)
+}
diff --git a/packages/core/src/utils/clone-scene-graph.ts b/packages/core/src/utils/clone-scene-graph.ts
index 2bee88931..ddaa9d8cf 100644
--- a/packages/core/src/utils/clone-scene-graph.ts
+++ b/packages/core/src/utils/clone-scene-graph.ts
@@ -108,6 +108,13 @@ export function cloneSceneGraph(sceneGraph: SceneGraph): SceneGraph {
         clonedNode.support.roofSegmentId) as typeof clonedNode.support.roofSegmentId
     }
 
+    if (clonedNode.type === 'roof' && clonedNode.sourceWallIds) {
+      clonedNode.sourceWallIds = clonedNode.sourceWallIds.flatMap((id) => {
+        const mapped = idMap.get(id)
+        return mapped ? [mapped as `wall_${string}`] : []
+      })
+    }
+
     // Remap supportSlabId (persisted slab-support hosts). The 'ground'
     // sentinel is not a node id — keep it as-is.
     if (
@@ -304,6 +311,12 @@ export function cloneLevelSubtree(
         cloned.support.roofSegmentId) as typeof cloned.support.roofSegmentId
     }
 
+    if (cloned.type === 'roof' && cloned.sourceWallIds) {
+      cloned.sourceWallIds = cloned.sourceWallIds.map(
+        (id) => (idMap.get(id) ?? id) as `wall_${string}`,
+      )
+    }
+
     // Remap supportSlabId when the host slab is inside the cloned subtree;
     // preserve it otherwise (like wallId, the reference may point outside).
     if ('supportSlabId' in cloned && typeof cloned.supportSlabId === 'string') {
diff --git a/packages/nodes/src/roof/conical-roof.ts b/packages/nodes/src/roof/conical-roof.ts
index 3b13037f3..3ea7cd22e 100644
--- a/packages/nodes/src/roof/conical-roof.ts
+++ b/packages/nodes/src/roof/conical-roof.ts
@@ -2,14 +2,12 @@ import {
   type AnyNode,
   type AnyNodeId,
   getLevelBelow,
-  getLevelElevations,
   getWallArcData,
-  getWallBaseElevationForNodes,
-  getWallEffectiveHeightForNodes,
   type LevelNode,
   RoofNode,
   RoofSegmentNode,
   resolveLevelId,
+  resolveRoofWallTopElevation,
   type SceneApi,
   type WallNode,
 } from '@pascal-app/core'
@@ -45,10 +43,6 @@ export function createConicalRoofSectorAboveWall(
     if (existingSegment) return existingSegment.id
   }
 
-  const elevations = getLevelElevations(completeNodes)
-  const sourceLevelY = elevations.get(resolveLevelId(wall, completeNodes))?.baseY ?? 0
-  const targetLevelY = elevations.get(targetLevelId)?.baseY ?? 0
-
   const roofCount = Object.values(nodes).filter((node) => node?.type === 'roof').length
   const segment = RoofSegmentNode.parse({
     roofType: 'conical',
@@ -63,15 +57,10 @@ export function createConicalRoofSectorAboveWall(
   const roof = RoofNode.parse({
     name: `Roof ${roofCount + 1}`,
     metadata: { conicalSourceWallId: wall.id },
+    sourceWallIds: [wall.id],
     position: [
       arc.center.x,
-      Math.max(
-        0,
-        sourceLevelY +
-          getWallBaseElevationForNodes(wall, completeNodes) +
-          getWallEffectiveHeightForNodes(wall, completeNodes) -
-          targetLevelY,
-      ),
+      Math.max(0, resolveRoofWallTopElevation(targetLevelId, wall, nodes)),
       arc.center.y,
     ],
     children: [segment.id],
diff --git a/packages/nodes/src/roof/definition.ts b/packages/nodes/src/roof/definition.ts
index 315d35299..44d5ee63d 100644
--- a/packages/nodes/src/roof/definition.ts
+++ b/packages/nodes/src/roof/definition.ts
@@ -107,7 +107,7 @@ export const roofDefinition: NodeDefinition<typeof RoofNode> = {
   // Drafted as a 2-corner footprint (axis-aligned bbox), not a directional
   // edge → no angle-lock mode (grid / lines / off only).
   snapDraftDirectional: false,
-  schemaVersion: 2,
+  schemaVersion: 3,
   schema: RoofNode,
   category: 'structure',
   surfaceRole: 'roof',
@@ -124,6 +124,7 @@ export const roofDefinition: NodeDefinition<typeof RoofNode> = {
   },
 
   capabilities: {
+    hostRefFields: ['sourceWallIds'],
     selectable: { hitVolume: 'bbox' },
     duplicable: true,
     deletable: true,
diff --git a/packages/nodes/src/roof/panel.tsx b/packages/nodes/src/roof/panel.tsx
index ac07a728d..0a19bebf1 100644
--- a/packages/nodes/src/roof/panel.tsx
+++ b/packages/nodes/src/roof/panel.tsx
@@ -288,7 +288,7 @@ export default function RoofPanel() {
           onChange={(v) => {
             const pos = [...node.position] as [number, number, number]
             pos[1] = v
-            handleUpdate({ position: pos })
+            handleUpdate({ position: pos, sourceWallIds: undefined })
           }}
           precision={2}
           step={0.05}
diff --git a/packages/nodes/src/roof/roof-footprint.ts b/packages/nodes/src/roof/roof-footprint.ts
index 13fadbd85..439a87348 100644
--- a/packages/nodes/src/roof/roof-footprint.ts
+++ b/packages/nodes/src/roof/roof-footprint.ts
@@ -4,13 +4,12 @@ import {
   emitter,
   getLevelBelow,
   getLevelElevations,
-  getWallBaseElevationForNodes,
-  getWallEffectiveHeightForNodes,
   isCurvedWall,
   type LevelNode,
   pointInPolygon2D,
   type RoofType,
   resolveLevelId,
+  resolveRoofWallTopElevation,
   type WallEvent,
   type WallNode,
 } from '@pascal-app/core'
@@ -198,15 +197,13 @@ export function resolveRoofFootprintElevation(
 ): number {
   const completeNodes = nodes as Record<string, AnyNode>
   const elevations = getLevelElevations(completeNodes)
-  return Math.max(
-    0,
-    ...target.wallIds.map((id) => {
-      const wall = nodes[id]
-      return wall?.type === 'wall'
-        ? resolveRoofWallTopElevation(targetLevelId, wall, completeNodes, elevations)
-        : 0
-    }),
-  )
+  const tops = target.wallIds.flatMap((id) => {
+    const wall = nodes[id]
+    return wall?.type === 'wall'
+      ? [resolveRoofWallTopElevation(targetLevelId, wall, completeNodes, elevations)]
+      : []
+  })
+  return tops.length ? Math.max(0, ...tops) : 0
 }
 
 export function resolveRoofFootprintWorldElevation(
@@ -222,24 +219,6 @@ export function resolveRoofFootprintWorldElevation(
   )
 }
 
-export function resolveRoofWallTopElevation(
-  targetLevelId: LevelNode['id'],
-  wall: WallNode,
-  nodes: Readonly<Record<string, AnyNode>>,
-  elevations = getLevelElevations(nodes as Record<string, AnyNode>),
-): number {
-  const completeNodes = nodes as Record<string, AnyNode>
-  const sourceLevelY = elevations.get(resolveLevelId(wall, completeNodes))?.baseY ?? 0
-  const targetLevelY = elevations.get(targetLevelId)?.baseY ?? 0
-  return Math.max(
-    0,
-    sourceLevelY +
-      getWallBaseElevationForNodes(wall, completeNodes) +
-      getWallEffectiveHeightForNodes(wall, completeNodes) -
-      targetLevelY,
-  )
-}
-
 /**
  * World/building-local Y for a wall-top preview rendered outside a level node.
  *
diff --git a/packages/nodes/src/roof/tool.tsx b/packages/nodes/src/roof/tool.tsx
index 323ff1ca3..b020e59ae 100644
--- a/packages/nodes/src/roof/tool.tsx
+++ b/packages/nodes/src/roof/tool.tsx
@@ -382,6 +382,7 @@ const commitRoofFootprint = (
       target.center[1],
     ],
     rotation: target.rotation,
+    sourceWallIds: target.wallIds,
     children: [segment.id],
   })
   createRoofNodes(sceneApi, [
diff --git a/packages/viewer/src/components/viewer/index.tsx b/packages/viewer/src/components/viewer/index.tsx
index 6dd57a272..f6b348938 100644
--- a/packages/viewer/src/components/viewer/index.tsx
+++ b/packages/viewer/src/components/viewer/index.tsx
@@ -3,6 +3,7 @@
 import {
   type AnyNodeId,
   nodeRegistry,
+  RoofElevationSystem,
   StairOpeningSystem,
   sceneRegistry,
   useScene,
@@ -625,6 +626,7 @@ const Viewer = forwardRef<ViewerHandle, ViewerProps>(function Viewer(
           {/* Automated stair opening sync — updates slab/ceiling cutouts
             whenever stairs, slabs, or levels change. */}
           <StairOpeningSystem />
+          <RoofElevationSystem />
           {/* Mounts systems contributed by registry-backed kinds. Each
             kind's `def.system` is loaded via lazy() and rendered here,
             ordered by `system.priority`. */}
diff --git a/wiki/architecture/vertical-model.md b/wiki/architecture/vertical-model.md
index fd7c66fee..91cc7be78 100644
--- a/wiki/architecture/vertical-model.md
+++ b/wiki/architecture/vertical-model.md
@@ -2,7 +2,7 @@
 
 *How buildings stack: stored level heights, plane-bound wall/ceiling tops, slab placement + thickness, support hosts, and the clamp rules that keep it all coherent.*
 
-Applies to: anything that reads or writes vertical geometry — levels, walls, slabs, ceilings, stairs, fences, floor-placed items.
+Applies to: anything that reads or writes vertical geometry — levels, walls, slabs, ceilings, roofs, stairs, fences, floor-placed items.
 
 The invariant, in one sentence:
 
@@ -21,6 +21,7 @@ The invariant, in one sentence:
 | `level.baseElevation` | Additive offset from the computed stack position. It shifts this level and cumulatively shifts every higher level in the same building; negative offsets are valid. | Zero (the schema default). |
 | `wall.height` | Explicit body height (half wall, parapet, or a raised-support draft whose ghost height must remain invariant). Ground-hosted walls always resolve top = elected base + height, including below datum; other legacy sunken supports retain their absolute-top constraint. | **Plane-bound** (the default for ordinary datum placement): the top follows `getWallPlaneTop` — `min(level height, lowest covering-slab underside over the span)`. |
 | `ceiling.height` | Explicit custom height, write-clamped to the bound. | **Follows the level**: resolves live to `getCeilingClampBound` = `min(level height, covering underside) − 0.01`. |
+| `roof.sourceWallIds` | Wall footprint whose highest resolved top drives `roof.position[1]` in the roof's level frame. Room and curved-wall creation persist these IDs. | Manual Y; existing roofs without recorded source walls remain unchanged. Editing Y in the roof panel removes this binding. Roof-surface attachments use `support` instead. |
 | `slab.elevation` | The walking surface (top), level-local. | Default 0.05. |
 | `slab.thickness` | Grows **downward**: the solid occupies `[elevation − thickness, elevation]`. | Default 0.05. |
 | `slab.recessed` | Recess intent: open shell whose floor is `elevation` and whose rim is `recessedRimElevation`. Excluded from "covering" queries and wall-face adoption. | Solid slab. |
@@ -35,7 +36,7 @@ The invariant, in one sentence:
 
 Two schema rules protect these semantics:
 
-- **No Zod defaults on meaning-bearing fields.** `level.height`, `wall.height`, `ceiling.height`, `stair.totalRise` are `.optional()` with no `.default()` — absence is data. Creation sites write values explicitly; `migrateNodes` output is cast, not parsed, so a schema default would never materialize on legacy load anyway.
+- **No Zod defaults on meaning-bearing fields.** `level.height`, `wall.height`, `ceiling.height`, `roof.sourceWallIds`, `stair.totalRise` are `.optional()` with no `.default()` — absence is data. Creation sites write values explicitly; `migrateNodes` output is cast, not parsed, so a schema default would never materialize on legacy load anyway.
 - **The store deletes explicit-`undefined` keys.** `updateNode(id, { height: undefined })` removes the key (see `mergeNodeUpdate` in `node-actions.ts`). Legacy plane-bound walls may still omit `height`; the wall panel resolves and materializes their current body height before enabling terrain infill. Ceiling and stair follow modes continue to derive from field presence — no persisted mode enums.
 
 ## Resolution helpers (use these, never `?? 2.5`)
@@ -49,6 +50,7 @@ Two schema rules protect these semantics:
 | `getCeilingClampBound`, `getCoveringSlabUndersideAt` | `services/storey.ts` | Ceiling bound; the cross-level covering query (level above, non-recessed slabs) |
 | `resolveCeilingHeight` | `services/level-height.ts` | A ceiling's effective height (explicit or follows) |
 | `resolveStairTotalRise`, `syncStairRises` | `systems/stair/stair-rise.ts` | Stair rise precedence + straight-flight convergence |
+| `resolveRoofElevation`, `resolveRoofWallTopElevation` | `systems/roof/roof-elevation.ts` | Highest source-wall top, including explicit heights and elected bases, converted to the roof's level frame |
 | `computeWallSlabSupport`, `getSlabSupportForItem`, `getSupportCandidatesForFootprint` | `systems/slab/slab-support.ts` + spatial-grid manager | Support election (rendered polygons, host-preferring, optional `maxElevation` cap) |
 | `resolveSlabPlacementElevation` | `systems/slab/slab-placement.ts` | Translates a solid slab's authored top/thickness interval onto a captured base plane; recessed slabs stay level-relative |
 | `getSlabBaseElevation`, `applySlabBaseElevationChange`, `applySlabThicknessChange` | `nodes/slab/elevation-limit.ts` | Separates whole-body underside placement from fixed-base thickness editing |
@@ -134,6 +136,7 @@ Because community autosave only persists after the first post-load edit, the mig
 
 ## Gotchas
 
+- **Wall-footprint roofs track their source walls.** `RoofElevationSystem` re-derives Y on wall, slab, level, building, site, and roof edits, history-paused and one microtask after store updates so the spatial grid has settled. Because the originating commit has already been captured, settled updates publish a separate scene commit without adding an undo step; an outer gesture's history pause retains commit ownership. The system preserves XZ and rotation; missing source walls are ignored, and losing every source preserves the last Y. Negative level-local Y is valid when the wall tops lie below the roof's containing level. Clone paths must remap `sourceWallIds` with the walls; preset storage strips them through `hostRefFields`.
 - **Ordinals are semantic.** `level < 0` renders "Basement N"; `level === 0` is the ground-floor lookup. Never renumber without the zero anchor.
 - **Boundary geometry.** Auto slabs derive polygons from wall centerlines, so wall/ceiling clamp samples sit exactly on polygon edges — always use the boundary-inclusive band-overlap helpers (`wallOverlapsSlabFootprint`, `slabCoversPoint`), never raw ray-cast point-in-polygon on those paths.
 - **Straight stairs build from stored segment heights**, not the resolved rise — any rise change must go through `syncStairRises` (applied by `StairOpeningSystem`, history-paused, one microtask after store updates so the spatial grid has settled).

From 55bf556e6b4dae15658ba9ff55682f26d86c3059 Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Thu, 10 Sep 2026 10:02:33 -0400
Subject: [PATCH 23/27] fix(stair): a flight height edit pins the parent stair
 to the new total rise

On a follows-level stair the sync handed the edited height straight back,
so the segment slider did nothing. The edit now also writes totalRise
(the stair becomes Custom rise, as editing Rise on its own panel does).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 packages/nodes/src/stair-segment/panel.tsx | 39 +++++++++++++++++++++-
 1 file changed, 38 insertions(+), 1 deletion(-)

diff --git a/packages/nodes/src/stair-segment/panel.tsx b/packages/nodes/src/stair-segment/panel.tsx
index 698216d33..9bae5e859 100644
--- a/packages/nodes/src/stair-segment/panel.tsx
+++ b/packages/nodes/src/stair-segment/panel.tsx
@@ -6,6 +6,7 @@ import {
   type AttachmentSide,
   DEFAULT_LEVEL_HEIGHT,
   resolveStairTotalRise,
+  runAsSingleSceneHistoryStep,
   type StairSegmentNode,
   StairSegmentNode as StairSegmentNodeSchema,
   type StairSegmentType,
@@ -69,6 +70,37 @@ export default function StairSegmentPanel() {
     setSelection({ selectedIds: [] })
   }, [setSelection])
 
+  // A follows-level stair would hand the edited height straight back to
+  // `syncStairRises`, so a flight edit also pins the parent to the new total:
+  // the stair becomes Custom rise, exactly as editing Rise on its own panel.
+  const parentFollowsLevel = useScene((s) => {
+    const parent = node?.parentId ? s.nodes[node.parentId as AnyNodeId] : undefined
+    return parent?.type === 'stair' && parent.totalRise == null
+  })
+  const handleFlightHeightChange = useCallback(
+    (height: number) => {
+      if (!node) return
+      const sceneNodes = useScene.getState().nodes
+      const parent = node.parentId ? sceneNodes[node.parentId as AnyNodeId] : undefined
+      if (parent?.type !== 'stair') {
+        handleUpdate({ height })
+        return
+      }
+      const totalRise = parent.children.reduce((sum, childId) => {
+        const child = sceneNodes[childId as AnyNodeId]
+        if (child?.type !== 'stair-segment') return sum
+        return sum + (child.id === node.id ? height : child.height)
+      }, 0)
+      runAsSingleSceneHistoryStep(useScene, () => {
+        useScene.getState().updateNodes([
+          { id: node.id as AnyNodeId, data: { height } },
+          { id: parent.id as AnyNodeId, data: { totalRise } },
+        ])
+      })
+    },
+    [node, handleUpdate],
+  )
+
   // Turning a landing back into a flight seeds the rise the parent stair
   // resolves — a fixed 2.5 m stops halfway up a tall storey, and for a
   // follows-mode stair it is what `syncStairRises` would converge to anyway.
@@ -197,12 +229,17 @@ export default function StairSegmentPanel() {
               label="Height"
               max={1000}
               min={0.5}
-              onChange={(v) => handleUpdate({ height: v })}
+              onChange={handleFlightHeightChange}
               precision={2}
               step={0.1}
               unit="m"
               value={Math.round(node.height * 100) / 100}
             />
+            {parentFollowsLevel && (
+              <div className="px-1 text-[11px] text-muted-foreground">
+                Editing switches the stair to Custom rise
+              </div>
+            )}
             <SliderControl
               label="Steps"
               max={30}

From 0af754db53238b76ef6ab9512a4d4b86659b4565 Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Thu, 10 Sep 2026 10:02:33 -0400
Subject: [PATCH 24/27] fix(roof): follow wall tops below the storey plane

Walls shorter than the level (2.5 m in a 3 m storey) left a gap because
the roof elevation was clamped to its level floor. Follow the wall top.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 packages/core/src/systems/roof/roof-elevation.test.ts | 4 ++--
 packages/core/src/systems/roof/roof-elevation.ts      | 4 +---
 packages/nodes/src/roof/conical-roof.ts               | 6 +-----
 packages/nodes/src/roof/roof-footprint.ts             | 2 +-
 packages/nodes/src/wall/definition.test.ts            | 4 ++--
 5 files changed, 7 insertions(+), 13 deletions(-)

diff --git a/packages/core/src/systems/roof/roof-elevation.test.ts b/packages/core/src/systems/roof/roof-elevation.test.ts
index caf69526a..5b0c1a64f 100644
--- a/packages/core/src/systems/roof/roof-elevation.test.ts
+++ b/packages/core/src/systems/roof/roof-elevation.test.ts
@@ -62,9 +62,9 @@ describe('resolveRoofElevation', () => {
     expect(resolveRoofElevation(roof, { ...nodes, [wall.id]: wall })).toBe(0)
   })
 
-  test('clamps tops below the roof level plane to the floor', () => {
+  test('follows tops below the roof level plane so short walls leave no gap', () => {
     const { roof, nodes } = scene([2])
-    expect(resolveRoofElevation(roof, nodes)).toBe(0)
+    expect(resolveRoofElevation(roof, nodes)).toBe(-0.5)
   })
 
   test('preserves manual Y without a footprint or after all sources disappear', () => {
diff --git a/packages/core/src/systems/roof/roof-elevation.ts b/packages/core/src/systems/roof/roof-elevation.ts
index 1daedcc0e..f891f2a93 100644
--- a/packages/core/src/systems/roof/roof-elevation.ts
+++ b/packages/core/src/systems/roof/roof-elevation.ts
@@ -37,7 +37,5 @@ export function resolveRoofElevation(
     const top = resolveRoofWallTopElevation(levelId as LevelNode['id'], wall, nodes, elevations)
     highest = highest === undefined ? top : Math.max(highest, top)
   }
-  // A roof never sinks below its own level's floor plane; a lower-floor wall
-  // top is clamped there, as the creation paths always did.
-  return highest === undefined ? roof.position[1] : Math.max(0, highest)
+  return highest ?? roof.position[1]
 }
diff --git a/packages/nodes/src/roof/conical-roof.ts b/packages/nodes/src/roof/conical-roof.ts
index 3ea7cd22e..459903017 100644
--- a/packages/nodes/src/roof/conical-roof.ts
+++ b/packages/nodes/src/roof/conical-roof.ts
@@ -58,11 +58,7 @@ export function createConicalRoofSectorAboveWall(
     name: `Roof ${roofCount + 1}`,
     metadata: { conicalSourceWallId: wall.id },
     sourceWallIds: [wall.id],
-    position: [
-      arc.center.x,
-      Math.max(0, resolveRoofWallTopElevation(targetLevelId, wall, nodes)),
-      arc.center.y,
-    ],
+    position: [arc.center.x, resolveRoofWallTopElevation(targetLevelId, wall, nodes), arc.center.y],
     children: [segment.id],
   })
 
diff --git a/packages/nodes/src/roof/roof-footprint.ts b/packages/nodes/src/roof/roof-footprint.ts
index 439a87348..244eb37a4 100644
--- a/packages/nodes/src/roof/roof-footprint.ts
+++ b/packages/nodes/src/roof/roof-footprint.ts
@@ -203,7 +203,7 @@ export function resolveRoofFootprintElevation(
       ? [resolveRoofWallTopElevation(targetLevelId, wall, completeNodes, elevations)]
       : []
   })
-  return tops.length ? Math.max(0, ...tops) : 0
+  return tops.length ? Math.max(...tops) : 0
 }
 
 export function resolveRoofFootprintWorldElevation(
diff --git a/packages/nodes/src/wall/definition.test.ts b/packages/nodes/src/wall/definition.test.ts
index e79a4da50..694b474c8 100644
--- a/packages/nodes/src/wall/definition.test.ts
+++ b/packages/nodes/src/wall/definition.test.ts
@@ -242,7 +242,7 @@ test('curved wall roof builder reuses its existing hosted roof', () => {
   expect(created).toHaveLength(0)
 })
 
-test('curved wall roof builder clamps a lower-floor wall to the active floor', () => {
+test('curved wall roof builder follows a lower-floor wall top below the active floor', () => {
   const sourceLevel = {
     object: 'node',
     id: 'level_source',
@@ -280,7 +280,7 @@ test('curved wall roof builder clamps a lower-floor wall to the active floor', (
   createConicalRoofSectorAboveWall(wall, nodes, sceneApi, activeLevel.id as AnyNodeId)
 
   const createdRoof = created.find((entry) => entry.node.type === 'roof')
-  expect(createdRoof?.node).toMatchObject({ position: [0, 0, 0] })
+  expect(createdRoof?.node).toMatchObject({ position: [0, -2, 0] })
 })
 
 test('curved wall roof builder rejects walls more than one level below', () => {

From 947c439820bce2eba61d6e220b647fabbd3dc557 Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Thu, 10 Sep 2026 10:46:39 -0400
Subject: [PATCH 25/27] feat(roof): follow walls by intent, resolved from the
 footprint

Replace the source-wall id list with support.kind 'walls': room and
conical roofs are created following, the system resolves the enclosure
under the roof centre on the level below and writes the highest wall top
(unclamped), an explicit Y edit or vertical handle drag flips the roof to
custom, and the panel offers Follows walls / Custom like walls do. No
migration; existing roofs stay custom until the user opts in.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 packages/core/src/index.ts                    |   6 +
 .../src/schema/nodes/roof-elevation.test.ts   |  26 +--
 packages/core/src/schema/nodes/roof.ts        |   5 +-
 .../roof/roof-elevation-system.test.ts        | 140 ++++++++---
 .../systems/roof/roof-elevation-system.tsx    |   2 +-
 .../src/systems/roof/roof-elevation.test.ts   | 221 +++++++++++++++---
 .../core/src/systems/roof/roof-elevation.ts   |  42 +++-
 .../core/src/systems/roof/roof-footprint.ts   | 118 ++++++++++
 packages/core/src/utils/clone-scene-graph.ts  |  13 --
 packages/nodes/src/roof/conical-roof.ts       |   2 +-
 packages/nodes/src/roof/definition.test.ts    |  21 ++
 packages/nodes/src/roof/definition.ts         |   8 +-
 packages/nodes/src/roof/panel.tsx             |  50 +++-
 .../nodes/src/roof/roof-footprint.test.ts     |   9 +-
 packages/nodes/src/roof/roof-footprint.ts     | 117 +---------
 packages/nodes/src/roof/tool.test.ts          |  58 +++++
 packages/nodes/src/roof/tool.tsx              |  11 +-
 packages/nodes/src/wall/definition.test.ts    |   4 +-
 wiki/architecture/vertical-model.md           |   8 +-
 19 files changed, 612 insertions(+), 249 deletions(-)
 create mode 100644 packages/core/src/systems/roof/roof-footprint.ts
 create mode 100644 packages/nodes/src/roof/tool.test.ts

diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 91dfeed97..7ff7c5c22 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -397,6 +397,12 @@ export {
 } from './systems/fence/fence-spline'
 export { resolveRoofElevation, resolveRoofWallTopElevation } from './systems/roof/roof-elevation'
 export { RoofElevationSystem } from './systems/roof/roof-elevation-system'
+export {
+  fitRoofFootprint,
+  type RoofFootprintTarget,
+  resolveRoomRoofFootprint,
+  resolveRoomRoofFootprintOnLevel,
+} from './systems/roof/roof-footprint'
 export { resolveSlabPlacementElevation } from './systems/slab/slab-placement'
 export {
   clampSlabElevationForWalls,
diff --git a/packages/core/src/schema/nodes/roof-elevation.test.ts b/packages/core/src/schema/nodes/roof-elevation.test.ts
index eeb5a5ff4..4b5186ab2 100644
--- a/packages/core/src/schema/nodes/roof-elevation.test.ts
+++ b/packages/core/src/schema/nodes/roof-elevation.test.ts
@@ -1,27 +1,11 @@
 import { expect, test } from 'bun:test'
-import { cloneLevelSubtree, cloneSceneGraph } from '../../utils/clone-scene-graph'
-import { LevelNode } from './level'
 import { RoofNode } from './roof'
-import { WallNode } from './wall'
 
-test('roof wall bindings are optional and survive JSON parsing', () => {
-  expect(RoofNode.parse({})).not.toHaveProperty('sourceWallIds')
-  const roof = RoofNode.parse({ sourceWallIds: ['wall_source'] })
-  expect(RoofNode.parse(JSON.parse(JSON.stringify(roof))).sourceWallIds).toEqual(['wall_source'])
+test('roofs default to custom level support', () => {
+  expect(RoofNode.parse({}).support).toEqual({ kind: 'level' })
 })
 
-test('scene and level clones remap roof source walls', () => {
-  const level = LevelNode.parse({})
-  const wall = WallNode.parse({ parentId: level.id, start: [0, 0], end: [4, 0] })
-  const roof = RoofNode.parse({ parentId: level.id, sourceWallIds: [wall.id] })
-  level.children = [wall.id, roof.id]
-  const nodes = Object.fromEntries([level, wall, roof].map((node) => [node.id, node]))
-  const whole = cloneSceneGraph({ nodes, rootNodeIds: [level.id] })
-  const levelClone = cloneLevelSubtree(nodes, level.id)
-  for (const clonedNodes of [Object.values(whole.nodes), levelClone.clonedNodes]) {
-    const clonedWall = clonedNodes.find((node) => node.type === 'wall')!
-    const clonedRoof = clonedNodes.find((node) => node.type === 'roof')!
-    expect(clonedRoof.sourceWallIds).toEqual([clonedWall.id])
-    expect(clonedWall.id).not.toBe(wall.id)
-  }
+test('wall-follow support survives JSON parsing without host references', () => {
+  const roof = RoofNode.parse({ support: { kind: 'walls' }, position: [2, -0.5, 1] })
+  expect(RoofNode.parse(JSON.parse(JSON.stringify(roof)))).toEqual(roof)
 })
diff --git a/packages/core/src/schema/nodes/roof.ts b/packages/core/src/schema/nodes/roof.ts
index 0c182d9b4..ca9ae3522 100644
--- a/packages/core/src/schema/nodes/roof.ts
+++ b/packages/core/src/schema/nodes/roof.ts
@@ -14,6 +14,7 @@ export type RoofSurfaceMaterialSpec = {
 export const RoofSupport = z
   .discriminatedUnion('kind', [
     z.object({ kind: z.literal('level') }),
+    z.object({ kind: z.literal('walls') }),
     z.object({
       kind: z.literal('roof'),
       roofSegmentId: RoofSegmentNode.shape.id,
@@ -40,7 +41,6 @@ export const RoofNode = BaseNode.extend({
   // Rotation around Y axis in radians
   rotation: z.number().default(0),
   support: RoofSupport,
-  sourceWallIds: z.array(z.templateLiteral(['wall_', z.string()])).optional(),
   // Child roof segment IDs
   children: z.array(RoofSegmentNode.shape.id).default([]),
 }).describe(
@@ -50,8 +50,7 @@ export const RoofNode = BaseNode.extend({
   When not being edited, segments are visually combined into a single solid.
   - position: center position of the roof group
   - rotation: rotation around Y axis
-  - support: level placement or an explicit roof-surface attachment
-  - sourceWallIds: follows the highest source wall top when present
+  - support: custom level placement, spatial wall-top following, or a roof-surface attachment
   - children: array of RoofSegmentNode IDs
   `,
 )
diff --git a/packages/core/src/systems/roof/roof-elevation-system.test.ts b/packages/core/src/systems/roof/roof-elevation-system.test.ts
index 3eb400e3a..0617edb6e 100644
--- a/packages/core/src/systems/roof/roof-elevation-system.test.ts
+++ b/packages/core/src/systems/roof/roof-elevation-system.test.ts
@@ -47,27 +47,33 @@ afterEach(() => {
 })
 
 function setup() {
-  const level = LevelNode.parse({ height: 2.5 })
+  const level = LevelNode.parse({ height: 3, level: 0 })
+  const upper = LevelNode.parse({ height: 3, level: 1 })
   const wall = WallNode.parse({ parentId: level.id, start: [0, 0], end: [4, 0], height: 3 })
   const roof = RoofNode.parse({
-    parentId: level.id,
-    sourceWallIds: [wall.id],
-    position: [2, 3, 1],
+    parentId: upper.id,
+    support: { kind: 'walls' },
+    position: [2, 0, 1],
     rotation: 0.4,
   })
   const manual = RoofNode.parse({ parentId: level.id, position: [6, 7, 8] })
-  level.children = [wall.id, roof.id, manual.id]
+  const otherWalls = [
+    WallNode.parse({ parentId: level.id, start: [4, 0], end: [4, 3], height: 3 }),
+    WallNode.parse({ parentId: level.id, start: [4, 3], end: [0, 3], height: 3 }),
+    WallNode.parse({ parentId: level.id, start: [0, 3], end: [0, 0], height: 3 }),
+  ]
+  level.children = [wall.id, ...otherWalls.map((node) => node.id), manual.id]
+  upper.children = [roof.id]
   useScene.setState({
-    nodes: Object.fromEntries([level, wall, roof, manual].map((node) => [node.id, node])) as Record<
-      AnyNodeId,
-      AnyNode
-    >,
-    rootNodeIds: [level.id],
+    nodes: Object.fromEntries(
+      [level, upper, wall, ...otherWalls, roof, manual].map((node) => [node.id, node]),
+    ) as Record<AnyNodeId, AnyNode>,
+    rootNodeIds: [level.id, upper.id],
   })
   clearSceneHistory()
   stopRoofSync = initializeRoofElevationSync()
   stopGridSync = initSpatialGridSync()
-  return { level, wall, roof, manual }
+  return { level, upper, wall, otherWalls, roof, manual }
 }
 
 function currentRoof(id: RoofNode['id']): RoofNode {
@@ -81,22 +87,22 @@ describe('RoofElevationSystem', () => {
     const commits: SceneCommit[] = []
     stopCommitSubscription = subscribeSceneCommits((commit) => commits.push(commit))
     useScene.getState().updateNode(wall.id, { height: 4.2 })
-    expect(currentRoof(roof.id).position).toEqual([2, 3, 1])
+    expect(currentRoof(roof.id).position).toEqual([2, 0, 1])
     await Promise.resolve()
-    expect(currentRoof(roof.id).position).toEqual([2, 4.2, 1])
+    expect(currentRoof(roof.id).position[1]).toBeCloseTo(1.2)
     expect(currentRoof(roof.id).rotation).toBe(0.4)
     expect(currentRoof(manual.id).position).toEqual([6, 7, 8])
     expect(useScene.temporal.getState().pastStates).toHaveLength(1)
     expect(commits).toHaveLength(2)
-    expect((commits[1]?.before.nodes[roof.id] as RoofNode).position[1]).toBe(3)
-    expect((commits[1]?.current.nodes[roof.id] as RoofNode).position[1]).toBe(4.2)
+    expect((commits[1]?.before.nodes[roof.id] as RoofNode).position[1]).toBe(0)
+    expect((commits[1]?.current.nodes[roof.id] as RoofNode).position[1]).toBeCloseTo(1.2)
     expect(commits[1]?.changedNodeIds).toEqual(new Set([roof.id]))
     useScene.temporal.getState().undo()
     await Promise.resolve()
-    expect(currentRoof(roof.id).position[1]).toBe(3)
+    expect(currentRoof(roof.id).position[1]).toBe(0)
     useScene.temporal.getState().redo()
     await Promise.resolve()
-    expect(currentRoof(roof.id).position[1]).toBe(4.2)
+    expect(currentRoof(roof.id).position[1]).toBeCloseTo(1.2)
   })
 
   test('does not publish previews owned by an outer history pause', async () => {
@@ -108,7 +114,7 @@ describe('RoofElevationSystem', () => {
     try {
       useScene.getState().updateNode(wall.id, { height: 4 })
       await Promise.resolve()
-      expect(currentRoof(roof.id).position[1]).toBe(4)
+      expect(currentRoof(roof.id).position[1]).toBe(1)
       expect(useScene.temporal.getState().isTracking).toBe(false)
       expect(commits).toHaveLength(0)
     } finally {
@@ -129,20 +135,102 @@ describe('RoofElevationSystem', () => {
     })
     useScene.getState().createNode(slab, level.id)
     await Promise.resolve()
-    expect(currentRoof(roof.id).position[1]).toBe(3.5)
+    expect(currentRoof(roof.id).position[1]).toBe(0.5)
     useScene.getState().updateNode(slab.id, { elevation: 0.9 })
     await Promise.resolve()
-    expect(currentRoof(roof.id).position[1]).toBe(3.9)
+    expect(currentRoof(roof.id).position[1]).toBeCloseTo(0.9)
   })
 
-  test('keeps a manual Y edit after its wall binding is removed', async () => {
+  test('keeps a custom Y edit after follow mode is disabled', async () => {
     const { wall, roof } = setup()
     await Promise.resolve()
-    useScene.getState().updateNode(roof.id, { sourceWallIds: undefined, position: [2, 9, 1] })
+    useScene.getState().updateNode(roof.id, { support: { kind: 'level' }, position: [2, 9, 1] })
     useScene.getState().updateNode(wall.id, { height: 5 })
     await Promise.resolve()
     expect(currentRoof(roof.id).position[1]).toBe(9)
-    expect(currentRoof(roof.id)).not.toHaveProperty('sourceWallIds')
+    expect(currentRoof(roof.id).support).toEqual({ kind: 'level' })
+  })
+
+  test('undo and redo restore custom/follow mode and Y together', async () => {
+    const { roof } = setup()
+    await Promise.resolve()
+    useScene.getState().updateNode(roof.id, { support: { kind: 'level' }, position: [2, 9, 1] })
+    await Promise.resolve()
+    expect(useScene.temporal.getState().pastStates).toHaveLength(1)
+    useScene.temporal.getState().undo()
+    await Promise.resolve()
+    expect(currentRoof(roof.id)).toMatchObject({ support: { kind: 'walls' }, position: [2, 0, 1] })
+    useScene.temporal.getState().redo()
+    await Promise.resolve()
+    expect(currentRoof(roof.id)).toMatchObject({ support: { kind: 'level' }, position: [2, 9, 1] })
+    useScene.getState().updateNode(roof.id, { support: { kind: 'walls' } })
+    expect(currentRoof(roof.id).position[1]).toBe(9)
+    await Promise.resolve()
+    expect(currentRoof(roof.id)).toMatchObject({ support: { kind: 'walls' }, position: [2, 0, 1] })
+    expect(useScene.temporal.getState().pastStates).toHaveLength(2)
+    useScene.temporal.getState().undo()
+    await Promise.resolve()
+    expect(currentRoof(roof.id)).toMatchObject({ support: { kind: 'level' }, position: [2, 9, 1] })
+    useScene.temporal.getState().redo()
+    await Promise.resolve()
+    expect(currentRoof(roof.id)).toMatchObject({ support: { kind: 'walls' }, position: [2, 0, 1] })
+  })
+
+  test('deleting all walls freezes Y and redrawing an enclosure resumes following', async () => {
+    const { level, wall, otherWalls, roof } = setup()
+    useScene.getState().updateNode(wall.id, { height: 4 })
+    await Promise.resolve()
+    const walls = [wall, ...otherWalls]
+    useScene.getState().deleteNodes(walls.map((node) => node.id))
+    await Promise.resolve()
+    expect(currentRoof(roof.id)).toMatchObject({ support: { kind: 'walls' }, position: [2, 1, 1] })
+    const replacements = walls.map((node) =>
+      WallNode.parse({ ...node, id: undefined, height: 2.5 }),
+    )
+    useScene.getState().createNodes(replacements.map((node) => ({ node, parentId: level.id })))
+    await Promise.resolve()
+    expect(currentRoof(roof.id)).toMatchObject({
+      support: { kind: 'walls' },
+      position: [2, -0.5, 1],
+    })
+    useScene.temporal.getState().undo()
+    await Promise.resolve()
+    expect(currentRoof(roof.id)).toMatchObject({ support: { kind: 'walls' }, position: [2, 1, 1] })
+    useScene.temporal.getState().redo()
+    await Promise.resolve()
+    expect(currentRoof(roof.id)).toMatchObject({
+      support: { kind: 'walls' },
+      position: [2, -0.5, 1],
+    })
+  })
+
+  test('an XZ-only move resolves a different enclosure without changing mode', async () => {
+    const { level, wall, otherWalls, roof } = setup()
+    const second = [wall, ...otherWalls].map((node) =>
+      WallNode.parse({
+        ...node,
+        id: undefined,
+        height: 5,
+        start: [node.start[0] + 10, node.start[1]],
+        end: [node.end[0] + 10, node.end[1]],
+      }),
+    )
+    useScene.getState().createNodes(second.map((node) => ({ node, parentId: level.id })))
+    await Promise.resolve()
+    useScene.getState().updateNode(roof.id, { position: [12, 0, 1] })
+    await Promise.resolve()
+    expect(currentRoof(roof.id)).toMatchObject({ support: { kind: 'walls' }, position: [12, 2, 1] })
+  })
+
+  test('initialization never changes existing custom roofs', async () => {
+    const { roof } = setup()
+    stopRoofSync()
+    useScene.getState().updateNode(roof.id, { support: { kind: 'level' }, position: [2, 8, 1] })
+    clearSceneHistory()
+    stopRoofSync = initializeRoofElevationSync()
+    await Promise.resolve()
+    expect(currentRoof(roof.id)).toMatchObject({ support: { kind: 'level' }, position: [2, 8, 1] })
+    expect(useScene.temporal.getState().pastStates).toHaveLength(0)
   })
 
   test('coalesces rapid edits, ignores epsilon drift and cancels queued work on disposal', async () => {
@@ -150,14 +238,14 @@ describe('RoofElevationSystem', () => {
     await Promise.resolve()
     useScene.getState().updateNode(wall.id, { height: 3.00001 })
     await Promise.resolve()
-    expect(currentRoof(roof.id).position[1]).toBe(3)
+    expect(currentRoof(roof.id).position[1]).toBe(0)
     useScene.getState().updateNode(wall.id, { height: 4 })
     useScene.getState().updateNode(wall.id, { height: 5 })
     await Promise.resolve()
-    expect(currentRoof(roof.id).position[1]).toBe(5)
+    expect(currentRoof(roof.id).position[1]).toBe(2)
     useScene.getState().updateNode(wall.id, { height: 6 })
     stopRoofSync()
     await Promise.resolve()
-    expect(currentRoof(roof.id).position[1]).toBe(5)
+    expect(currentRoof(roof.id).position[1]).toBe(2)
   })
 })
diff --git a/packages/core/src/systems/roof/roof-elevation-system.tsx b/packages/core/src/systems/roof/roof-elevation-system.tsx
index 19865441b..e5b9cd7ea 100644
--- a/packages/core/src/systems/roof/roof-elevation-system.tsx
+++ b/packages/core/src/systems/roof/roof-elevation-system.tsx
@@ -46,7 +46,7 @@ export function initializeRoofElevationSync(): () => void {
       if (readOnly) return
       const updates: Array<{ id: AnyNodeId; data: Partial<AnyNode> }> = []
       for (const node of Object.values(nodes)) {
-        if (node.type !== 'roof') continue
+        if (node.type !== 'roof' || node.support?.kind !== 'walls') continue
         const elevation = resolveRoofElevation(node, nodes)
         if (Math.abs(node.position[1] - elevation) <= ROOF_ELEVATION_EPSILON) continue
         updates.push({
diff --git a/packages/core/src/systems/roof/roof-elevation.test.ts b/packages/core/src/systems/roof/roof-elevation.test.ts
index 5b0c1a64f..59ef383ac 100644
--- a/packages/core/src/systems/roof/roof-elevation.test.ts
+++ b/packages/core/src/systems/roof/roof-elevation.test.ts
@@ -1,27 +1,49 @@
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
 import { spatialGridManager } from '../../hooks/spatial-grid/spatial-grid-manager'
-import { type AnyNode, LevelNode, RoofNode, SlabNode, WallNode } from '../../schema'
+import {
+  type AnyNode,
+  BuildingNode,
+  LevelNode,
+  RoofNode,
+  RoofSegmentNode,
+  SlabNode,
+  WallNode,
+} from '../../schema'
+import { planWallSplitAtPoint } from '../wall/wall-topology'
 import { resolveRoofElevation } from './roof-elevation'
 
 beforeEach(() => spatialGridManager.clear())
 afterEach(() => spatialGridManager.clear())
 
-function scene(heights: Array<number | undefined>) {
-  const level = LevelNode.parse({ id: 'level_roof_source', height: 2.5, level: 0 })
-  const upper = LevelNode.parse({ id: 'level_roof_target', height: 3, level: 1 })
-  const walls = heights.map((height, index) =>
-    WallNode.parse({
+function room(level: LevelNode, heights: Array<number | undefined>, offsetX = 0) {
+  const polygon: Array<[number, number]> = [
+    [0, 0],
+    [4, 0],
+    [4, 3],
+    [0, 3],
+  ]
+  return polygon.map((point, index) => {
+    const next = polygon[(index + 1) % polygon.length]!
+    return WallNode.parse({
       parentId: level.id,
-      start: [0, index],
-      end: [4, index],
-      height,
-    }),
-  )
+      start: [point[0] + offsetX, point[1]],
+      end: [next[0] + offsetX, next[1]],
+      height: heights[index % heights.length],
+    })
+  })
+}
+
+function scene(heights: Array<number | undefined>) {
+  const level = LevelNode.parse({ height: 3, level: 0 })
+  const upper = LevelNode.parse({ height: 3, level: 1 })
+  const walls = room(level, heights)
   const roof = RoofNode.parse({
     parentId: upper.id,
-    sourceWallIds: walls.map((wall) => wall.id),
+    support: { kind: 'walls' },
     position: [2, 0, 1],
   })
+  level.children = walls.map((wall) => wall.id)
+  upper.children = [roof.id]
   const nodes: Record<string, AnyNode> = Object.fromEntries(
     [level, upper, roof, ...walls].map((node) => [node.id, node]),
   )
@@ -29,26 +51,26 @@ function scene(heights: Array<number | undefined>) {
 }
 
 describe('resolveRoofElevation', () => {
-  test('honors an explicit height above the storey and converts to the roof level frame', () => {
-    const { roof, nodes } = scene([4])
+  test('honors an explicit height above the storey in the roof level frame', () => {
+    const { roof, nodes } = scene([4.5])
     expect(resolveRoofElevation(roof, nodes)).toBe(1.5)
   })
 
   test('takes the highest top across mixed explicit and plane-bound walls', () => {
-    const { roof, nodes } = scene([3, undefined, 4.5, 2])
+    const { roof, nodes } = scene([3, undefined, 5, 2])
     expect(resolveRoofElevation(roof, nodes)).toBe(2)
   })
 
   test('includes the elected slab base and wall support offset', () => {
-    const { level, walls, roof, nodes } = scene([4])
+    const { level, walls, roof, nodes } = scene([4.5])
     const slab = SlabNode.parse({
       parentId: level.id,
       elevation: 0.8,
       polygon: [
         [-1, -1],
         [5, -1],
-        [5, 2],
-        [-1, 2],
+        [5, 4],
+        [-1, 4],
       ],
     })
     spatialGridManager.handleNodeCreated(slab, level.id)
@@ -62,34 +84,161 @@ describe('resolveRoofElevation', () => {
     expect(resolveRoofElevation(roof, { ...nodes, [wall.id]: wall })).toBe(0)
   })
 
-  test('follows tops below the roof level plane so short walls leave no gap', () => {
-    const { roof, nodes } = scene([2])
+  test('2.5 m walls under a 3 m storey pull the roof down to -0.5 m', () => {
+    const { roof, nodes } = scene([2.5])
     expect(resolveRoofElevation(roof, nodes)).toBe(-0.5)
   })
 
-  test('preserves manual Y without a footprint or after all sources disappear', () => {
-    const { roof, nodes } = scene([4])
-    expect(resolveRoofElevation({ ...roof, sourceWallIds: undefined }, nodes)).toBe(0)
-    expect(resolveRoofElevation({ ...roof, sourceWallIds: ['wall_deleted'] }, nodes)).toBe(0)
-    expect(resolveRoofElevation({ ...roof, sourceWallIds: [] }, nodes)).toBe(0)
-  })
-
-  test('ignores missing walls while retaining surviving sources', () => {
-    const { roof, nodes } = scene([4])
-    expect(
-      resolveRoofElevation(
-        { ...roof, sourceWallIds: ['wall_deleted', ...roof.sourceWallIds!] },
-        nodes,
-      ),
-    ).toBe(1.5)
+  test('freezes without an enclosure, retaining follow intent', () => {
+    const { walls, roof, nodes } = scene([4])
+    const remaining = { ...nodes }
+    delete remaining[walls[0]!.id]
+    expect(resolveRoofElevation(roof, remaining)).toBe(0)
+    for (const wall of walls) delete remaining[wall.id]
+    expect(resolveRoofElevation(roof, remaining)).toBe(0)
+    expect(roof.support).toEqual({ kind: 'walls' })
+    expect(resolveRoofElevation(roof, nodes)).toBe(1)
   })
 
-  test('leaves roof-surface attachments to their own support rule', () => {
+  test('level roofs and roof-surface attachments keep their Y', () => {
     const { roof, nodes } = scene([4])
+    expect(resolveRoofElevation({ ...roof, support: { kind: 'level' } }, nodes)).toBe(0)
     const attached = RoofNode.parse({
       ...roof,
       support: { kind: 'roof', roofSegmentId: 'rseg_host', localPosition: [0, 0] },
     })
     expect(resolveRoofElevation(attached, nodes)).toBe(0)
   })
+
+  test('re-resolves replacement wall pieces after a topology split', () => {
+    const { level, walls, roof, nodes } = scene([4])
+    const split = planWallSplitAtPoint(nodes, { levelId: level.id, point: [2, 0], radius: 0.05 })
+    expect(split.ok).toBe(true)
+    if (!split.ok) throw new Error(split.reason)
+    const { create, delete: deleted } = split.plan.changes
+    expect(create).toHaveLength(2)
+    const next = { ...nodes }
+    for (const id of deleted) delete next[id]
+    for (const { node } of create) next[node.id] = { ...node, height: 5 } as WallNode
+    next[level.id] = {
+      ...level,
+      children: [
+        ...walls.filter((wall) => !deleted.includes(wall.id)).map((wall) => wall.id),
+        ...create.map(({ node }) => node.id),
+      ],
+    }
+    expect(resolveRoofElevation(roof, next)).toBe(2)
+  })
+
+  test('chooses the smallest enclosure containing the roof centre', () => {
+    const { level, roof, nodes } = scene([5])
+    const innerPolygon: Array<[number, number]> = [
+      [1, 0.5],
+      [3, 0.5],
+      [3, 2.5],
+      [1, 2.5],
+    ]
+    const innerWalls = innerPolygon.map((start, index) =>
+      WallNode.parse({
+        parentId: level.id,
+        start,
+        end: innerPolygon[(index + 1) % innerPolygon.length],
+        height: 2.5,
+      }),
+    )
+    const next = {
+      ...nodes,
+      ...Object.fromEntries(innerWalls.map((wall) => [wall.id, wall])),
+      [level.id]: { ...level, children: [...level.children, ...innerWalls.map((wall) => wall.id)] },
+    }
+    expect(resolveRoofElevation(roof, next)).toBe(-0.5)
+  })
+
+  test('moving XZ chooses the enclosure at the new centre', () => {
+    const { level, roof, nodes } = scene([4])
+    const secondWalls = room(level, [5], 10)
+    const next = {
+      ...nodes,
+      ...Object.fromEntries(secondWalls.map((wall) => [wall.id, wall])),
+      [level.id]: {
+        ...level,
+        children: [...level.children, ...secondWalls.map((wall) => wall.id)],
+      },
+    }
+    expect(resolveRoofElevation(roof, next)).toBe(1)
+    expect(resolveRoofElevation({ ...roof, position: [12, 1, 1] }, next)).toBe(2)
+    expect(resolveRoofElevation({ ...roof, position: [20, 7, 1] }, next)).toBe(7)
+  })
+
+  test('uses the lower neighbour in the same building across ordinal gaps and offsets', () => {
+    const { level, upper, roof, nodes } = scene([4.5])
+    const building = BuildingNode.parse({ children: [level.id, upper.id] })
+    const otherBuilding = BuildingNode.parse({})
+    const unrelated = LevelNode.parse({ parentId: otherBuilding.id, level: 8, height: 100 })
+    const next = {
+      ...nodes,
+      [building.id]: building,
+      [otherBuilding.id]: otherBuilding,
+      [unrelated.id]: unrelated,
+      [level.id]: { ...level, parentId: building.id, level: -2, baseElevation: 2 },
+      [upper.id]: { ...upper, parentId: building.id, level: 10, baseElevation: 0.5 },
+    }
+    expect(resolveRoofElevation(roof, next)).toBe(1)
+  })
+
+  test('never substitutes walls on the roof parent level or a more distant floor', () => {
+    const { level, upper, roof, nodes } = scene([4])
+    const middle = LevelNode.parse({ level: 0.5, height: 2 })
+    const onParent = room(upper, [20])
+    const next = {
+      ...nodes,
+      [middle.id]: middle,
+      [upper.id]: { ...upper, children: [...upper.children, ...onParent.map((wall) => wall.id)] },
+      ...Object.fromEntries(onParent.map((wall) => [wall.id, wall])),
+    }
+    expect(resolveRoofElevation(roof, next)).toBe(0)
+    expect(resolveRoofElevation({ ...roof, parentId: level.id }, nodes)).toBe(0)
+  })
+
+  test('matches a conical arc by centre and radius after replacement, without an enclosure', () => {
+    const { level, roof, nodes } = scene([4])
+    const segment = RoofSegmentNode.parse({
+      parentId: roof.id,
+      roofType: 'conical',
+      width: 4,
+      depth: 4,
+      conicalFullCircle: true,
+    })
+    const curved = WallNode.parse({
+      parentId: level.id,
+      start: [-2, 0],
+      end: [2, 0],
+      curveOffset: 2,
+      height: 2.5,
+    })
+    const cone = {
+      ...roof,
+      children: [segment.id],
+      position: [0, 0, 0] as [number, number, number],
+    }
+    const next = {
+      ...nodes,
+      [level.id]: { ...level, children: [curved.id] },
+      [curved.id]: curved,
+      [segment.id]: segment,
+    }
+    expect(resolveRoofElevation(cone, next)).toBe(-0.5)
+    const replacement = WallNode.parse({ ...curved, id: undefined, height: 5 })
+    const replaced = {
+      ...next,
+      [level.id]: { ...level, children: [replacement.id] },
+      [replacement.id]: replacement,
+    }
+    delete replaced[curved.id]
+    expect(resolveRoofElevation(cone, replaced)).toBe(2)
+    expect(resolveRoofElevation({ ...cone, position: [1, 7, 0] }, replaced)).toBe(7)
+    expect(
+      resolveRoofElevation(cone, { ...replaced, [segment.id]: { ...segment, width: 6 } }),
+    ).toBe(0)
+  })
 })
diff --git a/packages/core/src/systems/roof/roof-elevation.ts b/packages/core/src/systems/roof/roof-elevation.ts
index f891f2a93..a8b8c9cea 100644
--- a/packages/core/src/systems/roof/roof-elevation.ts
+++ b/packages/core/src/systems/roof/roof-elevation.ts
@@ -3,8 +3,10 @@ import {
   getWallEffectiveHeightForNodes,
 } from '../../hooks/spatial-grid/spatial-grid-manager'
 import { resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync'
-import type { AnyNode, LevelNode, RoofNode, WallNode } from '../../schema'
-import { getLevelElevations } from '../../services/storey'
+import type { AnyNode, LevelNode, RoofNode, RoofSegmentNode, WallNode } from '../../schema'
+import { findLevelBelowId, getLevelElevations } from '../../services/storey'
+import { getWallArcData } from '../wall/wall-curve'
+import { resolveRoomRoofFootprintOnLevel } from './roof-footprint'
 
 export function resolveRoofWallTopElevation(
   targetLevelId: LevelNode['id'],
@@ -26,14 +28,44 @@ export function resolveRoofElevation(
   roof: RoofNode,
   nodes: Readonly<Record<string, AnyNode>>,
 ): number {
-  if (!roof.sourceWallIds?.length || roof.support?.kind === 'roof') return roof.position[1]
+  if (roof.support?.kind !== 'walls') return roof.position[1]
   const levelId = resolveLevelId(roof, nodes)
   if (nodes[levelId]?.type !== 'level') return roof.position[1]
   const elevations = getLevelElevations(nodes)
+  const belowId = findLevelBelowId(levelId, elevations)
+  const below = belowId ? nodes[belowId] : undefined
+  if (below?.type !== 'level') return roof.position[1]
+
+  const conicalSegments = roof.children
+    .map((id) => nodes[id])
+    .filter(
+      (node): node is RoofSegmentNode =>
+        node?.type === 'roof-segment' && node.roofType === 'conical',
+    )
+  const wallIds = conicalSegments.length
+    ? below.children.filter((id) => {
+        const wall = nodes[id]
+        if (wall?.type !== 'wall') return false
+        const arc = getWallArcData(wall)
+        if (!arc) return false
+        const cos = Math.cos(roof.rotation)
+        const sin = Math.sin(roof.rotation)
+        return conicalSegments.some((segment) => {
+          const centerX = roof.position[0] + segment.position[0] * cos + segment.position[2] * sin
+          const centerZ = roof.position[2] - segment.position[0] * sin + segment.position[2] * cos
+          return (
+            Math.hypot(arc.center.x - centerX, arc.center.y - centerZ) <= 1e-4 &&
+            Math.abs(arc.radius - segment.width / 2) <= 1e-4
+          )
+        })
+      })
+    : (resolveRoomRoofFootprintOnLevel(below.id, nodes, [roof.position[0], roof.position[2]])
+        ?.wallIds ?? [])
+
   let highest: number | undefined
-  for (const id of roof.sourceWallIds) {
+  for (const id of wallIds) {
     const wall = nodes[id]
-    if (wall?.type !== 'wall' || nodes[resolveLevelId(wall, nodes)]?.type !== 'level') continue
+    if (wall?.type !== 'wall') continue
     const top = resolveRoofWallTopElevation(levelId as LevelNode['id'], wall, nodes, elevations)
     highest = highest === undefined ? top : Math.max(highest, top)
   }
diff --git a/packages/core/src/systems/roof/roof-footprint.ts b/packages/core/src/systems/roof/roof-footprint.ts
new file mode 100644
index 000000000..5fa4b8adf
--- /dev/null
+++ b/packages/core/src/systems/roof/roof-footprint.ts
@@ -0,0 +1,118 @@
+import { pointInPolygon as pointInPolygon2D } from '../../lib/polygon-relations'
+import { detectSpacesForLevel } from '../../lib/space-detection'
+import type { AnyNode, LevelNode, WallNode } from '../../schema'
+import { getLevelBelow } from '../../services/storey'
+
+export type RoofFootprintTarget = {
+  id: string
+  polygon: Array<[number, number]>
+  wallIds: WallNode['id'][]
+  center: [number, number]
+  width: number
+  depth: number
+  rotation: number
+  rectangular: boolean
+}
+
+function polygonArea(polygon: ReadonlyArray<readonly [number, number]>): number {
+  return Math.abs(
+    polygon.reduce((area, point, index) => {
+      const next = polygon[(index + 1) % polygon.length]
+      return next ? area + point[0] * next[1] - next[0] * point[1] : area
+    }, 0) / 2,
+  )
+}
+
+export function fitRoofFootprint(
+  id: string,
+  polygon: Array<[number, number]>,
+  wallIds: WallNode['id'][],
+): RoofFootprintTarget | null {
+  if (polygon.length < 3) return null
+
+  let best:
+    | {
+        center: [number, number]
+        width: number
+        depth: number
+        rotation: number
+        area: number
+      }
+    | undefined
+
+  for (let index = 0; index < polygon.length; index++) {
+    const point = polygon[index]
+    const next = polygon[(index + 1) % polygon.length]
+    if (!(point && next)) continue
+    const rotation = Math.atan2(next[1] - point[1], next[0] - point[0])
+    const cos = Math.cos(rotation)
+    const sin = Math.sin(rotation)
+    const rotated = polygon.map(([x, z]) => [x * cos + z * sin, -x * sin + z * cos] as const)
+    const xs = rotated.map(([x]) => x)
+    const zs = rotated.map(([, z]) => z)
+    const minX = Math.min(...xs)
+    const maxX = Math.max(...xs)
+    const minZ = Math.min(...zs)
+    const maxZ = Math.max(...zs)
+    const width = maxX - minX
+    const depth = maxZ - minZ
+    const area = width * depth
+    if (area <= 0 || (best && best.area <= area)) continue
+    const localCenterX = (minX + maxX) / 2
+    const localCenterZ = (minZ + maxZ) / 2
+    best = {
+      center: [localCenterX * cos - localCenterZ * sin, localCenterX * sin + localCenterZ * cos],
+      width,
+      depth,
+      rotation: -rotation,
+      area,
+    }
+  }
+
+  if (!best) return null
+  return {
+    id,
+    polygon,
+    wallIds,
+    center: best.center,
+    width: best.width,
+    depth: best.depth,
+    rotation: best.rotation,
+    rectangular: polygonArea(polygon) / best.area >= 0.96,
+  }
+}
+
+export function resolveRoomRoofFootprint(
+  levelId: LevelNode['id'],
+  nodes: Readonly<Record<string, AnyNode>>,
+  point: [number, number],
+  options: { rectangularOnly?: boolean } = {},
+): RoofFootprintTarget | null {
+  const activeTarget = resolveRoomRoofFootprintOnLevel(levelId, nodes, point)
+  if (activeTarget && (!options.rectangularOnly || activeTarget.rectangular)) return activeTarget
+  if (activeTarget) return null
+  const levelBelow = getLevelBelow(levelId, nodes as Record<string, AnyNode>)
+  const levelBelowTarget = levelBelow
+    ? resolveRoomRoofFootprintOnLevel(levelBelow.id, nodes, point)
+    : null
+  return levelBelowTarget && (!options.rectangularOnly || levelBelowTarget.rectangular)
+    ? levelBelowTarget
+    : null
+}
+
+export function resolveRoomRoofFootprintOnLevel(
+  levelId: LevelNode['id'],
+  nodes: Readonly<Record<string, AnyNode>>,
+  point: [number, number],
+): RoofFootprintTarget | null {
+  const level = nodes[levelId]
+  if (level?.type !== 'level') return null
+  const walls = level.children
+    .map((id) => nodes[id])
+    .filter((node): node is WallNode => node?.type === 'wall')
+  const spaces = detectSpacesForLevel(levelId, walls)
+    .spaces.filter((space) => !space.isExterior && pointInPolygon2D(point, space.polygon))
+    .sort((left, right) => polygonArea(left.polygon) - polygonArea(right.polygon))
+  const space = spaces[0]
+  return space ? fitRoofFootprint(space.id, space.polygon, space.wallIds) : null
+}
diff --git a/packages/core/src/utils/clone-scene-graph.ts b/packages/core/src/utils/clone-scene-graph.ts
index ddaa9d8cf..2bee88931 100644
--- a/packages/core/src/utils/clone-scene-graph.ts
+++ b/packages/core/src/utils/clone-scene-graph.ts
@@ -108,13 +108,6 @@ export function cloneSceneGraph(sceneGraph: SceneGraph): SceneGraph {
         clonedNode.support.roofSegmentId) as typeof clonedNode.support.roofSegmentId
     }
 
-    if (clonedNode.type === 'roof' && clonedNode.sourceWallIds) {
-      clonedNode.sourceWallIds = clonedNode.sourceWallIds.flatMap((id) => {
-        const mapped = idMap.get(id)
-        return mapped ? [mapped as `wall_${string}`] : []
-      })
-    }
-
     // Remap supportSlabId (persisted slab-support hosts). The 'ground'
     // sentinel is not a node id — keep it as-is.
     if (
@@ -311,12 +304,6 @@ export function cloneLevelSubtree(
         cloned.support.roofSegmentId) as typeof cloned.support.roofSegmentId
     }
 
-    if (cloned.type === 'roof' && cloned.sourceWallIds) {
-      cloned.sourceWallIds = cloned.sourceWallIds.map(
-        (id) => (idMap.get(id) ?? id) as `wall_${string}`,
-      )
-    }
-
     // Remap supportSlabId when the host slab is inside the cloned subtree;
     // preserve it otherwise (like wallId, the reference may point outside).
     if ('supportSlabId' in cloned && typeof cloned.supportSlabId === 'string') {
diff --git a/packages/nodes/src/roof/conical-roof.ts b/packages/nodes/src/roof/conical-roof.ts
index 459903017..8a7ff8fe2 100644
--- a/packages/nodes/src/roof/conical-roof.ts
+++ b/packages/nodes/src/roof/conical-roof.ts
@@ -57,7 +57,7 @@ export function createConicalRoofSectorAboveWall(
   const roof = RoofNode.parse({
     name: `Roof ${roofCount + 1}`,
     metadata: { conicalSourceWallId: wall.id },
-    sourceWallIds: [wall.id],
+    support: { kind: 'walls' },
     position: [arc.center.x, resolveRoofWallTopElevation(targetLevelId, wall, nodes), arc.center.y],
     children: [segment.id],
   })
diff --git a/packages/nodes/src/roof/definition.test.ts b/packages/nodes/src/roof/definition.test.ts
index 8d40a96cf..a31044776 100644
--- a/packages/nodes/src/roof/definition.test.ts
+++ b/packages/nodes/src/roof/definition.test.ts
@@ -26,6 +26,27 @@ function handles(node: RoofNode = roof()): HandleDescriptor<RoofNode>[] {
 }
 
 describe('roof handles', () => {
+  test('an explicit Y move detaches while XZ moves and epsilon drift retain following', () => {
+    const node = roof({ support: { kind: 'walls' }, position: [2, 1, 1] })
+    const handle = handles(node).find((entry) => entry.kind === 'translate')!
+    if (handle.kind !== 'translate') throw new Error('Missing roof translate handle')
+    expect(handle.apply(node, [8, 2, 3], undefined as never)).toEqual({
+      position: [8, 2, 3],
+      support: { kind: 'level' },
+    })
+    expect(handle.apply(node, [8, 1, 3], undefined as never)).toEqual({ position: [8, 1, 3] })
+    expect(handle.apply(node, [8, 1.00001, 3], undefined as never)).toEqual({
+      position: [8, 1.00001, 3],
+    })
+    expect(
+      handle.apply(roof({ support: { kind: 'level' } }), [0, 2, 0], undefined as never),
+    ).toEqual({ position: [0, 2, 0] })
+    const attached = roof({
+      support: { kind: 'roof', roofSegmentId: 'rseg_host', localPosition: [0, 0], curbHeight: 0.5 },
+    })
+    expect(handle.apply(attached, [0, 2, 0], undefined as never)).toEqual({ position: [0, 2, 0] })
+  })
+
   test('hides direct move handle for managed lean-to roofs', () => {
     expect(handles(roof()).length).toBeGreaterThan(0)
     expect(
diff --git a/packages/nodes/src/roof/definition.ts b/packages/nodes/src/roof/definition.ts
index 44d5ee63d..08274d898 100644
--- a/packages/nodes/src/roof/definition.ts
+++ b/packages/nodes/src/roof/definition.ts
@@ -72,7 +72,12 @@ function roofMoveHandle(): HandleDescriptor<RoofNodeType> {
         return [(bounds.minX + bounds.maxX) / 2, 0.02, bounds.maxZ + MOVE_FRONT_OFFSET]
       },
     },
-    apply: (_node, position) => ({ position: [position[0], position[1], position[2]] }),
+    apply: (node, position) => ({
+      position: [position[0], position[1], position[2]],
+      ...(node.support?.kind === 'walls' && Math.abs(position[1] - node.position[1]) > 1e-4
+        ? { support: { kind: 'level' as const } }
+        : {}),
+    }),
     snapExtents: (node, sceneApi) => {
       const bounds = getRoofFootprintBounds(node, sceneApi)
       const width = Math.max(bounds.maxX - bounds.minX, MIN_ROOF_FOOTPRINT)
@@ -124,7 +129,6 @@ export const roofDefinition: NodeDefinition<typeof RoofNode> = {
   },
 
   capabilities: {
-    hostRefFields: ['sourceWallIds'],
     selectable: { hitVolume: 'bbox' },
     duplicable: true,
     deletable: true,
diff --git a/packages/nodes/src/roof/panel.tsx b/packages/nodes/src/roof/panel.tsx
index 0a19bebf1..b4716ec4d 100644
--- a/packages/nodes/src/roof/panel.tsx
+++ b/packages/nodes/src/roof/panel.tsx
@@ -283,18 +283,44 @@ export default function RoofPanel() {
           unit="m"
           value={Math.round(node.position[0] * 100) / 100}
         />
-        <SliderControl
-          label="Y"
-          onChange={(v) => {
-            const pos = [...node.position] as [number, number, number]
-            pos[1] = v
-            handleUpdate({ position: pos, sourceWallIds: undefined })
-          }}
-          precision={2}
-          step={0.05}
-          unit="m"
-          value={Math.round(node.position[1] * 100) / 100}
-        />
+        {node.support?.kind !== 'roof' && (
+          <SegmentedControl
+            onChange={(mode) =>
+              handleUpdate({ support: { kind: mode === 'walls' ? 'walls' : 'level' } })
+            }
+            options={[
+              { label: 'Follows walls', value: 'walls' },
+              { label: 'Custom', value: 'custom' },
+            ]}
+            value={node.support?.kind === 'walls' ? 'walls' : 'custom'}
+          />
+        )}
+        {node.support?.kind === 'walls' ? (
+          <div className="px-1 text-[11px] text-muted-foreground">
+            Currently {Math.round(node.position[1] * 100) / 100} m
+          </div>
+        ) : (
+          <SliderControl
+            label="Y"
+            onChange={(v) => {
+              const pos = [...node.position] as [number, number, number]
+              pos[1] = v
+              const current = useScene.getState().nodes[node.id]
+              handleUpdate({
+                position: pos,
+                ...(current?.type === 'roof' &&
+                current.support?.kind === 'walls' &&
+                Math.abs(v - current.position[1]) > 1e-4
+                  ? { support: { kind: 'level' as const } }
+                  : {}),
+              })
+            }}
+            precision={2}
+            step={0.05}
+            unit="m"
+            value={Math.round(node.position[1] * 100) / 100}
+          />
+        )}
         <SliderControl
           label="Z"
           onChange={(v) => {
diff --git a/packages/nodes/src/roof/roof-footprint.test.ts b/packages/nodes/src/roof/roof-footprint.test.ts
index d235d94a1..cc1529a4e 100644
--- a/packages/nodes/src/roof/roof-footprint.test.ts
+++ b/packages/nodes/src/roof/roof-footprint.test.ts
@@ -1,13 +1,18 @@
 import { describe, expect, test } from 'bun:test'
-import { emitter, LevelNode, type WallEvent, WallNode } from '@pascal-app/core'
 import {
+  emitter,
   fitRoofFootprint,
+  LevelNode,
+  resolveRoomRoofFootprint,
+  type WallEvent,
+  WallNode,
+} from '@pascal-app/core'
+import {
   isStandardRoofWallEligible,
   parseRoofFootprintSource,
   resolveRoofFootprintElevation,
   resolveRoofFootprintWorldElevation,
   resolveRoofWallTopWorldElevation,
-  resolveRoomRoofFootprint,
   subscribeToConicalRoofWallClicks,
 } from './roof-footprint'
 
diff --git a/packages/nodes/src/roof/roof-footprint.ts b/packages/nodes/src/roof/roof-footprint.ts
index 244eb37a4..a887a957a 100644
--- a/packages/nodes/src/roof/roof-footprint.ts
+++ b/packages/nodes/src/roof/roof-footprint.ts
@@ -1,12 +1,11 @@
 import {
   type AnyNode,
-  detectSpacesForLevel,
   emitter,
   getLevelBelow,
   getLevelElevations,
   isCurvedWall,
   type LevelNode,
-  pointInPolygon2D,
+  type RoofFootprintTarget,
   type RoofType,
   resolveLevelId,
   resolveRoofWallTopElevation,
@@ -16,17 +15,6 @@ import {
 
 export type RoofFootprintSource = 'room' | 'walls' | 'draw'
 
-export type RoofFootprintTarget = {
-  id: string
-  polygon: Array<[number, number]>
-  wallIds: WallNode['id'][]
-  center: [number, number]
-  width: number
-  depth: number
-  rotation: number
-  rectangular: boolean
-}
-
 const ROOF_AXIS_ALIGNMENT_EPSILON = 1e-4
 
 export function isStandardRoofWallEligible(wall: WallNode): boolean {
@@ -104,92 +92,6 @@ export function subscribeToConicalRoofWallClicks(options: {
   }
 }
 
-function polygonArea(polygon: ReadonlyArray<readonly [number, number]>): number {
-  return Math.abs(
-    polygon.reduce((area, point, index) => {
-      const next = polygon[(index + 1) % polygon.length]
-      return next ? area + point[0] * next[1] - next[0] * point[1] : area
-    }, 0) / 2,
-  )
-}
-
-export function fitRoofFootprint(
-  id: string,
-  polygon: Array<[number, number]>,
-  wallIds: WallNode['id'][],
-): RoofFootprintTarget | null {
-  if (polygon.length < 3) return null
-
-  let best:
-    | {
-        center: [number, number]
-        width: number
-        depth: number
-        rotation: number
-        area: number
-      }
-    | undefined
-
-  for (let index = 0; index < polygon.length; index++) {
-    const point = polygon[index]
-    const next = polygon[(index + 1) % polygon.length]
-    if (!(point && next)) continue
-    const rotation = Math.atan2(next[1] - point[1], next[0] - point[0])
-    const cos = Math.cos(rotation)
-    const sin = Math.sin(rotation)
-    const rotated = polygon.map(([x, z]) => [x * cos + z * sin, -x * sin + z * cos] as const)
-    const xs = rotated.map(([x]) => x)
-    const zs = rotated.map(([, z]) => z)
-    const minX = Math.min(...xs)
-    const maxX = Math.max(...xs)
-    const minZ = Math.min(...zs)
-    const maxZ = Math.max(...zs)
-    const width = maxX - minX
-    const depth = maxZ - minZ
-    const area = width * depth
-    if (area <= 0 || (best && best.area <= area)) continue
-    const localCenterX = (minX + maxX) / 2
-    const localCenterZ = (minZ + maxZ) / 2
-    best = {
-      center: [localCenterX * cos - localCenterZ * sin, localCenterX * sin + localCenterZ * cos],
-      width,
-      depth,
-      rotation: -rotation,
-      area,
-    }
-  }
-
-  if (!best) return null
-  return {
-    id,
-    polygon,
-    wallIds,
-    center: best.center,
-    width: best.width,
-    depth: best.depth,
-    rotation: best.rotation,
-    rectangular: polygonArea(polygon) / best.area >= 0.96,
-  }
-}
-
-export function resolveRoomRoofFootprint(
-  levelId: LevelNode['id'],
-  nodes: Readonly<Record<string, AnyNode>>,
-  point: [number, number],
-  options: { rectangularOnly?: boolean } = {},
-): RoofFootprintTarget | null {
-  const activeTarget = resolveRoomRoofFootprintOnLevel(levelId, nodes, point)
-  if (activeTarget && (!options.rectangularOnly || activeTarget.rectangular)) return activeTarget
-  if (activeTarget) return null
-  const levelBelow = getLevelBelow(levelId, nodes as Record<string, AnyNode>)
-  const levelBelowTarget = levelBelow
-    ? resolveRoomRoofFootprintOnLevel(levelBelow.id, nodes, point)
-    : null
-  return levelBelowTarget && (!options.rectangularOnly || levelBelowTarget.rectangular)
-    ? levelBelowTarget
-    : null
-}
-
 export function resolveRoofFootprintElevation(
   targetLevelId: LevelNode['id'],
   target: RoofFootprintTarget,
@@ -238,20 +140,3 @@ export function resolveRoofWallTopWorldElevation(
     resolveRoofWallTopElevation(targetLevelId, wall, nodes, elevations)
   )
 }
-
-function resolveRoomRoofFootprintOnLevel(
-  levelId: LevelNode['id'],
-  nodes: Readonly<Record<string, AnyNode>>,
-  point: [number, number],
-): RoofFootprintTarget | null {
-  const level = nodes[levelId]
-  if (level?.type !== 'level') return null
-  const walls = level.children
-    .map((id) => nodes[id])
-    .filter((node): node is WallNode => node?.type === 'wall')
-  const spaces = detectSpacesForLevel(levelId, walls)
-    .spaces.filter((space) => !space.isExterior && pointInPolygon2D(point, space.polygon))
-    .sort((left, right) => polygonArea(left.polygon) - polygonArea(right.polygon))
-  const space = spaces[0]
-  return space ? fitRoofFootprint(space.id, space.polygon, space.wallIds) : null
-}
diff --git a/packages/nodes/src/roof/tool.test.ts b/packages/nodes/src/roof/tool.test.ts
new file mode 100644
index 000000000..1c8d149f4
--- /dev/null
+++ b/packages/nodes/src/roof/tool.test.ts
@@ -0,0 +1,58 @@
+import { afterEach, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeId,
+  LevelNode,
+  type RoofNode,
+  resolveRoomRoofFootprint,
+  type SceneApi,
+  WallNode,
+} from '@pascal-app/core'
+import { useEditor } from '@pascal-app/editor'
+import { commitRoofFootprint, commitRoofPlacement } from './tool'
+
+const originalDefaults = useEditor.getState().toolDefaults
+
+afterEach(() => useEditor.setState({ toolDefaults: originalDefaults }))
+
+function setup() {
+  const level = LevelNode.parse({ level: 0, height: 3 })
+  const upper = LevelNode.parse({ level: 1, height: 3 })
+  const polygon: Array<[number, number]> = [
+    [0, 0],
+    [4, 0],
+    [4, 3],
+    [0, 3],
+  ]
+  const walls = polygon.map((start, index) =>
+    WallNode.parse({
+      parentId: level.id,
+      start,
+      end: polygon[(index + 1) % polygon.length],
+      height: 2.5,
+    }),
+  )
+  level.children = walls.map((wall) => wall.id)
+  const nodes = Object.fromEntries([level, upper, ...walls].map((node) => [node.id, node]))
+  const created: Array<{ node: AnyNode; parentId?: AnyNodeId }> = []
+  const sceneApi = { nodes: () => nodes, createMany: (ops) => created.push(...ops) } as SceneApi
+  return { upper, nodes, created, sceneApi }
+}
+
+test('room creation follows walls and retains the computed initial Y', () => {
+  const { upper, nodes, created, sceneApi } = setup()
+  useEditor.getState().setToolDefaults('roof', { roofType: 'gable', support: { kind: 'level' } })
+  const target = resolveRoomRoofFootprint(upper.id, nodes, [2, 1])!
+  commitRoofFootprint(sceneApi, upper.id, target, false)
+  const roof = created.find(({ node }) => node.type === 'roof')!
+  expect(roof.parentId).toBe(upper.id)
+  expect(roof.node).toMatchObject({ support: { kind: 'walls' }, position: [2, -0.5, 1.5] })
+})
+
+test('free-drawn rectangles stay custom at Y zero even with following preset defaults', () => {
+  const { upper, created, sceneApi } = setup()
+  useEditor.getState().setToolDefaults('roof', { roofType: 'gable', support: { kind: 'walls' } })
+  commitRoofPlacement(sceneApi, upper.id, [0, 9, 0], [4, 9, 3], [], false, 'ground')
+  const roof = created.find(({ node }) => node.type === 'roof')?.node as RoofNode
+  expect(roof).toMatchObject({ support: { kind: 'level' }, position: [2, 0, 1.5] })
+})
diff --git a/packages/nodes/src/roof/tool.tsx b/packages/nodes/src/roof/tool.tsx
index b020e59ae..0ca51d406 100644
--- a/packages/nodes/src/roof/tool.tsx
+++ b/packages/nodes/src/roof/tool.tsx
@@ -10,11 +10,13 @@ import {
   getWallEffectiveHeightForNodes,
   isCurvedWall,
   type LevelNode,
+  type RoofFootprintTarget,
   RoofNode,
   RoofSegmentNode,
   type RoofType,
   RoofType as RoofTypeSchema,
   resolveBuildingForLevel,
+  resolveRoomRoofFootprint,
   type SceneApi,
   sceneRegistry,
   type WallEvent,
@@ -52,11 +54,9 @@ import { resolveConicalRoofPlacement } from './conical-roof-placement'
 import {
   isStandardRoofWallEligible,
   parseRoofFootprintSource,
-  type RoofFootprintTarget,
   resolveRoofFootprintElevation,
   resolveRoofFootprintWorldElevation,
   resolveRoofWallTopWorldElevation,
-  resolveRoomRoofFootprint,
   subscribeToConicalRoofWallClicks,
 } from './roof-footprint'
 import useRoofFootprintSource from './roof-footprint-source'
@@ -183,7 +183,7 @@ function collectRoofAlignmentAnchors(
 /**
  * Creates a roof group with one default gable segment
  */
-const commitRoofPlacement = (
+export const commitRoofPlacement = (
   sceneApi: SceneApi,
   levelId: LevelNode['id'],
   corner1: [number, number, number],
@@ -337,6 +337,7 @@ const commitRoofPlacement = (
     ...defaults,
     name,
     position: [centerX, 0, centerZ],
+    support: { kind: 'level' },
     children: [segment.id],
   })
 
@@ -350,7 +351,7 @@ const commitRoofPlacement = (
   return roof.id
 }
 
-const commitRoofFootprint = (
+export const commitRoofFootprint = (
   sceneApi: SceneApi,
   levelId: LevelNode['id'],
   target: RoofFootprintTarget,
@@ -382,7 +383,7 @@ const commitRoofFootprint = (
       target.center[1],
     ],
     rotation: target.rotation,
-    sourceWallIds: target.wallIds,
+    support: { kind: 'walls' },
     children: [segment.id],
   })
   createRoofNodes(sceneApi, [
diff --git a/packages/nodes/src/wall/definition.test.ts b/packages/nodes/src/wall/definition.test.ts
index 694b474c8..6c0484485 100644
--- a/packages/nodes/src/wall/definition.test.ts
+++ b/packages/nodes/src/wall/definition.test.ts
@@ -139,7 +139,7 @@ test('curved wall roof builder creates a matching conical sector above it', () =
   const segment = created.find((entry) => entry.node.type === 'roof-segment')?.node
 
   expect(wallDefinition.quickActions).toBeUndefined()
-  expect(roof).toMatchObject({ position: [0, 3, 0] })
+  expect(roof).toMatchObject({ position: [0, 3, 0], support: { kind: 'walls' } })
   expect(segment).toMatchObject({
     roofType: 'conical',
     width: 4,
@@ -190,7 +190,7 @@ test('curved wall roof builder parents the roof to the active level', () => {
 
   const createdRoof = created.find((entry) => entry.node.type === 'roof')
   expect(createdRoof?.parentId).toBe(activeLevel.id)
-  expect(createdRoof?.node).toMatchObject({ position: [0, 0, 0] })
+  expect(createdRoof?.node).toMatchObject({ position: [0, 0, 0], support: { kind: 'walls' } })
 })
 
 test('curved wall roof builder reuses its existing hosted roof', () => {
diff --git a/wiki/architecture/vertical-model.md b/wiki/architecture/vertical-model.md
index 91cc7be78..bb475da80 100644
--- a/wiki/architecture/vertical-model.md
+++ b/wiki/architecture/vertical-model.md
@@ -21,7 +21,7 @@ The invariant, in one sentence:
 | `level.baseElevation` | Additive offset from the computed stack position. It shifts this level and cumulatively shifts every higher level in the same building; negative offsets are valid. | Zero (the schema default). |
 | `wall.height` | Explicit body height (half wall, parapet, or a raised-support draft whose ghost height must remain invariant). Ground-hosted walls always resolve top = elected base + height, including below datum; other legacy sunken supports retain their absolute-top constraint. | **Plane-bound** (the default for ordinary datum placement): the top follows `getWallPlaneTop` — `min(level height, lowest covering-slab underside over the span)`. |
 | `ceiling.height` | Explicit custom height, write-clamped to the bound. | **Follows the level**: resolves live to `getCeilingClampBound` = `min(level height, covering underside) − 0.01`. |
-| `roof.sourceWallIds` | Wall footprint whose highest resolved top drives `roof.position[1]` in the roof's level frame. Room and curved-wall creation persist these IDs. | Manual Y; existing roofs without recorded source walls remain unchanged. Editing Y in the roof panel removes this binding. Roof-surface attachments use `support` instead. |
+| `roof.support.kind` | `walls` follows the highest spatially matched wall top in the roof’s level frame; `level` keeps custom Y; `roof` retains its roof-surface attachment rule. Room and curved-wall creation write `walls`; free-drawn rectangles write `level` at Y 0. | Existing roofs remain custom (`level`); no load migration enables following. |
 | `slab.elevation` | The walking surface (top), level-local. | Default 0.05. |
 | `slab.thickness` | Grows **downward**: the solid occupies `[elevation − thickness, elevation]`. | Default 0.05. |
 | `slab.recessed` | Recess intent: open shell whose floor is `elevation` and whose rim is `recessedRimElevation`. Excluded from "covering" queries and wall-face adoption. | Solid slab. |
@@ -36,7 +36,7 @@ The invariant, in one sentence:
 
 Two schema rules protect these semantics:
 
-- **No Zod defaults on meaning-bearing fields.** `level.height`, `wall.height`, `ceiling.height`, `roof.sourceWallIds`, `stair.totalRise` are `.optional()` with no `.default()` — absence is data. Creation sites write values explicitly; `migrateNodes` output is cast, not parsed, so a schema default would never materialize on legacy load anyway.
+- **No Zod defaults on meaning-bearing fields.** `level.height`, `wall.height`, `ceiling.height`, `stair.totalRise` are `.optional()` with no `.default()` — absence is data. Creation sites write values explicitly; `migrateNodes` output is cast, not parsed, so a schema default would never materialize on legacy load anyway.
 - **The store deletes explicit-`undefined` keys.** `updateNode(id, { height: undefined })` removes the key (see `mergeNodeUpdate` in `node-actions.ts`). Legacy plane-bound walls may still omit `height`; the wall panel resolves and materializes their current body height before enabling terrain infill. Ceiling and stair follow modes continue to derive from field presence — no persisted mode enums.
 
 ## Resolution helpers (use these, never `?? 2.5`)
@@ -50,7 +50,7 @@ Two schema rules protect these semantics:
 | `getCeilingClampBound`, `getCoveringSlabUndersideAt` | `services/storey.ts` | Ceiling bound; the cross-level covering query (level above, non-recessed slabs) |
 | `resolveCeilingHeight` | `services/level-height.ts` | A ceiling's effective height (explicit or follows) |
 | `resolveStairTotalRise`, `syncStairRises` | `systems/stair/stair-rise.ts` | Stair rise precedence + straight-flight convergence |
-| `resolveRoofElevation`, `resolveRoofWallTopElevation` | `systems/roof/roof-elevation.ts` | Highest source-wall top, including explicit heights and elected bases, converted to the roof's level frame |
+| `resolveRoofElevation`, `resolveRoofWallTopElevation` | `systems/roof/roof-elevation.ts` | Highest spatially matched wall top for `walls` support, including explicit heights and elected bases, converted to the roof's level frame |
 | `computeWallSlabSupport`, `getSlabSupportForItem`, `getSupportCandidatesForFootprint` | `systems/slab/slab-support.ts` + spatial-grid manager | Support election (rendered polygons, host-preferring, optional `maxElevation` cap) |
 | `resolveSlabPlacementElevation` | `systems/slab/slab-placement.ts` | Translates a solid slab's authored top/thickness interval onto a captured base plane; recessed slabs stay level-relative |
 | `getSlabBaseElevation`, `applySlabBaseElevationChange`, `applySlabThicknessChange` | `nodes/slab/elevation-limit.ts` | Separates whole-body underside placement from fixed-base thickness editing |
@@ -136,7 +136,7 @@ Because community autosave only persists after the first post-load edit, the mig
 
 ## Gotchas
 
-- **Wall-footprint roofs track their source walls.** `RoofElevationSystem` re-derives Y on wall, slab, level, building, site, and roof edits, history-paused and one microtask after store updates so the spatial grid has settled. Because the originating commit has already been captured, settled updates publish a separate scene commit without adding an undo step; an outer gesture's history pause retains commit ownership. The system preserves XZ and rotation; missing source walls are ignored, and losing every source preserves the last Y. Negative level-local Y is valid when the wall tops lie below the roof's containing level. Clone paths must remap `sourceWallIds` with the walls; preset storage strips them through `hostRefFields`.
+- **Only `support.kind: 'walls'` roofs follow walls.** The resolver projects the roof’s XZ centre onto its parent level’s lower neighbour, selected by `findLevelBelowId` from `getLevelElevations` in the same building stack (ordinals need not be consecutive). It uses the smallest enclosing room at that point and takes the highest resolved wall top without clamping to the storey. Conical roofs match curved walls by arc centre and radius against their transformed segment footprint, without a wall-ID binding. No matching enclosure or arc freezes Y and preserves follow intent, so redrawing walls resumes following. Negative level-local Y is valid: 2.5 m walls under a 3 m storey put the roof at −0.5 m. `RoofElevationSystem` re-derives Y only for following roofs on wall, slab, level, building, site, and roof edits, history-paused and one microtask after store updates so the spatial grid has settled. Settled updates publish a separate scene commit without adding an undo step; an outer gesture’s history pause retains commit ownership. The panel’s “Follows walls” choice enables this rule; “Custom” writes `level` and keeps Y. An explicit Y change exceeding 1e-4 m in the panel or 3D move handle switches to `level` in the same patch; XZ-only moves retain `walls` and re-resolve spatially. Undo/redo restores mode and Y together. Roof-surface attachments hide this mode control and retain their own rule. Schema version stays 3 and load never opts existing roofs into following.
 - **Ordinals are semantic.** `level < 0` renders "Basement N"; `level === 0` is the ground-floor lookup. Never renumber without the zero anchor.
 - **Boundary geometry.** Auto slabs derive polygons from wall centerlines, so wall/ceiling clamp samples sit exactly on polygon edges — always use the boundary-inclusive band-overlap helpers (`wallOverlapsSlabFootprint`, `slabCoversPoint`), never raw ray-cast point-in-polygon on those paths.
 - **Straight stairs build from stored segment heights**, not the resolved rise — any rise change must go through `syncStairRises` (applied by `StairOpeningSystem`, history-paused, one microtask after store updates so the spatial grid has settled).

From f38c10568ce9062da33bf131924e519af463b1ac Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Thu, 10 Sep 2026 10:57:36 -0400
Subject: [PATCH 26/27] fix(roof): pick supporting walls by footprint overlap,
 not closed-room membership

A room missing a wall, or an L-room whose centre falls outside, left the
roof frozen. Walls whose band overlaps a segment footprint on the level
below now count; segment-less roofs keep the point-in-room lookup.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 .../src/systems/roof/roof-elevation.test.ts   | 18 ++++++++
 .../core/src/systems/roof/roof-elevation.ts   | 46 ++++++++++++++++---
 2 files changed, 58 insertions(+), 6 deletions(-)

diff --git a/packages/core/src/systems/roof/roof-elevation.test.ts b/packages/core/src/systems/roof/roof-elevation.test.ts
index 59ef383ac..39f768f4a 100644
--- a/packages/core/src/systems/roof/roof-elevation.test.ts
+++ b/packages/core/src/systems/roof/roof-elevation.test.ts
@@ -51,6 +51,24 @@ function scene(heights: Array<number | undefined>) {
 }
 
 describe('resolveRoofElevation', () => {
+  test('follows the walls under the segment footprint when the room is not closed', () => {
+    const { roof, walls, nodes, level } = scene([4.5])
+    // Drop the east wall: point-in-room finds no enclosure, the footprint still does.
+    const east = walls[1]!
+    delete nodes[east.id]
+    level.children = level.children.filter((id) => id !== east.id)
+    const segment = RoofSegmentNode.parse({
+      parentId: roof.id,
+      roofType: 'gable',
+      width: 4,
+      depth: 3,
+      position: [0, 0, 0],
+    })
+    roof.children = [segment.id]
+    nodes[segment.id] = segment
+    expect(resolveRoofElevation(roof, nodes)).toBe(1.5)
+  })
+
   test('honors an explicit height above the storey in the roof level frame', () => {
     const { roof, nodes } = scene([4.5])
     expect(resolveRoofElevation(roof, nodes)).toBe(1.5)
diff --git a/packages/core/src/systems/roof/roof-elevation.ts b/packages/core/src/systems/roof/roof-elevation.ts
index a8b8c9cea..328be7b00 100644
--- a/packages/core/src/systems/roof/roof-elevation.ts
+++ b/packages/core/src/systems/roof/roof-elevation.ts
@@ -5,6 +5,7 @@ import {
 import { resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync'
 import type { AnyNode, LevelNode, RoofNode, RoofSegmentNode, WallNode } from '../../schema'
 import { findLevelBelowId, getLevelElevations } from '../../services/storey'
+import { wallOverlapsSlabFootprint } from '../slab/slab-support'
 import { getWallArcData } from '../wall/wall-curve'
 import { resolveRoomRoofFootprintOnLevel } from './roof-footprint'
 
@@ -42,25 +43,58 @@ export function resolveRoofElevation(
       (node): node is RoofSegmentNode =>
         node?.type === 'roof-segment' && node.roofType === 'conical',
     )
+  const cos = Math.cos(roof.rotation)
+  const sin = Math.sin(roof.rotation)
+  const toLevel = (x: number, z: number): [number, number] => [
+    roof.position[0] + x * cos + z * sin,
+    roof.position[2] - x * sin + z * cos,
+  ]
+  // Walls under the footprint, closed room or not: a room missing a wall, an
+  // L-shaped room whose centre falls outside, or a redrawn enclosure all still
+  // hold the roof up. The band test is curve- and thickness-aware and
+  // boundary-inclusive, so perimeter walls on the footprint edge count.
+  const footprints = roof.children
+    .map((id) => nodes[id])
+    .filter((node): node is RoofSegmentNode => node?.type === 'roof-segment')
+    .map((segment) => {
+      const c = Math.cos(segment.rotation)
+      const s = Math.sin(segment.rotation)
+      const halfW = segment.width / 2
+      const halfD = segment.depth / 2
+      const corners: Array<[number, number]> = [
+        [-halfW, -halfD],
+        [halfW, -halfD],
+        [halfW, halfD],
+        [-halfW, halfD],
+      ]
+      return corners.map(([x, z]) =>
+        toLevel(segment.position[0] + x * c + z * s, segment.position[2] - x * s + z * c),
+      )
+    })
   const wallIds = conicalSegments.length
     ? below.children.filter((id) => {
         const wall = nodes[id]
         if (wall?.type !== 'wall') return false
         const arc = getWallArcData(wall)
         if (!arc) return false
-        const cos = Math.cos(roof.rotation)
-        const sin = Math.sin(roof.rotation)
         return conicalSegments.some((segment) => {
-          const centerX = roof.position[0] + segment.position[0] * cos + segment.position[2] * sin
-          const centerZ = roof.position[2] - segment.position[0] * sin + segment.position[2] * cos
+          const [centerX, centerZ] = toLevel(segment.position[0], segment.position[2])
           return (
             Math.hypot(arc.center.x - centerX, arc.center.y - centerZ) <= 1e-4 &&
             Math.abs(arc.radius - segment.width / 2) <= 1e-4
           )
         })
       })
-    : (resolveRoomRoofFootprintOnLevel(below.id, nodes, [roof.position[0], roof.position[2]])
-        ?.wallIds ?? [])
+    : footprints.length
+      ? below.children.filter((id) => {
+          const wall = nodes[id]
+          return (
+            wall?.type === 'wall' &&
+            footprints.some((polygon) => wallOverlapsSlabFootprint(wall, polygon))
+          )
+        })
+      : (resolveRoomRoofFootprintOnLevel(below.id, nodes, [roof.position[0], roof.position[2]])
+          ?.wallIds ?? [])
 
   let highest: number | undefined
   for (const id of wallIds) {

From fb945b167e08131de8daff317fbbabc91c2f873f Mon Sep 17 00:00:00 2001
From: Wassim SAMAD <wass08@gmail.com>
Date: Thu, 10 Sep 2026 11:05:49 -0400
Subject: [PATCH 27/27] fix(roof): parent room roofs to the storey above their
 walls; follow walls on the roof's own level too

Armed on the walls' level, the tool parented the roof to that level and
the follow rule only looked one storey down, so a Floor 1 roof dropped to
the Level 0 wall tops. The roof now goes to the level above the walls
when one exists (top floor keeps it on the walls' level), and the
resolver considers walls on the roof's level and the one below.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013hQVFZ62S1qJDsBM9ferYc
---
 .../src/systems/roof/roof-elevation.test.ts   | 21 ++++++++++++----
 .../core/src/systems/roof/roof-elevation.ts   | 24 ++++++++++++++-----
 packages/nodes/src/roof/tool.test.ts          | 21 ++++++++++++++++
 packages/nodes/src/roof/tool.tsx              | 13 ++++++++--
 4 files changed, 67 insertions(+), 12 deletions(-)

diff --git a/packages/core/src/systems/roof/roof-elevation.test.ts b/packages/core/src/systems/roof/roof-elevation.test.ts
index 39f768f4a..827076622 100644
--- a/packages/core/src/systems/roof/roof-elevation.test.ts
+++ b/packages/core/src/systems/roof/roof-elevation.test.ts
@@ -51,6 +51,16 @@ function scene(heights: Array<number | undefined>) {
 }
 
 describe('resolveRoofElevation', () => {
+  test("follows walls on the roof's own level when it sits on the top floor", () => {
+    const { roof, level, upper, nodes } = scene([2.5])
+    // Move the roof onto the walls' level: no storey above, roof and walls share it.
+    delete nodes[upper.id]
+    roof.parentId = level.id
+    level.children = [...level.children, roof.id]
+    roof.position = [2, 2.5, 1]
+    expect(resolveRoofElevation(roof, nodes)).toBe(2.5)
+  })
+
   test('follows the walls under the segment footprint when the room is not closed', () => {
     const { roof, walls, nodes, level } = scene([4.5])
     // Drop the east wall: point-in-room finds no enclosure, the footprint still does.
@@ -204,18 +214,21 @@ describe('resolveRoofElevation', () => {
     expect(resolveRoofElevation(roof, next)).toBe(1)
   })
 
-  test('never substitutes walls on the roof parent level or a more distant floor', () => {
+  test('looks at its own level and the one below, never two floors down', () => {
     const { level, upper, roof, nodes } = scene([4])
     const middle = LevelNode.parse({ level: 0.5, height: 2 })
+    // A wall-less storey slipped between roof and walls: the walls are now two
+    // floors down and the roof freezes where it is.
+    expect(resolveRoofElevation(roof, { ...nodes, [middle.id]: middle })).toBe(0)
+    // Walls on the roof's own level count (top floor without a storey above).
     const onParent = room(upper, [20])
     const next = {
       ...nodes,
-      [middle.id]: middle,
       [upper.id]: { ...upper, children: [...upper.children, ...onParent.map((wall) => wall.id)] },
       ...Object.fromEntries(onParent.map((wall) => [wall.id, wall])),
     }
-    expect(resolveRoofElevation(roof, next)).toBe(0)
-    expect(resolveRoofElevation({ ...roof, parentId: level.id }, nodes)).toBe(0)
+    expect(resolveRoofElevation(roof, next)).toBe(20)
+    expect(resolveRoofElevation({ ...roof, parentId: level.id }, nodes)).toBe(4)
   })
 
   test('matches a conical arc by centre and radius after replacement, without an enclosure', () => {
diff --git a/packages/core/src/systems/roof/roof-elevation.ts b/packages/core/src/systems/roof/roof-elevation.ts
index 328be7b00..1e75ab60f 100644
--- a/packages/core/src/systems/roof/roof-elevation.ts
+++ b/packages/core/src/systems/roof/roof-elevation.ts
@@ -33,9 +33,13 @@ export function resolveRoofElevation(
   const levelId = resolveLevelId(roof, nodes)
   if (nodes[levelId]?.type !== 'level') return roof.position[1]
   const elevations = getLevelElevations(nodes)
+  // A roof usually sits on the storey above its walls, but the top floor (or a
+  // roof armed from the walls' own level) keeps roof and walls on one level.
   const belowId = findLevelBelowId(levelId, elevations)
-  const below = belowId ? nodes[belowId] : undefined
-  if (below?.type !== 'level') return roof.position[1]
+  const candidateWallIds = [levelId, belowId]
+    .map((id) => (id ? nodes[id] : undefined))
+    .filter((node): node is LevelNode => node?.type === 'level')
+    .flatMap((level) => level.children)
 
   const conicalSegments = roof.children
     .map((id) => nodes[id])
@@ -72,7 +76,7 @@ export function resolveRoofElevation(
       )
     })
   const wallIds = conicalSegments.length
-    ? below.children.filter((id) => {
+    ? candidateWallIds.filter((id) => {
         const wall = nodes[id]
         if (wall?.type !== 'wall') return false
         const arc = getWallArcData(wall)
@@ -86,15 +90,23 @@ export function resolveRoofElevation(
         })
       })
     : footprints.length
-      ? below.children.filter((id) => {
+      ? candidateWallIds.filter((id) => {
           const wall = nodes[id]
           return (
             wall?.type === 'wall' &&
             footprints.some((polygon) => wallOverlapsSlabFootprint(wall, polygon))
           )
         })
-      : (resolveRoomRoofFootprintOnLevel(below.id, nodes, [roof.position[0], roof.position[2]])
-          ?.wallIds ?? [])
+      : ([levelId, belowId]
+          .map((id) =>
+            id
+              ? resolveRoomRoofFootprintOnLevel(id as LevelNode['id'], nodes, [
+                  roof.position[0],
+                  roof.position[2],
+                ])
+              : null,
+          )
+          .find((target) => target !== null)?.wallIds ?? [])
 
   let highest: number | undefined
   for (const id of wallIds) {
diff --git a/packages/nodes/src/roof/tool.test.ts b/packages/nodes/src/roof/tool.test.ts
index 1c8d149f4..4f076ffd0 100644
--- a/packages/nodes/src/roof/tool.test.ts
+++ b/packages/nodes/src/roof/tool.test.ts
@@ -56,3 +56,24 @@ test('free-drawn rectangles stay custom at Y zero even with following preset def
   const roof = created.find(({ node }) => node.type === 'roof')?.node as RoofNode
   expect(roof).toMatchObject({ support: { kind: 'level' }, position: [2, 0, 1.5] })
 })
+
+test("room creation from the walls' own level still parents the roof to the level above", () => {
+  const { upper, nodes, created, sceneApi } = setup()
+  const level = Object.values(nodes).find((node) => node.type === 'level' && node.id !== upper.id)!
+  const target = resolveRoomRoofFootprint(level.id as LevelNode['id'], nodes, [2, 1])!
+  commitRoofFootprint(sceneApi, level.id as LevelNode['id'], target, false)
+  const roof = created.find(({ node }) => node.type === 'roof')!
+  expect(roof.parentId).toBe(upper.id)
+  expect(roof.node).toMatchObject({ support: { kind: 'walls' }, position: [2, -0.5, 1.5] })
+})
+
+test("room creation on the top floor keeps the roof on the walls' level at their top", () => {
+  const { upper, nodes, created, sceneApi } = setup()
+  delete nodes[upper.id]
+  const level = Object.values(nodes).find((node) => node.type === 'level')!
+  const target = resolveRoomRoofFootprint(level.id as LevelNode['id'], nodes, [2, 1])!
+  commitRoofFootprint(sceneApi, level.id as LevelNode['id'], target, false)
+  const roof = created.find(({ node }) => node.type === 'roof')!
+  expect(roof.parentId).toBe(level.id)
+  expect(roof.node).toMatchObject({ support: { kind: 'walls' }, position: [2, 2.5, 1.5] })
+})
diff --git a/packages/nodes/src/roof/tool.tsx b/packages/nodes/src/roof/tool.tsx
index 0ca51d406..b21780b2c 100644
--- a/packages/nodes/src/roof/tool.tsx
+++ b/packages/nodes/src/roof/tool.tsx
@@ -4,7 +4,9 @@ import {
   type AnyNodeId,
   collectAlignmentAnchors,
   emitter,
+  findLevelAboveId,
   type GridEvent,
+  getLevelElevations,
   getWallArcData,
   getWallBaseElevationForNodes,
   getWallEffectiveHeightForNodes,
@@ -16,6 +18,7 @@ import {
   type RoofType,
   RoofType as RoofTypeSchema,
   resolveBuildingForLevel,
+  resolveLevelId,
   resolveRoomRoofFootprint,
   type SceneApi,
   sceneRegistry,
@@ -374,12 +377,18 @@ export const commitRoofFootprint = (
     position: [0, 0, 0],
     rotation: quarterTurn ? Math.PI / 2 : 0,
   })
+  // A roof belongs to the storey above the walls it covers, whichever level the
+  // tool was armed on; the top floor keeps it on the walls' own level.
+  const firstWall = target.wallIds.map((id) => nodes[id]).find((node) => node?.type === 'wall')
+  const wallsLevelId = firstWall ? resolveLevelId(firstWall, nodes) : levelId
+  const parentLevelId = (findLevelAboveId(wallsLevelId, getLevelElevations(nodes)) ??
+    wallsLevelId) as LevelNode['id']
   const roof = RoofNode.parse({
     ...defaults,
     name: `Roof ${roofCount + 1}`,
     position: [
       target.center[0],
-      resolveRoofFootprintElevation(levelId, target, nodes),
+      resolveRoofFootprintElevation(parentLevelId, target, nodes),
       target.center[1],
     ],
     rotation: target.rotation,
@@ -387,7 +396,7 @@ export const commitRoofFootprint = (
     children: [segment.id],
   })
   createRoofNodes(sceneApi, [
-    { node: roof, parentId: levelId },
+    { node: roof, parentId: parentLevelId },
     { node: segment, parentId: roof.id },
   ])
   triggerSFX('sfx:structure-build')