@pascal-app/editor 0.9.1 → 0.9.2

package/src/components/editor-2d/renderers/floorplan-registry-layer.tsx

@@ -2,27 +2,34 @@
 
 import {
   type AnyNode,
+  type AnyNodeDefinition,
   type AnyNodeId,
-  type FloorplanAffordancePoint,
+  createSceneApi,
+  emitter,
   type FloorplanAffordanceSession,
   type FloorplanGeometry,
   type FloorplanPalette,
   type FloorplanPoint,
   type GeometryContext,
+  isNodeKindEnabled,
+  isRegistryMovable,
   kindsWithFloorplanScope,
+  type LiveNodeOverrides,
+  type LiveTransform,
   nodeRegistry,
   pauseSceneHistory,
   resolveBuildingForLevel,
+  resolveSelectionProxyId,
   resumeSceneHistory,
   useInteractive,
   useLiveNodeOverrides,
   useLiveTransforms,
   useScene,
 } from '@pascal-app/core'
-import { useAlignmentGuides } from '@pascal-app/editor'
 import { useViewer } from '@pascal-app/viewer'
 import {
   memo,
+  type MouseEvent as ReactMouseEvent,
   type PointerEvent as ReactPointerEvent,
   useCallback,
   useEffect,
@@ -30,10 +37,45 @@ import {
   useRef,
   useState,
 } from 'react'
+import { markToolCancelConsumed } from '../../../hooks/use-keyboard'
+import { ROTATE_HANDLE_DRAG_LABEL } from '../../../lib/contextual-help'
+import {
+  canDirectRotateNode,
+  resolveDirectManipulationNode,
+  resolveDirectRotationDragDelta,
+  resolveDirectRotationPatch,
+  snapDirectRotationDelta,
+} from '../../../lib/direct-manipulation'
+import { createEditorApi } from '../../../lib/editor-api'
+import { clientToPlan } from '../../../lib/floorplan/plan-coords'
+import {
+  type ActiveInteractionScope,
+  boundaryReshapeScope,
+  controlPointReshapeScope,
+  curveReshapeScope,
+  endpointReshapeScope,
+  holeEditScope,
+  tangentReshapeScope,
+} from '../../../lib/interaction/scope'
 import { sfxEmitter } from '../../../lib/sfx-bus'
+import { clearSurfacePlanSnapFeedback } from '../../../lib/surface-plan-snap'
+import useDirectManipulationFeedback from '../../../store/use-direct-manipulation-feedback'
 import useEditor from '../../../store/use-editor'
+import useInteractionScope, {
+  useEndpointReshape,
+  useMovingNode,
+} from '../../../store/use-interaction-scope'
+import { startGroupPickUp } from '../../editor/group-actions'
+import { classifyParticipant } from '../../editor/group-transform-shared'
+import { suppressBoxSelectForPointer } from '../../tools/select/box-select-state'
+import {
+  FloorplanGroupSelectionBox,
+  startFloorplanGroupMove,
+  startFloorplanGroupRotate,
+} from '../floorplan-group-move'
 import { useFloorplanRender } from '../floorplan-render-context'
 import { FloorplanGeometryRenderer } from './floorplan-geometry-renderer'
+import { resolveFloorplanLabelAngle } from './floorplan-label-angle'
 
 /**
  * Registry-driven floor-plan layer.
@@ -70,6 +112,9 @@ const ENDPOINT_HIT_STROKE_WIDTH_PX = 18
 const ENDPOINT_HOVER_GLOW_STROKE_WIDTH_PX = 16
 const ENDPOINT_HOVER_RING_STROKE_WIDTH_PX = 7
 const HOVER_TRANSITION = 'opacity 180ms cubic-bezier(0.2, 0, 0, 1)'
+const DIRECT_DRAG_THRESHOLD_PX = 4
+const DIRECT_ROTATE_EPSILON = 1e-6
+const DIRECT_ROTATE_RADIANS_PER_PIXEL = Math.PI / 180
 
 /**
  * Snapshot of node fields captured at drag-start, used by the single-undo
@@ -82,11 +127,18 @@ type NodeSnapshot = { id: AnyNodeId; data: Record<string, unknown> }
 
 type ActiveDrag = {
   pointerId: number
+  captureTarget: Element
   /** Key for the visual `active` flag — e.g. `${nodeId}:${endpoint}`. */
   handleId: string
   session: FloorplanAffordanceSession
   snapshots: NodeSnapshot[]
   historyPaused: boolean
+  /**
+   * Last plan point handed to `session.apply` (the grab point until the first
+   * move). Lets the modifier-key listeners re-run the session immediately on
+   * an Alt/Shift flip instead of waiting for the next pointer move.
+   */
+  lastPlanPoint: FloorplanPoint
   /**
    * Set only for rotate-arrow drags (handles that carry a `pivot`). Drives
    * the live angle wedge + degree readout — the 2D twin of the 3D rotate
@@ -94,6 +146,110 @@ type ActiveDrag = {
    * rotate affordance measures it: `atan2(pointer − pivot)`.
    */
   rotation?: { pivot: FloorplanPoint; initialAngle: number; radius: number }
+  /**
+   * Node id of the reshaping scope this drag began (boundary / curve / endpoint
+   * edits), so the matching `endIf` on release/cancel tears down exactly this
+   * scope. Unset for affordances that drive no snapping scope (resize / rotate).
+   */
+  reshapeScopeNodeId?: string
+}
+
+type FloorplanAffordanceCancelEffects = {
+  restoreSnapshots: (snapshots: NodeSnapshot[]) => void
+  resumeHistory: () => void
+  clearPreview: (id: AnyNodeId) => void
+  clearSnapFeedback: () => void
+  endReshapeScope: (drag: ActiveDrag) => void
+  clearDragFeedback?: () => void
+}
+
+export function cancelFloorplanAffordanceDrag(
+  dragRef: { current: ActiveDrag | null },
+  effects: FloorplanAffordanceCancelEffects,
+  pointerId?: number,
+): boolean {
+  const drag = dragRef.current
+  if (!drag || (pointerId !== undefined && pointerId !== drag.pointerId)) return false
+
+  // Clear ownership before cleanup so a queued pointer-up cannot commit the
+  // session while cancellation side effects are still running.
+  dragRef.current = null
+
+  if (drag.captureTarget.hasPointerCapture?.(drag.pointerId)) {
+    drag.captureTarget.releasePointerCapture?.(drag.pointerId)
+  }
+
+  effects.restoreSnapshots(drag.snapshots)
+  if (drag.historyPaused) {
+    effects.resumeHistory()
+    drag.historyPaused = false
+  }
+  effects.clearSnapFeedback()
+  for (const id of drag.session.affectedIds) effects.clearPreview(id)
+  effects.endReshapeScope(drag)
+  effects.clearDragFeedback?.()
+  return true
+}
+
+export function subscribeFloorplanAffordanceToolCancel(
+  cancelActiveDrag: () => boolean,
+  consumeToolCancel: () => void,
+): () => void {
+  const onToolCancel = () => {
+    if (cancelActiveDrag()) consumeToolCancel()
+  }
+  emitter.on('tool:cancel', onToolCancel)
+  return () => emitter.off('tool:cancel', onToolCancel)
+}
+
+// Map a floor-plan affordance to the reshaping scope it represents, so the
+// dispatcher can drive the contextual snapping HUD (the chip) AND make
+// `getActiveSnapContext()` resolve the right mode-set during the edit. Geometry
+// edits that set a direction/shape map to a scope; resize / rotate / body-move
+// affordances return `null` (no polygon/wall snapping chip). Keyed off the
+// affordance name the kinds register (`move-vertex` / `move-edge` / `add-vertex`
+// / `curve` / `move-endpoint`).
+function affordanceReshapeScope(
+  affordance: string,
+  nodeId: string,
+  payload: unknown,
+): ActiveInteractionScope | null {
+  if (affordance.includes('vertex') || affordance.includes('edge')) {
+    const holeIndex = (payload as { holeIndex?: number } | undefined)?.holeIndex
+    return holeIndex !== undefined
+      ? holeEditScope({ nodeId, holeIndex })
+      : boundaryReshapeScope(nodeId)
+  }
+  if (affordance.includes('curve')) {
+    return curveReshapeScope(nodeId)
+  }
+  if (affordance.includes('control-point')) {
+    const index = (payload as { index?: number } | undefined)?.index ?? 0
+    return controlPointReshapeScope(nodeId, index)
+  }
+  if (affordance.includes('tangent')) {
+    const target = payload as { index?: number; side?: 'in' | 'out' } | undefined
+    return tangentReshapeScope(nodeId, target?.index ?? 0, target?.side ?? 'out')
+  }
+  if (affordance.includes('endpoint')) {
+    const endpoint = (payload as { endpoint?: 'start' | 'end' } | undefined)?.endpoint ?? 'end'
+    return endpointReshapeScope(nodeId, endpoint)
+  }
+  // Roof-segment width/depth resize — a no-angle dimension edit, so the
+  // no-angle 'polygon' snap set (grid / lines / off) via a boundary scope.
+  // Matched exactly so a still-legacy `*-resize` affordance on another kind
+  // doesn't get a chip its snap math can't honour yet.
+  if (affordance === 'roof-segment-resize') {
+    return boundaryReshapeScope(nodeId)
+  }
+  // 2D corner rotate-arrow (column / elevator / roof-segment / shelf / spawn /
+  // stair). Begin the same handle-drag scope the 3D rotate gizmo uses, label-
+  // matched, so the contextual HUD shows the "Shift = rotate freely" hint over
+  // the drag. The affordance applies the 15° angle step itself.
+  if (affordance.includes('rotate')) {
+    return { kind: 'handle-drag', nodeId, handle: ROTATE_HANDLE_DRAG_LABEL }
+  }
+  return null
 }
 
 /**
@@ -109,6 +265,61 @@ type RotationOverlayState = {
   sweep: number
 }
 
+type FloorplanEntryDescriptor = {
+  id: AnyNodeId
+  node: AnyNode
+  dependsOnSiblingInputs: boolean
+  ctxOverrides?: FloorplanContextOverrides
+}
+
+type NodeDeps = {
+  node: AnyNode
+  live: LiveTransform | undefined
+  unit: 'metric' | 'imperial'
+  selected: boolean
+  highlighted: boolean
+  hovered: boolean
+  moving: boolean
+  liveOverride: LiveNodeOverrides | undefined
+  palette: FloorplanPalette | undefined
+  siblingEpoch: number
+  committedNodes: Record<string, AnyNode> | null
+  dependencyNodes: AnyNode[]
+  interactiveElevators: unknown
+}
+
+type CacheEntry = {
+  deps: NodeDeps
+  base: FloorplanGeometry | null
+  overlay: FloorplanGeometry | null
+  node: AnyNode
+}
+
+type LevelDataCacheEntry = {
+  nodes: Record<string, AnyNode>
+  liveOverrides: Map<string, LiveNodeOverrides>
+  ids: readonly AnyNodeId[]
+  value: unknown
+}
+
+type FloorplanContextOverrides = {
+  children: AnyNode[]
+  siblings: AnyNode[]
+  parent: AnyNode | null
+}
+
+type FloorplanLevelDataHook = (args: {
+  siblings: ReadonlyArray<AnyNode>
+  nodes: Record<string, AnyNode>
+}) => unknown
+
+type FloorplanRenderPass = 'base' | 'overlay'
+
+const POINTER_CURSOR_STYLE = { cursor: 'pointer' } as const
+// Group members advertise the drag-to-move-the-selection gesture.
+const MOVE_CURSOR_STYLE = { cursor: 'move' } as const
+const NO_POINTER_EVENTS_STYLE = { pointerEvents: 'none' } as const
+
 function snapshotNode(node: AnyNode): NodeSnapshot {
   // Shallow-clone every non-id, non-type field. Arrays / vec tuples are
   // deep-cloned to detach from the live store reference.
@@ -124,25 +335,32 @@ function snapshotsToUpdates(snapshots: NodeSnapshot[]) {
   return snapshots.map((s) => ({ id: s.id, data: s.data }))
 }
 
+// Stable empty sentinel used by per-entry builders while the floor plan is
+// hidden; committed scene edits still flow through `useScene`.
+const EMPTY_LIVE_OVERRIDES: Map<string, LiveNodeOverrides> = new Map()
+
 export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
   const selectedLevelId = useViewer((s) => s.selection.levelId)
   const selectedBuildingId = useViewer((s) => s.selection.buildingId)
+  const unit = useViewer((s) => s.unit)
+  const showMeasurements = useViewer((s) => s.showMeasurements)
   const selectedIds = useViewer((s) => s.selection.selectedIds)
   const previewSelectedIds = useViewer((s) => s.previewSelectedIds)
   const hoveredId = useViewer((s) => s.hoveredId)
+  const activeRotateNodeId = useDirectManipulationFeedback((s) => s.activeRotateNodeId)
   const setHoveredId = useViewer((s) => s.setHoveredId)
   const setSelection = useViewer((s) => s.setSelection)
   const nodes = useScene((s) => s.nodes)
+  const installedPlugins = useScene((s) => s.installedPlugins)
+  const movingNode = useMovingNode()
   // When a building is being moved, its explicit selection may be
   // cleared as part of the move handoff. Fall back to the
   // mid-drag building id so the dimmed floor keeps rendering
   // throughout the gesture.
-  const movingBuildingId = useEditor((state) => {
-    const moving = state.movingNode
-    if (!moving) return null
-    const def = nodeRegistry.get(moving.type)
-    return def?.capabilities?.floorplanLevelContainer ? moving.id : null
-  })
+  const movingBuildingId =
+    movingNode && nodeRegistry.get(movingNode.type)?.capabilities?.floorplanLevelContainer
+      ? movingNode.id
+      : null
   const ambientBuildingSourceId = selectedBuildingId ?? movingBuildingId
 
   // When only a building is in scope (no specific level), fall back to
@@ -152,7 +370,7 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
   const ambientLevelId = useMemo<AnyNodeId | null>(() => {
     if (selectedLevelId || !ambientBuildingSourceId) return null
     const building = nodes[ambientBuildingSourceId]
-    if (!building || building.type !== 'building') return null
+    if (building?.type !== 'building') return null
     let zero: AnyNodeId | null = null
     let lowestId: AnyNodeId | null = null
     let lowestIdx = Number.POSITIVE_INFINITY
@@ -175,8 +393,8 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
   const levelId = selectedLevelId ?? ambientLevelId
   const isAmbient = !selectedLevelId && !!ambientLevelId
   const renderCtx = useFloorplanRender()
-  const movingNode = useEditor((s) => s.movingNode)
   const setMovingNode = useEditor((s) => s.setMovingNode)
+  const setMovingNodeOrigin = useEditor((s) => s.setMovingNodeOrigin)
   // Door / window placement (both build and move) needs the SVG's
   // background click handler to run — it finds the closest wall via
   // `findClosestWallPoint` and emits `wall:click` for the door / window
@@ -189,7 +407,7 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
   const editorTool = useEditor((s) => s.tool)
   const structureLayer = useEditor((s) => s.structureLayer)
   const floorplanSelectionTool = useEditor((s) => s.floorplanSelectionTool)
-  const movingFenceEndpoint = useEditor((s) => s.movingFenceEndpoint)
+  const endpointReshape = useEndpointReshape()
   const isOpeningPlacementActive =
     (editorPhase === 'structure' &&
       editorMode === 'build' &&
@@ -200,24 +418,30 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
     floorplanSelectionTool === 'marquee' &&
     structureLayer !== 'zones' &&
     !movingNode &&
-    !movingFenceEndpoint
-  // Subscribe to the live-transforms map ref so the layer re-renders
-  // whenever a 3D mover publishes a per-frame position (see
-  // `usePlacementCoordinator`). Without this the 2D floor plan only
-  // updates after 3D commit — the 3D drag would look frozen in 2D.
-  const liveTransforms = useLiveTransforms((s) => s.transforms)
-  // Same reactivity hook for elevator runtime state — `useInteractive`
-  // tracks the current / fallback level + cab travel, `useLiveNode
-  // Overrides` carries live-edit overrides from the inspector. Builders
-  // read both via `getState()` inside `def.floorplan`; subscribing here
-  // is what forces the layer to re-render when they change.
-  const liveOverrides = useLiveNodeOverrides((s) => s.overrides)
+    !endpointReshape
+  // While the floor plan is not on screen (pure 3D view), per-entry live
+  // selectors freeze to `undefined` so drag publishes do not re-render the
+  // hidden floor-plan tree.
+  const floorplanVisible = useEditor((s) => s.viewMode !== '3d')
+  // Elevator builders read runtime state imperatively, so entries include this
+  // rare-changing ref in their cache deps.
   const interactiveElevators = useInteractive((s) => s.elevators)
 
   const selectedIdSet = useMemo(() => new Set(selectedIds), [selectedIds])
   // Marquee preview selection — matches the legacy `highlightedIdSet` use
   // (filter-while-marquee), surfaces selection chrome without keyboard focus.
   const highlightedIdSet = useMemo(() => new Set(previewSelectedIds), [previewSelectedIds])
+  // Multi-selection: members show highlight only (per-node edit chrome hidden)
+  // and transformable members advertise the drag-to-move gesture.
+  const isMultiSelect = selectedIds.length > 1
+  const groupParticipantIdSet = useMemo(() => {
+    if (selectedIds.length < 2 || !levelId) return null
+    return new Set(
+      selectedIds.filter(
+        (id) => classifyParticipant(nodes[id as AnyNodeId], levelId, nodes) !== null,
+      ),
+    )
+  }, [selectedIds, levelId, nodes])
 
   // Interactive state lives in refs; only the visible feedback bits go
   // into React state to keep re-renders cheap during drag.
@@ -225,12 +449,89 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
   const [hoveredHandleId, setHoveredHandleId] = useState<string | null>(null)
   const [activeDragId, setActiveDragId] = useState<string | null>(null)
   const [rotationOverlay, setRotationOverlay] = useState<RotationOverlayState | null>(null)
+  const geometryCacheRef = useRef<Map<string, CacheEntry>>(new Map())
+  const levelDataCacheRef = useRef<Map<string, LevelDataCacheEntry>>(new Map())
+  const nodesRef = useRef(nodes)
+  const [siblingEpochs, setSiblingEpochs] = useState<Map<AnyNodeId, number>>(() => new Map())
+  // Per-node sibling epoch (replaces a single global epoch). Bumped only for the
+  // nodes affected by this frame's live drags, so an unaffected wall/opening
+  // keeps its epoch and stays cached. `prevLiveFlaggedIdsRef` remembers which
+  // sibling-dependent nodes were live last frame, so a node that just STOPPED
+  // being dragged (override cleared, no commit) still gets one final rebuild to
+  // revert — its dependents (host wall, junction neighbours) don't carry its
+  // override in their own deps.
+  const nodeSiblingEpochRef = useRef<Map<AnyNodeId, number>>(new Map())
+  const prevLiveFlaggedIdsRef = useRef<AnyNodeId[]>([])
 
-  const handleSelect = useCallback(
-    (id: AnyNodeId, event: React.PointerEvent<SVGGElement>) => {
-      if (event.button !== 0) return
-      event.stopPropagation()
-      setSelection({ selectedIds: [id] })
+  useEffect(() => {
+    nodesRef.current = nodes
+  }, [nodes])
+
+  const bumpAffectedSiblingEpochs = useCallback(() => {
+    if (!floorplanVisible) return
+
+    const sceneNodes = nodesRef.current
+    const liveTransforms = useLiveTransforms.getState().transforms
+    const liveOverrides = useLiveNodeOverrides.getState().overrides
+    const liveFlaggedIds: AnyNodeId[] = []
+
+    for (const [id] of liveTransforms) {
+      const node = sceneNodes[id as AnyNodeId]
+      const def = node ? nodeRegistry.get(node.type) : null
+      if (
+        node &&
+        (def?.floorplanDependsOnSiblings ||
+          def?.floorplanSiblingOverrides ||
+          def?.floorplanAffectedIds)
+      ) {
+        liveFlaggedIds.push(id as AnyNodeId)
+      }
+    }
+    for (const [id] of liveOverrides) {
+      const node = sceneNodes[id as AnyNodeId]
+      const def = node ? nodeRegistry.get(node.type) : null
+      if (
+        node &&
+        (def?.floorplanDependsOnSiblings ||
+          def?.floorplanSiblingOverrides ||
+          def?.floorplanAffectedIds)
+      ) {
+        liveFlaggedIds.push(id as AnyNodeId)
+      }
+    }
+
+    const expandFrom = Array.from(new Set([...liveFlaggedIds, ...prevLiveFlaggedIdsRef.current]))
+    const affectedSiblingIds = computeAffectedSiblingIds(expandFrom, sceneNodes, liveOverrides)
+    const nodeSiblingEpochs = nodeSiblingEpochRef.current
+    for (const id of affectedSiblingIds) {
+      nodeSiblingEpochs.set(id, (nodeSiblingEpochs.get(id) ?? 0) + 1)
+    }
+    prevLiveFlaggedIdsRef.current = liveFlaggedIds
+    if (affectedSiblingIds.size > 0) {
+      setSiblingEpochs(new Map(nodeSiblingEpochs))
+    }
+  }, [floorplanVisible])
+
+  useEffect(() => {
+    bumpAffectedSiblingEpochs()
+    const unsubscribeTransforms = useLiveTransforms.subscribe(bumpAffectedSiblingEpochs)
+    const unsubscribeOverrides = useLiveNodeOverrides.subscribe(bumpAffectedSiblingEpochs)
+    return () => {
+      unsubscribeTransforms()
+      unsubscribeOverrides()
+    }
+  }, [bumpAffectedSiblingEpochs])
+
+  const applyEntrySelection = useCallback(
+    (id: AnyNodeId, shouldToggle: boolean) => {
+      const currentSelectedIds = useViewer.getState().selection.selectedIds
+      setSelection({
+        selectedIds: shouldToggle
+          ? currentSelectedIds.includes(id)
+            ? currentSelectedIds.filter((selectedId) => selectedId !== id)
+            : [...currentSelectedIds, id]
+          : [id],
+      })
       // Setting selection re-renders the entry — the overlay pass mounts
       // (endpoint handles, etc.), reshuffling DOM under the cursor between
       // pointerdown and click. If the click target ends up on the SVG
@@ -239,129 +540,322 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
       // selection we just set. Swallow the next click globally to break
       // that race; the listener removes itself after firing (or after a
       // safety timeout if no click follows).
-      const swallowClick = (ev: Event) => {
-        ev.stopPropagation()
-        ev.preventDefault()
-        window.removeEventListener('click', swallowClick, true)
-      }
-      window.addEventListener('click', swallowClick, true)
-      setTimeout(() => window.removeEventListener('click', swallowClick, true), 200)
+      swallowNextClick(200)
     },
     [setSelection],
   )
 
+  const handleSelect = useCallback(
+    (id: AnyNodeId, event: React.PointerEvent<SVGGElement>) => {
+      if (event.button !== 0) return
+      event.stopPropagation()
+      applyEntrySelection(id, event.metaKey || event.ctrlKey || event.shiftKey)
+    },
+    [applyEntrySelection],
+  )
+
   const handleClickStop = useCallback((event: React.MouseEvent<SVGGElement>) => {
     event.stopPropagation()
   }, [])
 
-  // Build the geometry list. `viewState` flows into ctx so kinds can
-  // theme their output and conditionally emit selection chrome.
-  //
-  // Each entry carries TWO trees:
-  //   - `base`: filled shapes, strokes, polygons, hatches — anything
-  //     that should respect the kind's z-order bucket.
-  //   - `overlay`: interactive handles (vertex / midpoint / edge / move)
-  //     and labels (text / dimension). These always render on top of
-  //     every base entry so selection chrome and node names stay visible
-  //     above walls, items, etc.
-  //
-  // The split is computed by `splitFloorplanOverlay` from the single
-  // tree the builder returns. Builders don't need to know about the
-  // partition.
-  const entries = useMemo(() => {
-    // Some builders read elevator runtime state imperatively; this keeps the memo subscribed.
-    void interactiveElevators
-
-    if (!levelId) return []
-    const out: {
-      id: AnyNodeId
-      node: AnyNode
-      base: FloorplanGeometry | null
-      overlay: FloorplanGeometry | null
-      selected: boolean
-      highlighted: boolean
-    }[] = []
+  const startDirectMoveDrag = useCallback(
+    (id: AnyNodeId, event: ReactPointerEvent<SVGGElement>): boolean => {
+      if (event.button !== 0 || !(event.metaKey || event.ctrlKey)) return false
 
-    const visit = (id: AnyNodeId) => {
-      const node = nodes[id]
-      if (!node) return
-      if ((node as { visible?: boolean }).visible === false) return
-      const def = nodeRegistry.get(node.type)
-      const builder = def?.floorplan
-      if (builder) {
-        const selected = selectedIdSet.has(id)
-        const highlighted = highlightedIdSet.has(id)
-        const hovered = hoveredId === id
-        const moving = movingNode?.id === id
-        // Live-transform override — when a mover is publishing per-frame
-        // position/rotation, render that here instead of the committed
-        // scene state. Without this the 2D floor plan would only update
-        // after commit, making the drag look frozen.
-        //
-        // The live-transform contract varies per kind (see
-        // wiki/architecture/tools.md "useLiveTransforms contract is
-        // per-kind, not generic"); position-carrying floor-placed kinds
-        // publish canonical X/Z, while slab / ceiling publish a polygon
-        // translation delta.
-        const live = liveTransforms.get(id)
-        let effectiveNode: AnyNode = node
-        if (live) {
-          const floorPlaced = def?.capabilities?.floorPlaced
-          const hasPosition = Array.isArray((node as { position?: unknown }).position)
-          if (floorPlaced && hasPosition) {
-            effectiveNode = applyPositionLiveTransform(node, live)
-          } else if (node.type === 'slab' || node.type === 'ceiling' || node.type === 'zone') {
-            const dx = live.position[0]
-            const dz = live.position[2]
-            if (dx !== 0 || dz !== 0) {
-              const surface = node as {
-                polygon: Array<[number, number]>
-                holes?: Array<Array<[number, number]>>
-              }
-              effectiveNode = {
-                ...node,
-                polygon: surface.polygon.map(([x, z]) => [x + dx, z + dz] as [number, number]),
-                holes: (surface.holes ?? []).map((h) =>
-                  h.map(([x, z]) => [x + dx, z + dz] as [number, number]),
-                ),
-              } as AnyNode
-            }
-          }
-        }
-        // Live-edit overrides: kinds whose `def.floorplan` builder
-        // reads cross-sibling data (wall miters, …) declare a
-        // `def.floorplanSiblingOverrides` hook that projects the
-        // override map into a merged `nodes` snapshot. The merged
-        // copy feeds `buildContext` so `ctx.siblings` reflects the
-        // live cursor positions, and replaces `effectiveNode` so the
-        // kind's own override lands too (covers the case where the
-        // node being rendered is itself the dragged one). Kinds
-        // without the hook hand the raw `nodes` through — most
-        // previews are self-contained.
-        const contextNodes = def?.floorplanSiblingOverrides
-          ? def.floorplanSiblingOverrides({ nodeId: id, nodes, liveOverrides })
-          : nodes
-        if (contextNodes !== nodes) {
-          const merged = contextNodes[id]
-          if (merged) effectiveNode = merged
+      const node = useScene.getState().nodes[id]
+      if (!node || !isRegistryMovable(node.type)) return false
+      // Sole selection only: per-node direct manipulation stands down for a
+      // multi-selection (the group session owns plain drags there, and Cmd is
+      // the selection-toggle key — a wobbly Cmd+click must not yank one
+      // member out of the group).
+      const currentSelectedIds = useViewer.getState().selection.selectedIds
+      if (currentSelectedIds.length !== 1 || currentSelectedIds[0] !== id) return false
+
+      event.preventDefault()
+      event.stopPropagation()
+
+      const startX = event.clientX
+      const startY = event.clientY
+      const pointerId = event.pointerId
+      let engaged = false
+
+      const cleanup = () => {
+        window.removeEventListener('pointermove', onMove)
+        window.removeEventListener('pointerup', onEnd)
+        window.removeEventListener('pointercancel', onEnd)
+        if (engaged) {
+          useViewer.getState().setInputDragging(false)
         }
-        const ctx = buildContext(effectiveNode, contextNodes, {
-          selected,
-          highlighted,
-          hovered,
-          moving,
-          palette: renderCtx?.palette,
+      }
+
+      const onMove = (moveEvent: PointerEvent) => {
+        if (moveEvent.pointerId !== pointerId) return
+        if (engaged) return
+        const distance = Math.hypot(moveEvent.clientX - startX, moveEvent.clientY - startY)
+        if (distance < DIRECT_DRAG_THRESHOLD_PX) return
+
+        engaged = true
+        useViewer.getState().setInputDragging(true)
+        swallowNextClick(300)
+        createEditorApi().engageMoveDrag(node)
+
+        requestAnimationFrame(() => {
+          window.dispatchEvent(
+            new PointerEvent('pointermove', {
+              altKey: moveEvent.altKey,
+              bubbles: true,
+              buttons: moveEvent.buttons,
+              clientX: moveEvent.clientX,
+              clientY: moveEvent.clientY,
+              ctrlKey: moveEvent.ctrlKey,
+              metaKey: moveEvent.metaKey,
+              pointerId,
+              pointerType: moveEvent.pointerType,
+              shiftKey: moveEvent.shiftKey,
+            }),
+          )
         })
-        const geometry = (builder as (n: AnyNode, c: GeometryContext) => FloorplanGeometry | null)(
-          effectiveNode,
-          ctx,
+      }
+
+      const onEnd = (endEvent: PointerEvent) => {
+        if (endEvent.pointerId !== pointerId) return
+        cleanup()
+        if (!engaged) {
+          applyEntrySelection(id, true)
+        }
+      }
+
+      window.addEventListener('pointermove', onMove)
+      window.addEventListener('pointerup', onEnd)
+      window.addEventListener('pointercancel', onEnd)
+      return true
+    },
+    [applyEntrySelection],
+  )
+
+  const startDirectRotateDrag = useCallback(
+    (id: AnyNodeId, event: ReactPointerEvent<SVGGElement>): boolean => {
+      if (event.button !== 2 || !(event.metaKey || event.ctrlKey)) return false
+
+      const sceneNodes = useScene.getState().nodes
+      const selectedNode = sceneNodes[id]
+      const node = selectedNode ? resolveDirectManipulationNode(selectedNode, sceneNodes) : null
+      if (!node || !canDirectRotateNode(node)) return false
+      // Sole selection only — same stand-down as the direct move above.
+      const selectedIds = useViewer.getState().selection.selectedIds
+      if (selectedIds.length !== 1 || selectedIds[0] !== id) return false
+      event.preventDefault()
+      event.stopPropagation()
+
+      const nodeId = node.id as AnyNodeId
+      const pointerId = event.pointerId
+      const startX = event.clientX
+      const sceneApi = createSceneApi(useScene)
+      let lastPatch: Partial<AnyNode> | null = null
+
+      const applyDelta = (pointerEvent: PointerEvent | ReactPointerEvent<SVGGElement>) => {
+        const delta = resolveDirectRotationDragDelta(
+          startX,
+          pointerEvent.clientX,
+          DIRECT_ROTATE_RADIANS_PER_PIXEL,
+          pointerEvent.shiftKey,
         )
-        if (geometry) {
-          const { base, overlay } = splitFloorplanOverlay(geometry)
-          out.push({ id, node: effectiveNode, base, overlay, selected, highlighted })
+        if (Math.abs(delta) < DIRECT_ROTATE_EPSILON) {
+          lastPatch = null
+          useLiveNodeOverrides.getState().clear(nodeId)
+          useScene.getState().markDirty(nodeId)
+          return
+        }
+        const patch = resolveDirectRotationPatch(node, delta, sceneApi)
+        if (!patch) return
+        lastPatch = patch
+        useLiveNodeOverrides.getState().set(nodeId, patch as Record<string, unknown>)
+        useScene.getState().markDirty(nodeId)
+      }
+
+      const cleanup = () => {
+        window.removeEventListener('pointermove', onMove, true)
+        window.removeEventListener('pointerup', onUp, true)
+        window.removeEventListener('pointercancel', onCancel, true)
+        window.removeEventListener('contextmenu', preventContextMenu, true)
+        useLiveNodeOverrides.getState().clear(nodeId)
+        useScene.getState().markDirty(nodeId)
+        resumeSceneHistory(useScene)
+        useDirectManipulationFeedback.getState().clearActiveRotateNodeId(nodeId)
+        useViewer.getState().setInputDragging(false)
+        if (document.body.style.cursor === 'ew-resize') {
+          document.body.style.cursor = ''
+        }
+      }
+
+      const onMove = (moveEvent: PointerEvent) => {
+        if (moveEvent.pointerId !== pointerId) return
+        moveEvent.preventDefault()
+        moveEvent.stopPropagation()
+        applyDelta(moveEvent)
+      }
+
+      const onUp = (upEvent: PointerEvent) => {
+        if (upEvent.pointerId !== pointerId) return
+        upEvent.preventDefault()
+        upEvent.stopPropagation()
+        swallowNextClick(300)
+        if (lastPatch) {
+          sceneApi.update(nodeId, lastPatch)
+          sfxEmitter.emit('sfx:item-place')
         }
+        cleanup()
+      }
+
+      const onCancel = (cancelEvent: PointerEvent) => {
+        if (cancelEvent.pointerId !== pointerId) return
+        cleanup()
+      }
+
+      const preventContextMenu = (contextEvent: Event) => {
+        contextEvent.preventDefault()
+        contextEvent.stopPropagation()
+      }
+
+      pauseSceneHistory(useScene)
+      useViewer.getState().setInputDragging(true)
+      useDirectManipulationFeedback.getState().setActiveRotateNodeId(nodeId)
+      document.body.style.cursor = 'ew-resize'
+      sfxEmitter.emit('sfx:item-pick')
+      applyDelta(event)
+
+      window.addEventListener('pointermove', onMove, true)
+      window.addEventListener('pointerup', onUp, true)
+      window.addEventListener('pointercancel', onCancel, true)
+      window.addEventListener('contextmenu', preventContextMenu, true)
+      return true
+    },
+    [],
+  )
+
+  // Photoshop-style group drag: plain pointer-down on a transformable member
+  // of a multi-selection slides the whole selection rigidly; a plain click
+  // (no drag) enters the group pick-up instead — parity with the single-item
+  // click-to-move (clicking outside still deselects). Modified clicks
+  // (selection toggle) and Cmd-drag / direct-rotate keep their existing
+  // paths. `immediate` engages without the drag threshold — the move-handle
+  // dot's pick-up semantics.
+  const startGroupMoveDrag = useCallback(
+    (id: AnyNodeId, event: ReactPointerEvent<SVGGElement>, immediate = false): boolean => {
+      if (event.button !== 0) return false
+      if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return false
+      if (movingNode) return false
+      if (useEditor.getState().mode === 'delete') return false
+      const started = startFloorplanGroupMove(id, event, {
+        immediate,
+        onClickFallthrough: immediate ? undefined : () => startGroupPickUp(),
+      })
+      if (!started) return false
+      event.preventDefault()
+      event.stopPropagation()
+      suppressBoxSelectForPointer(event)
+      return true
+    },
+    [movingNode],
+  )
+
+  // Move-handle dot variant — routes the dot through the group session when
+  // the owning node is part of a multi-selection.
+  const handleGroupMoveHandlePointerDown = useCallback(
+    (id: AnyNodeId, event: ReactPointerEvent<SVGGElement>) => startGroupMoveDrag(id, event, true),
+    [startGroupMoveDrag],
+  )
+
+  // The dashed selection box is itself the group's drag handle: a press
+  // anywhere inside it slides the group (or picks it up on a plain click),
+  // anchored on the first transformable member.
+  const handleGroupBoxPointerDown = useCallback(
+    (event: ReactPointerEvent<SVGGElement>) => {
+      const { selectedIds: currentIds, levelId: currentLevelId } = useViewer.getState().selection
+      const sceneNodes = useScene.getState().nodes
+      const anchor = currentIds.find(
+        (id) =>
+          classifyParticipant(sceneNodes[id as AnyNodeId], currentLevelId, sceneNodes) !== null,
+      )
+      if (!anchor) return
+      startGroupMoveDrag(anchor as AnyNodeId, event)
+    },
+    [startGroupMoveDrag],
+  )
+
+  // Corner rotate handles on the dashed selection box — 15° steps, Shift
+  // free, mirroring the 3D group rotate gizmo.
+  const handleGroupBoxRotatePointerDown = useCallback((event: ReactPointerEvent<SVGGElement>) => {
+    if (event.button !== 0) return
+    if (event.metaKey || event.ctrlKey || event.altKey) return
+    if (useEditor.getState().mode === 'delete') return
+    if (startFloorplanGroupRotate(event)) {
+      event.preventDefault()
+      suppressBoxSelectForPointer(event)
+    }
+  }, [])
+
+  const handleEntryPointerDown = useCallback(
+    (id: AnyNodeId, event: ReactPointerEvent<SVGGElement>) => {
+      if (startDirectMoveDrag(id, event)) return
+      if (startDirectRotateDrag(id, event)) return
+      if (startGroupMoveDrag(id, event)) return
+      handleSelect(id, event)
+    },
+    [handleSelect, startDirectMoveDrag, startDirectRotateDrag, startGroupMoveDrag],
+  )
+
+  const floorplanData = useMemo(() => {
+    if (!levelId) {
+      geometryCacheRef.current.clear()
+      levelDataCacheRef.current.clear()
+      return {
+        entries: [] as FloorplanEntryDescriptor[],
+        levelNodeIdsByType: new Map<string, AnyNodeId[]>(),
+      }
+    }
+
+    const out: FloorplanEntryDescriptor[] = []
+    const levelNodeIdsByType = new Map<string, AnyNodeId[]>()
+
+    const collectLevelDataKind = (id: AnyNodeId) => {
+      const node = nodes[id]
+      if (!node) return
+      if (!isNodeKindEnabled(node.type, installedPlugins)) return
+      const def = nodeRegistry.get(node.type)
+      if (def?.computeFloorplanLevelData) {
+        const ids = levelNodeIdsByType.get(node.type)
+        if (ids) ids.push(id)
+        else levelNodeIdsByType.set(node.type, [id])
       }
       const childIds = (node as unknown as { children?: AnyNodeId[] }).children
+      if (Array.isArray(childIds)) {
+        for (const cid of childIds) collectLevelDataKind(cid)
+      }
+    }
+
+    collectLevelDataKind(levelId as AnyNodeId)
+
+    const pushEntry = (id: AnyNodeId, node: AnyNode, ctxOverrides?: FloorplanContextOverrides) => {
+      if (!isNodeKindEnabled(node.type, installedPlugins)) return
+      const def = nodeRegistry.get(node.type)
+      if (!def?.floorplan) return
+      if (node.type === 'measurement' && !showMeasurements) return
+      const dependsOnSiblingInputs = !!(
+        def.floorplanDependsOnSiblings ||
+        def.floorplanSiblingOverrides ||
+        def.floorplanAffectedIds
+      )
+      const descriptor: FloorplanEntryDescriptor = { id, node, dependsOnSiblingInputs }
+      if (ctxOverrides) descriptor.ctxOverrides = ctxOverrides
+      out.push(descriptor)
+    }
+
+    const visit = (id: AnyNodeId) => {
+      const node = nodes[id]
+      if (!node) return
+      pushEntry(id, node)
+      const childIds = (node as unknown as { children?: AnyNodeId[] }).children
       if (Array.isArray(childIds)) {
         for (const cid of childIds) visit(cid)
       }
@@ -386,54 +880,14 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
       const buildingScopedKindSet = new Set(buildingScopedKinds)
       for (const [id, node] of Object.entries(nodes)) {
         if (!node || !buildingScopedKindSet.has(node.type)) continue
-        if ((node as { visible?: boolean }).visible === false) continue
         const parentId = (node as { parentId?: AnyNodeId | null }).parentId
         if (parentId !== activeBuildingId) continue
         const cid = id as AnyNodeId
-        const def = nodeRegistry.get(node.type)
-        const builder = def?.floorplan
-        if (!builder) continue
-        const selected = selectedIdSet.has(cid)
-        const highlighted = highlightedIdSet.has(cid)
-        const hovered = hoveredId === cid
-        const moving = movingNode?.id === cid
-        const live = liveTransforms.get(cid)
-        const hasPosition = Array.isArray((node as { position?: unknown }).position)
-        let effectiveNode: AnyNode =
-          live && hasPosition ? applyPositionLiveTransform(node, live) : node
-        const contextNodes = def?.floorplanSiblingOverrides
-          ? def.floorplanSiblingOverrides({ nodeId: cid, nodes, liveOverrides })
-          : nodes
-        if (contextNodes !== nodes) {
-          const merged = contextNodes[cid]
-          if (merged) {
-            effectiveNode = live && hasPosition ? applyPositionLiveTransform(merged, live) : merged
-          }
-        }
-        const ctx: GeometryContext = {
-          resolve: <N = AnyNode>(rid: AnyNodeId): N | undefined =>
-            contextNodes[rid] as N | undefined,
+        pushEntry(cid, node, {
           children: [],
           siblings: [],
           parent: activeLevelNode,
-          viewState: renderCtx?.palette
-            ? {
-                selected,
-                highlighted,
-                hovered,
-                moving,
-                palette: renderCtx.palette,
-              }
-            : undefined,
-        }
-        const geometry = (builder as (n: AnyNode, c: GeometryContext) => FloorplanGeometry | null)(
-          effectiveNode,
-          ctx,
-        )
-        if (geometry) {
-          const { base, overlay } = splitFloorplanOverlay(geometry)
-          out.push({ id: cid, node: effectiveNode, base, overlay, selected, highlighted })
-        }
+        })
       }
     }
 
@@ -445,19 +899,15 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
     // DFS visit order (stable sort) so siblings keep their relative
     // priority.
     out.sort((a, b) => floorplanLayerRank(a.node.type) - floorplanLayerRank(b.node.type))
-    return out
-  }, [
-    levelId,
-    nodes,
-    liveTransforms,
-    liveOverrides,
-    selectedIdSet,
-    highlightedIdSet,
-    hoveredId,
-    movingNode?.id,
-    renderCtx?.palette,
-    interactiveElevators,
-  ])
+    const entryIds = new Set(out.map((entry) => entry.id))
+    for (const id of geometryCacheRef.current.keys()) {
+      if (!entryIds.has(id as AnyNodeId)) geometryCacheRef.current.delete(id)
+    }
+    for (const type of levelDataCacheRef.current.keys()) {
+      if (!levelNodeIdsByType.has(type)) levelDataCacheRef.current.delete(type)
+    }
+    return { entries: out, levelNodeIdsByType }
+  }, [installedPlugins, levelId, nodes, showMeasurements])
 
   // ── Generic 2D affordance dispatch ─────────────────────────────────
   //
@@ -466,6 +916,37 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
   // dispatcher then owns: history pause/resume, snapshot capture,
   // pointer-move/up/cancel routing, and the single-undo dance on
   // commit. Each kind owns the actual mutation logic inside `apply`.
+  const commitAffordanceAction = useCallback(
+    (
+      nodeId: AnyNodeId,
+      affordance: string,
+      payload: unknown,
+      event: ReactMouseEvent<SVGElement>,
+    ) => {
+      if (event.button !== 0 || movingNode || dragRef.current) return
+
+      const sceneNodes = useScene.getState().nodes
+      const node = sceneNodes[nodeId]
+      if (!node) return
+      const handler = nodeRegistry.get(node.type)?.floorplanAffordances?.[affordance]
+      if (!handler) return
+      const initialPlanPoint = clientToPlan(event.clientX, event.clientY)
+      if (!initialPlanPoint) return
+
+      const session = handler.start({
+        node,
+        payload,
+        nodes: sceneNodes,
+        initialPlanPoint,
+        gridSnapStep: useEditor.getState().gridSnapStep,
+      })
+      if (!(session.commit && session.canCommit())) return
+      session.commit()
+      sfxEmitter.emit('sfx:structure-build')
+    },
+    [movingNode],
+  )
+
   const startAffordanceDrag = useCallback(
     (
       nodeId: AnyNodeId,
@@ -493,6 +974,7 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
 
       event.preventDefault()
       event.stopPropagation()
+      suppressBoxSelectForPointer(event)
 
       const session = handler.start({
         node,
@@ -525,22 +1007,73 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
         }
       }
 
+      // Begin the matching reshaping scope so the contextual snapping HUD shows
+      // the right chip during the edit AND `getActiveSnapContext()` resolves the
+      // polygon / wall mode-set the affordance's snap math reads. Torn down on
+      // release / cancel below. `null` for resize / rotate (no snapping chip).
+      const reshapeScope = affordanceReshapeScope(affordance, nodeId, payload)
+      if (reshapeScope) {
+        useInteractionScope.getState().begin(reshapeScope)
+      }
+
+      const captureTarget = event.currentTarget as Element
       dragRef.current = {
         pointerId: event.pointerId,
+        captureTarget,
         handleId,
         session,
         snapshots,
         historyPaused: true,
+        lastPlanPoint: initialPlanPoint,
         rotation,
+        reshapeScopeNodeId: reshapeScope ? nodeId : undefined,
       }
       setActiveDragId(handleId)
       setSelection({ selectedIds: [nodeId] })
-      ;(event.currentTarget as Element).setPointerCapture?.(event.pointerId)
+      captureTarget.setPointerCapture?.(event.pointerId)
     },
     [movingNode, setSelection],
   )
 
   useEffect(() => {
+    // Tear down the scope this drag opened (if any) — a reshaping scope for an
+    // edit affordance, or a handle-drag scope for a rotate-arrow — matched by
+    // node id so a concurrent scope from another path is never ended by mistake.
+    const endReshapeScope = (drag: ActiveDrag) => {
+      if (drag.reshapeScopeNodeId) {
+        useInteractionScope
+          .getState()
+          .endIf(
+            (s) =>
+              (s.kind === 'reshaping' || s.kind === 'handle-drag') &&
+              s.nodeId === drag.reshapeScopeNodeId,
+          )
+      }
+    }
+
+    const cancelActiveDrag = (pointerId?: number, clearDragFeedback = true) =>
+      cancelFloorplanAffordanceDrag(
+        dragRef,
+        {
+          restoreSnapshots: (snapshots) =>
+            useScene.getState().updateNodes(snapshotsToUpdates(snapshots)),
+          resumeHistory: () => resumeSceneHistory(useScene),
+          clearPreview: (id) => {
+            useLiveNodeOverrides.getState().clear(id)
+            useLiveTransforms.getState().clear(id)
+          },
+          clearSnapFeedback: clearSurfacePlanSnapFeedback,
+          endReshapeScope,
+          clearDragFeedback: clearDragFeedback
+            ? () => {
+                setActiveDragId(null)
+                setRotationOverlay(null)
+              }
+            : undefined,
+        },
+        pointerId,
+      )
+
     const onPointerMove = (event: PointerEvent) => {
       const drag = dragRef.current
       if (!drag || event.pointerId !== drag.pointerId) return
@@ -548,6 +1081,7 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
       const planPoint = clientToPlan(event.clientX, event.clientY)
       if (!planPoint) return
 
+      drag.lastPlanPoint = planPoint
       drag.session.apply({
         planPoint,
         modifiers: {
@@ -569,6 +1103,9 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
         let delta = current - rot.initialAngle
         while (delta > Math.PI) delta -= 2 * Math.PI
         while (delta < -Math.PI) delta += 2 * Math.PI
+        // Match the affordance's 15° angle step (Shift = free) so the wedge +
+        // degree chip read the committed rotation, not the raw pointer bearing.
+        delta = snapDirectRotationDelta(delta, event.shiftKey)
         if (Math.abs(delta) < 0.0087) {
           setRotationOverlay(null)
         } else {
@@ -603,14 +1140,18 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
         }
         drag.session.commit()
         sfxEmitter.emit('sfx:structure-build')
+        clearSurfacePlanSnapFeedback()
+        endReshapeScope(drag)
         dragRef.current = null
         setActiveDragId(null)
         setRotationOverlay(null)
         return
       }
 
-      // Capture the final state BEFORE the revert so we know what to
-      // re-apply post-resume.
+      // Legacy compatibility for sessions that still wrote preview state into
+      // `useScene` during `apply()`: capture the final state BEFORE the revert
+      // so we know what to re-apply post-resume. New sessions should provide a
+      // `commit()` hook and preview through live overrides/transforms instead.
       const sceneNodes = useScene.getState().nodes
       const finalUpdates: Array<{ id: AnyNodeId; data: Record<string, unknown> }> = []
       for (const snap of drag.snapshots) {
@@ -629,7 +1170,7 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
       }
 
       if (commitValid && finalUpdates.length > 0) {
-        // Single-undo dance (mirrors the 3D move-endpoint-tool):
+        // Legacy single-undo dance (mirrors the old 3D move-endpoint-tool):
         //   1. Revert to baseline while history is still paused (untracked).
         //   2. Resume history.
         //   3. Re-apply the final state — recorded as one tracked change.
@@ -654,129 +1195,71 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
         for (const id of drag.session.affectedIds) overrides.clear(id)
       }
 
+      clearSurfacePlanSnapFeedback()
+      endReshapeScope(drag)
       dragRef.current = null
       setActiveDragId(null)
       setRotationOverlay(null)
     }
 
     const onPointerCancel = (event: PointerEvent) => {
-      const drag = dragRef.current
-      if (!drag || event.pointerId !== drag.pointerId) return
+      cancelActiveDrag(event.pointerId)
+    }
 
-      // Revert untracked, then resume — no history entry is recorded.
-      useScene.getState().updateNodes(snapshotsToUpdates(drag.snapshots))
-      if (drag.historyPaused) {
-        resumeSceneHistory(useScene)
-        drag.historyPaused = false
+    // Re-run the active session the moment a modifier key flips so behaviors
+    // like the wall endpoint's Alt-detach / re-attach take effect immediately
+    // instead of waiting for the next pointer move. `event.altKey` & co
+    // already reflect the post-transition state on both keydown and keyup.
+    const onModifierKeyChange = (event: KeyboardEvent) => {
+      const drag = dragRef.current
+      if (!drag || event.repeat) return
+      if (
+        event.key !== 'Alt' &&
+        event.key !== 'Shift' &&
+        event.key !== 'Control' &&
+        event.key !== 'Meta'
+      ) {
+        return
       }
-      // Affordances that publish Figma alignment guides during `apply`
-      // (fence endpoint) leave them in the store on cancel — `canCommit`
-      // (the pointer-up clear) never runs on a cancel.
-      useAlignmentGuides.getState().clear()
-      // Drop any live overrides the session may have published. No-op
-      // for affordances whose `apply()` writes straight to scene; the
-      // override-routed sessions (wall endpoint, wall curve) rely on
-      // this to revert cleanly.
-      const overrides = useLiveNodeOverrides.getState()
-      for (const id of drag.session.affectedIds) overrides.clear(id)
-
-      dragRef.current = null
-      setActiveDragId(null)
-      setRotationOverlay(null)
+      drag.session.apply({
+        planPoint: drag.lastPlanPoint,
+        modifiers: {
+          shiftKey: event.shiftKey,
+          altKey: event.altKey,
+          ctrlKey: event.ctrlKey,
+          metaKey: event.metaKey,
+        },
+      })
     }
 
     window.addEventListener('pointermove', onPointerMove)
     window.addEventListener('pointerup', onPointerUp)
     window.addEventListener('pointercancel', onPointerCancel)
+    window.addEventListener('keydown', onModifierKeyChange)
+    window.addEventListener('keyup', onModifierKeyChange)
+    const unsubscribeToolCancel = subscribeFloorplanAffordanceToolCancel(
+      () => cancelActiveDrag(),
+      markToolCancelConsumed,
+    )
     return () => {
       window.removeEventListener('pointermove', onPointerMove)
       window.removeEventListener('pointerup', onPointerUp)
       window.removeEventListener('pointercancel', onPointerCancel)
-      // Component unmounted mid-drag — restore the baseline and unpause
-      // history so we don't leak a paused store across mounts. Also
-      // drop any live overrides the session published so the next
-      // mount doesn't render at the cancelled position.
-      const drag = dragRef.current
-      if (drag) {
-        useScene.getState().updateNodes(snapshotsToUpdates(drag.snapshots))
-        if (drag.historyPaused) {
-          resumeSceneHistory(useScene)
-        }
-        const overrides = useLiveNodeOverrides.getState()
-        for (const id of drag.session.affectedIds) overrides.clear(id)
-        dragRef.current = null
+      window.removeEventListener('keydown', onModifierKeyChange)
+      window.removeEventListener('keyup', onModifierKeyChange)
+      unsubscribeToolCancel()
+      if (!cancelActiveDrag(undefined, false)) {
+        clearSurfacePlanSnapFeedback()
       }
-      // Clear any alignment guide a session left behind on mid-drag unmount.
-      useAlignmentGuides.getState().clear()
     }
   }, [])
 
+  const entries = floorplanData.entries
   if (entries.length === 0) return null
 
   const unitsPerPixel = renderCtx?.unitsPerPixel ?? 1
   const palette = renderCtx?.palette
 
-  const renderEntry = (id: AnyNodeId, geometry: FloorplanGeometry, key: string) => (
-    <g
-      className="floorplan-registry-entry"
-      data-node-id={id}
-      key={key}
-      onClick={isOpeningPlacementActive || isMarqueeSelectionActive ? undefined : handleClickStop}
-      onPointerDown={
-        isOpeningPlacementActive || isMarqueeSelectionActive
-          ? undefined
-          : (e) => handleSelect(id, e)
-      }
-      // Mirror the sidebar tree nodes' hover wiring — `useViewer.
-      // hoveredId` drives the highlight halo in 3D as well as the
-      // wall / fence floor-plan hover stroke. Setting it on
-      // pointer-enter and clearing on leave keeps the two views in
-      // sync. Without this the registry-driven kinds had hover
-      // visuals defined but never reached because the entry `<g>`
-      // never updated the store.
-      onPointerEnter={() => setHoveredId(id)}
-      onPointerLeave={() => {
-        // Only clear when this entry is the one we last set —
-        // avoids racing with sibling entries during fast-moving
-        // pointer scans.
-        if (useViewer.getState().hoveredId === id) setHoveredId(null)
-      }}
-      style={{ cursor: 'pointer' }}
-    >
-      <InteractiveGeometry
-        activeDragId={activeDragId}
-        geometry={geometry}
-        hatchPatternId={renderCtx?.hatchPatternId}
-        hoveredHandleId={hoveredHandleId}
-        isMarqueeSelectionActive={isMarqueeSelectionActive}
-        nodeId={id}
-        onHandleHoverChange={setHoveredHandleId}
-        onHandlePointerDown={(affordance, payload, event, rotationPivot) =>
-          startAffordanceDrag(
-            id,
-            makeHandleId(id, payload),
-            affordance,
-            payload,
-            event,
-            rotationPivot,
-          )
-        }
-        onMoveHandlePointerDown={(event) => {
-          if (event.button !== 0) return
-          const node = useScene.getState().nodes[id]
-          if (!node) return
-          event.preventDefault()
-          event.stopPropagation()
-          sfxEmitter.emit('sfx:item-pick')
-          setMovingNode(node as never)
-        }}
-        palette={palette}
-        sceneRotationDeg={renderCtx?.sceneRotationDeg ?? 0}
-        unitsPerPixel={unitsPerPixel}
-      />
-    </g>
-  )
-
   return (
     // The outer wrapper stops `click` events that escape an entry's
     // `onClick={handleClickStop}`. The base+overlay split means
@@ -796,14 +1279,55 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
       className="floorplan-registry-layer"
       onClick={isOpeningPlacementActive ? undefined : handleClickStop}
       opacity={isAmbient ? 0.3 : undefined}
-      style={isAmbient ? { pointerEvents: 'none' } : undefined}
+      style={isAmbient ? NO_POINTER_EVENTS_STYLE : undefined}
     >
       {/* Base pass — rank-sorted body geometry (polygons, paths, fills,
           strokes, hatches). Lower-rank kinds (zones) paint first so
           higher-rank kinds (slabs, then walls / items / shelves) layer
           on top in the expected document-order z-stack. */}
       <g className="floorplan-registry-base">
-        {entries.map(({ id, base }) => (base ? renderEntry(id, base, `base-${id}`) : null))}
+        {entries.map((entry) => (
+          <FloorplanRegistryEntry
+            activeDragId={handleIdForNode(activeDragId, entry.id)}
+            activeRotateNodeId={activeRotateNodeId === entry.id ? activeRotateNodeId : null}
+            floorplanVisible={floorplanVisible}
+            geometryCacheRef={geometryCacheRef}
+            hatchPatternId={renderCtx?.hatchPatternId}
+            highlighted={highlightedIdSet.has(entry.id)}
+            hovered={hoveredId === entry.id}
+            hoveredHandleId={handleIdForNode(hoveredHandleId, entry.id)}
+            interactiveElevators={interactiveElevators}
+            isMarqueeSelectionActive={isMarqueeSelectionActive}
+            isOpeningPlacementActive={isOpeningPlacementActive}
+            key={`base-${entry.id}`}
+            levelDataCacheRef={levelDataCacheRef}
+            levelNodeIdsByType={floorplanData.levelNodeIdsByType}
+            moving={movingNode?.id === entry.id}
+            node={entry.node}
+            nodeId={entry.id}
+            nodes={nodes}
+            onClickStop={handleClickStop}
+            onEntryPointerDown={handleEntryPointerDown}
+            onGroupMovePointerDown={handleGroupMoveHandlePointerDown}
+            onHandleHoverChange={setHoveredHandleId}
+            onHandleDoubleClick={commitAffordanceAction}
+            onHandlePointerDown={startAffordanceDrag}
+            onHoveredIdChange={setHoveredId}
+            palette={palette}
+            pass="base"
+            sceneRotationDeg={renderCtx?.sceneRotationDeg ?? 0}
+            selected={selectedIdSet.has(entry.id)}
+            suppressHandles={isMultiSelect && selectedIdSet.has(entry.id)}
+            groupMoveCursor={groupParticipantIdSet?.has(entry.id) ?? false}
+            setMovingNode={setMovingNode}
+            setMovingNodeOrigin={setMovingNodeOrigin}
+            siblingEpoch={entry.dependsOnSiblingInputs ? (siblingEpochs.get(entry.id) ?? 0) : 0}
+            unit={unit}
+            unitsPerPixel={unitsPerPixel}
+            visibilityRootId={entry.ctxOverrides ? undefined : (levelId as AnyNodeId)}
+            ctxOverrides={entry.ctxOverrides}
+          />
+        ))}
       </g>
       {/* Overlay pass — interactive handles (vertex / midpoint / edge /
           move) and labels (text / dimensions). Painted after every base
@@ -813,10 +1337,58 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
           still routes through the same selection-handling `<g>` so a
           click on a zone's name selects the zone. */}
       <g className="floorplan-registry-overlay">
-        {entries.map(({ id, overlay }) =>
-          overlay ? renderEntry(id, overlay, `overlay-${id}`) : null,
-        )}
+        {entries.map((entry) => (
+          <FloorplanRegistryEntry
+            activeDragId={handleIdForNode(activeDragId, entry.id)}
+            activeRotateNodeId={activeRotateNodeId === entry.id ? activeRotateNodeId : null}
+            floorplanVisible={floorplanVisible}
+            geometryCacheRef={geometryCacheRef}
+            hatchPatternId={renderCtx?.hatchPatternId}
+            highlighted={highlightedIdSet.has(entry.id)}
+            hovered={hoveredId === entry.id}
+            hoveredHandleId={handleIdForNode(hoveredHandleId, entry.id)}
+            interactiveElevators={interactiveElevators}
+            isMarqueeSelectionActive={isMarqueeSelectionActive}
+            isOpeningPlacementActive={isOpeningPlacementActive}
+            key={`overlay-${entry.id}`}
+            levelDataCacheRef={levelDataCacheRef}
+            levelNodeIdsByType={floorplanData.levelNodeIdsByType}
+            moving={movingNode?.id === entry.id}
+            node={entry.node}
+            nodeId={entry.id}
+            nodes={nodes}
+            onClickStop={handleClickStop}
+            onEntryPointerDown={handleEntryPointerDown}
+            onGroupMovePointerDown={handleGroupMoveHandlePointerDown}
+            onHandleHoverChange={setHoveredHandleId}
+            onHandleDoubleClick={commitAffordanceAction}
+            onHandlePointerDown={startAffordanceDrag}
+            onHoveredIdChange={setHoveredId}
+            palette={palette}
+            pass="overlay"
+            sceneRotationDeg={renderCtx?.sceneRotationDeg ?? 0}
+            selected={selectedIdSet.has(entry.id)}
+            suppressHandles={isMultiSelect && selectedIdSet.has(entry.id)}
+            groupMoveCursor={groupParticipantIdSet?.has(entry.id) ?? false}
+            setMovingNode={setMovingNode}
+            setMovingNodeOrigin={setMovingNodeOrigin}
+            siblingEpoch={entry.dependsOnSiblingInputs ? (siblingEpochs.get(entry.id) ?? 0) : 0}
+            unit={unit}
+            unitsPerPixel={unitsPerPixel}
+            visibilityRootId={entry.ctxOverrides ? undefined : (levelId as AnyNodeId)}
+            ctxOverrides={entry.ctxOverrides}
+          />
+        ))}
       </g>
+      {/* Dashed group bbox — shows what a group drag carries along while a
+          multi-selection exists, rides the live delta mid-drag, and doubles
+          as the group's whole-area drag handle. */}
+      <FloorplanGroupSelectionBox
+        onPointerDown={handleGroupBoxPointerDown}
+        onRotatePointerDown={handleGroupBoxRotatePointerDown}
+        palette={palette}
+        unitsPerPixel={unitsPerPixel}
+      />
       {/* Transient live-rotation readout — drawn last so the wedge + degree
           chip sit above all handle chrome while a rotate-arrow is dragged. */}
       {rotationOverlay && palette ? (
@@ -831,32 +1403,517 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
   )
 })
 
-// ── Interactive geometry walker ──────────────────────────────────────
+type FloorplanRegistryEntryProps = {
+  activeDragId: string | null
+  activeRotateNodeId: AnyNodeId | null
+  ctxOverrides: FloorplanContextOverrides | undefined
+  floorplanVisible: boolean
+  geometryCacheRef: { current: Map<string, CacheEntry> }
+  hatchPatternId: string | undefined
+  highlighted: boolean
+  hovered: boolean
+  hoveredHandleId: string | null
+  interactiveElevators: unknown
+  isMarqueeSelectionActive: boolean
+  isOpeningPlacementActive: boolean
+  levelDataCacheRef: { current: Map<string, LevelDataCacheEntry> }
+  levelNodeIdsByType: ReadonlyMap<string, readonly AnyNodeId[]>
+  moving: boolean
+  node: AnyNode
+  nodeId: AnyNodeId
+  nodes: Record<string, AnyNode>
+  /** Selected member of a multi-selection: hide its per-node edit chrome. */
+  suppressHandles: boolean
+  /** Transformable member of a multi-selection: advertise drag-to-move. */
+  groupMoveCursor: boolean
+  onClickStop: (event: React.MouseEvent<SVGGElement>) => void
+  onEntryPointerDown: (id: AnyNodeId, event: ReactPointerEvent<SVGGElement>) => void
+  onGroupMovePointerDown: (id: AnyNodeId, event: ReactPointerEvent<SVGGElement>) => boolean
+  onHandleHoverChange: (id: string | null) => void
+  onHandleDoubleClick: (
+    nodeId: AnyNodeId,
+    affordance: string,
+    payload: unknown,
+    event: ReactMouseEvent<SVGElement>,
+  ) => void
+  onHandlePointerDown: (
+    nodeId: AnyNodeId,
+    handleId: string,
+    affordance: string,
+    payload: unknown,
+    event: ReactPointerEvent<SVGGElement>,
+    rotationPivot?: FloorplanPoint,
+  ) => void
+  onHoveredIdChange: (id: AnyNodeId | null) => void
+  palette: FloorplanPalette | undefined
+  pass: FloorplanRenderPass
+  sceneRotationDeg: number
+  selected: boolean
+  setMovingNode: ReturnType<typeof useEditor.getState>['setMovingNode']
+  setMovingNodeOrigin: ReturnType<typeof useEditor.getState>['setMovingNodeOrigin']
+  siblingEpoch: number
+  unit: 'metric' | 'imperial'
+  unitsPerPixel: number
+  visibilityRootId: AnyNodeId | undefined
+}
 
-function InteractiveGeometry({
-  geometry,
-  unitsPerPixel,
-  palette,
+const FloorplanRegistryEntry = memo(function FloorplanRegistryEntry({
+  activeDragId,
+  activeRotateNodeId,
+  ctxOverrides,
+  floorplanVisible,
+  geometryCacheRef,
   hatchPatternId,
+  highlighted,
+  hovered,
   hoveredHandleId,
-  activeDragId,
+  interactiveElevators,
   isMarqueeSelectionActive,
+  isOpeningPlacementActive,
+  levelDataCacheRef,
+  levelNodeIdsByType,
+  moving,
+  node,
   nodeId,
-  sceneRotationDeg,
+  nodes,
+  suppressHandles,
+  groupMoveCursor,
+  onClickStop,
+  onEntryPointerDown,
+  onGroupMovePointerDown,
   onHandleHoverChange,
+  onHandleDoubleClick,
   onHandlePointerDown,
-  onMoveHandlePointerDown,
-}: {
+  onHoveredIdChange,
+  palette,
+  pass,
+  sceneRotationDeg,
+  selected,
+  setMovingNode,
+  setMovingNodeOrigin,
+  siblingEpoch,
+  unit,
+  unitsPerPixel,
+  visibilityRootId,
+}: FloorplanRegistryEntryProps): React.ReactElement | null {
+  const live = useLiveTransforms((s) => (floorplanVisible ? s.transforms.get(nodeId) : undefined))
+  const liveOverride = useLiveNodeOverrides((s) =>
+    floorplanVisible ? s.overrides.get(nodeId) : undefined,
+  )
+  const liveOverrides = floorplanVisible
+    ? useLiveNodeOverrides.getState().overrides
+    : EMPTY_LIVE_OVERRIDES
+
+  const handlePointerDown = useCallback(
+    (event: ReactPointerEvent<SVGGElement>) => onEntryPointerDown(nodeId, event),
+    [nodeId, onEntryPointerDown],
+  )
+
+  // Mirror the sidebar tree nodes' hover wiring — `useViewer.hoveredId` drives
+  // the highlight halo in 3D as well as registry floor-plan hover strokes.
+  const handlePointerEnter = useCallback(() => {
+    const node = useScene.getState().nodes[nodeId]
+    onHoveredIdChange(
+      node
+        ? resolveSelectionProxyId(
+            node,
+            useScene.getState().nodes as Record<string, AnyNode | undefined>,
+          )
+        : nodeId,
+    )
+  }, [nodeId, onHoveredIdChange])
+
+  const handlePointerLeave = useCallback(() => {
+    const node = useScene.getState().nodes[nodeId]
+    const targetId = node
+      ? resolveSelectionProxyId(
+          node,
+          useScene.getState().nodes as Record<string, AnyNode | undefined>,
+        )
+      : nodeId
+    if (useViewer.getState().hoveredId === targetId) onHoveredIdChange(null)
+  }, [nodeId, onHoveredIdChange])
+
+  const handleHandlePointerDown = useCallback(
+    (
+      affordance: string,
+      payload: unknown,
+      event: ReactPointerEvent<SVGGElement>,
+      rotationPivot?: FloorplanPoint,
+    ) => {
+      onHandlePointerDown(
+        nodeId,
+        makeHandleId(nodeId, payload),
+        affordance,
+        payload,
+        event,
+        rotationPivot,
+      )
+    },
+    [nodeId, onHandlePointerDown],
+  )
+
+  const handleHandleDoubleClick = useCallback(
+    (affordance: string, payload: unknown, event: ReactMouseEvent<SVGElement>) => {
+      onHandleDoubleClick(nodeId, affordance, payload, event)
+    },
+    [nodeId, onHandleDoubleClick],
+  )
+
+  const handleMoveHandlePointerDown = useCallback(
+    (event: ReactPointerEvent<SVGGElement>) => {
+      if (event.button !== 0) return
+      const currentNode = useScene.getState().nodes[nodeId]
+      if (!currentNode) return
+      event.preventDefault()
+      event.stopPropagation()
+      suppressBoxSelectForPointer(event)
+      // In a multi-selection the move dot drives the group session, matching
+      // the body-drag gesture — the whole selection slides, not one member.
+      if (onGroupMovePointerDown(nodeId, event)) return
+      sfxEmitter.emit('sfx:item-pick')
+      setMovingNode(currentNode as never)
+      // Claim 2D ownership of this move at the source. `setMovingNode`
+      // resets the origin to null, so this must follow it.
+      setMovingNodeOrigin('2d')
+    },
+    [nodeId, onGroupMovePointerDown, setMovingNode, setMovingNodeOrigin],
+  )
+
+  const cacheEntry = buildFloorplanEntryGeometry({
+    ctxOverrides,
+    geometryCache: geometryCacheRef.current,
+    highlighted,
+    hovered,
+    interactiveElevators,
+    levelDataCache: levelDataCacheRef.current,
+    levelNodeIdsByType,
+    live,
+    liveOverride,
+    liveOverrides,
+    moving,
+    node,
+    nodeId,
+    nodes,
+    palette,
+    selected,
+    siblingEpoch,
+    unit,
+    visibilityRootId,
+  })
+  const rawGeometry = cacheEntry ? (pass === 'base' ? cacheEntry.base : cacheEntry.overlay) : null
+  // Multi-selection shows highlight only: strip this member's edit handles /
+  // dimension chrome (all of which live in the overlay pass) while keeping
+  // its highlighted body geometry.
+  const geometry =
+    rawGeometry && suppressHandles && pass === 'overlay'
+      ? stripHandleChrome(rawGeometry)
+      : rawGeometry
+  if (!geometry) return null
+
+  const entryClick = isOpeningPlacementActive || isMarqueeSelectionActive ? undefined : onClickStop
+  const entryPointerDown =
+    isOpeningPlacementActive || isMarqueeSelectionActive ? undefined : handlePointerDown
+
+  return (
+    <g
+      className="floorplan-registry-entry"
+      data-node-id={nodeId}
+      onClick={entryClick}
+      onPointerDown={entryPointerDown}
+      onPointerEnter={handlePointerEnter}
+      onPointerLeave={handlePointerLeave}
+      style={groupMoveCursor ? MOVE_CURSOR_STYLE : POINTER_CURSOR_STYLE}
+    >
+      <InteractiveGeometry
+        activeDragId={activeDragId}
+        activeRotateNodeId={activeRotateNodeId}
+        geometry={geometry}
+        hatchPatternId={hatchPatternId}
+        hoveredHandleId={hoveredHandleId}
+        isMarqueeSelectionActive={isMarqueeSelectionActive}
+        nodeId={nodeId}
+        onHandleDoubleClick={handleHandleDoubleClick}
+        onHandleHoverChange={onHandleHoverChange}
+        onHandlePointerDown={handleHandlePointerDown}
+        onMoveHandlePointerDown={handleMoveHandlePointerDown}
+        palette={palette}
+        sceneRotationDeg={sceneRotationDeg}
+        unitsPerPixel={unitsPerPixel}
+      />
+    </g>
+  )
+}, shallowPropsAreEqual)
+
+type BuildFloorplanEntryGeometryArgs = {
+  ctxOverrides: FloorplanContextOverrides | undefined
+  geometryCache: Map<string, CacheEntry>
+  highlighted: boolean
+  hovered: boolean
+  interactiveElevators: unknown
+  levelDataCache: Map<string, LevelDataCacheEntry>
+  levelNodeIdsByType: ReadonlyMap<string, readonly AnyNodeId[]>
+  live: LiveTransform | undefined
+  liveOverride: LiveNodeOverrides | undefined
+  liveOverrides: Map<string, LiveNodeOverrides>
+  moving: boolean
+  node: AnyNode
+  nodeId: AnyNodeId
+  nodes: Record<string, AnyNode>
+  palette: FloorplanPalette | undefined
+  selected: boolean
+  siblingEpoch: number
+  unit: 'metric' | 'imperial'
+  visibilityRootId: AnyNodeId | undefined
+}
+
+export function collectFloorplanDependencyNodes(
+  def: AnyNodeDefinition,
+  node: AnyNode,
+  nodes: Record<string, AnyNode>,
+  liveOverrides?: Map<string, LiveNodeOverrides>,
+): AnyNode[] {
+  return (def.floorplanDependencies?.(node) ?? []).flatMap((id) => {
+    const dependency = nodes[id]
+    if (!dependency) return []
+    const dependencyOverride = liveOverrides?.get(dependency.id)
+    const effectiveDependency = dependencyOverride
+      ? ({ ...dependency, ...dependencyOverride } as AnyNode)
+      : dependency
+    const parent = dependency.parentId ? nodes[dependency.parentId] : undefined
+    if (!parent) return [effectiveDependency]
+    const parentOverride = liveOverrides?.get(parent.id)
+    const effectiveParent = parentOverride ? ({ ...parent, ...parentOverride } as AnyNode) : parent
+    return [effectiveDependency, effectiveParent]
+  })
+}
+
+function buildFloorplanEntryGeometry({
+  ctxOverrides,
+  geometryCache,
+  highlighted,
+  hovered,
+  interactiveElevators,
+  levelDataCache,
+  levelNodeIdsByType,
+  live,
+  liveOverride,
+  liveOverrides,
+  moving,
+  node,
+  nodeId,
+  nodes,
+  palette,
+  selected,
+  siblingEpoch,
+  unit,
+  visibilityRootId,
+}: BuildFloorplanEntryGeometryArgs): CacheEntry | null {
+  const def = nodeRegistry.get(node.type)
+  const builder = def?.floorplan
+  if (!builder) return null
+
+  const visible = visibilityRootId
+    ? isFloorplanHierarchyVisible(node, nodes, liveOverrides, visibilityRootId)
+    : isFloorplanNodeVisible(node, liveOverride)
+  if (!visible) {
+    geometryCache.delete(nodeId)
+    return null
+  }
+
+  const dependsOnSiblingInputs = !!(
+    def.floorplanDependsOnSiblings ||
+    def.floorplanSiblingOverrides ||
+    def.floorplanAffectedIds
+  )
+  const dependencyNodes = collectFloorplanDependencyNodes(def, node, nodes, liveOverrides)
+  const deps: NodeDeps = {
+    node,
+    live,
+    unit,
+    selected,
+    highlighted,
+    hovered,
+    moving,
+    liveOverride,
+    palette,
+    siblingEpoch: dependsOnSiblingInputs ? siblingEpoch : 0,
+    // Sibling-dependent kinds (wall miters, opening cuts) read other nodes'
+    // committed state via `ctx`, so committed sibling edits still invalidate.
+    committedNodes: dependsOnSiblingInputs ? nodes : null,
+    dependencyNodes,
+    interactiveElevators,
+  }
+  const cached = geometryCache.get(nodeId)
+  if (cached && nodeDepsEqual(cached.deps, deps)) return cached
+
+  const applyLiveTransform = (sourceNode: AnyNode): AnyNode => {
+    if (!live) return sourceNode
+    const hasPosition = Array.isArray((sourceNode as { position?: unknown }).position)
+    const parentFrameProjection = nodeRegistry.get(sourceNode.type)?.capabilities?.movable
+      ?.parentFrame?.floorplanLiveTransform
+    if (parentFrameProjection) {
+      return parentFrameProjection({ node: sourceNode, live })
+    }
+    if (sourceNode.type === 'door' || sourceNode.type === 'window') {
+      const r = (sourceNode as { rotation?: unknown }).rotation
+      return {
+        ...sourceNode,
+        position: live.position,
+        rotation: Array.isArray(r)
+          ? [(r[0] as number) ?? 0, live.rotation, (r[2] as number) ?? 0]
+          : r,
+      } as AnyNode
+    }
+    if ((def.capabilities?.floorPlaced || def.floorplanScope === 'building') && hasPosition) {
+      return applyPositionLiveTransform(sourceNode, live)
+    }
+    if (sourceNode.type === 'slab' || sourceNode.type === 'ceiling' || sourceNode.type === 'zone') {
+      const dx = live.position[0]
+      const dz = live.position[2]
+      if (dx === 0 && dz === 0) return sourceNode
+      const surface = sourceNode as {
+        polygon: Array<[number, number]>
+        holes?: Array<Array<[number, number]>>
+      }
+      return {
+        ...sourceNode,
+        polygon: surface.polygon.map(([x, z]) => [x + dx, z + dz] as [number, number]),
+        holes: (surface.holes ?? []).map((h) =>
+          h.map(([x, z]) => [x + dx, z + dz] as [number, number]),
+        ),
+      } as AnyNode
+    }
+    return sourceNode
+  }
+
+  const contextNodes = def.floorplanSiblingOverrides
+    ? def.floorplanSiblingOverrides({
+        nodeId,
+        nodes,
+        liveTransforms: useLiveTransforms.getState().transforms,
+        liveOverrides,
+      })
+    : nodes
+  const sourceNode = contextNodes !== nodes ? (contextNodes[nodeId] ?? node) : node
+  const overrideNode = liveOverride ? ({ ...sourceNode, ...liveOverride } as AnyNode) : sourceNode
+  const effectiveNode = applyLiveTransform(overrideNode)
+  const levelData = getFloorplanLevelData(
+    node.type,
+    nodes,
+    liveOverrides,
+    levelNodeIdsByType,
+    levelDataCache,
+  )
+  const viewState = {
+    selected,
+    unit,
+    highlighted,
+    hovered,
+    moving,
+    palette,
+  }
+  const resolveContextNode = <N = AnyNode>(rid: AnyNodeId): N | undefined => {
+    const contextNode = contextNodes[rid]
+    if (!contextNode) return undefined
+    const contextOverride = liveOverrides.get(contextNode.id)
+    return (contextOverride ? { ...contextNode, ...contextOverride } : contextNode) as N
+  }
+  const ctx: GeometryContext = ctxOverrides
+    ? {
+        resolve: resolveContextNode,
+        children: ctxOverrides.children,
+        siblings: ctxOverrides.siblings,
+        parent: ctxOverrides.parent,
+        levelData,
+        viewState: palette
+          ? {
+              selected,
+              unit,
+              highlighted,
+              hovered,
+              moving,
+              palette,
+            }
+          : undefined,
+      }
+    : {
+        ...buildContext(effectiveNode, contextNodes, viewState, levelData),
+        resolve: resolveContextNode,
+      }
+  const geometry = (builder as (n: AnyNode, c: GeometryContext) => FloorplanGeometry | null)(
+    effectiveNode,
+    ctx,
+  )
+  const { base, overlay } = geometry
+    ? splitFloorplanOverlay(geometry)
+    : { base: null, overlay: null }
+  const entry: CacheEntry = { deps, base, overlay, node: effectiveNode }
+  geometryCache.set(nodeId, entry)
+  return entry
+}
+
+export function getFloorplanLevelData(
+  type: string,
+  nodes: Record<string, AnyNode>,
+  liveOverrides: Map<string, LiveNodeOverrides>,
+  levelNodeIdsByType: ReadonlyMap<string, readonly AnyNodeId[]>,
+  levelDataCache: Map<string, LevelDataCacheEntry>,
+): unknown {
+  const def = nodeRegistry.get(type)
+  if (!def?.computeFloorplanLevelData) return undefined
+  const ids = levelNodeIdsByType.get(type)
+  const sampleId = ids?.[0]
+  if (!ids || !sampleId) return undefined
+
+  const cached = levelDataCache.get(type)
+  if (
+    cached &&
+    cached.nodes === nodes &&
+    cached.liveOverrides === liveOverrides &&
+    cached.ids === ids
+  ) {
+    return cached.value
+  }
+
+  const computeLevelData = def.computeFloorplanLevelData as FloorplanLevelDataHook
+  const contextNodes = def.floorplanSiblingOverrides
+    ? def.floorplanSiblingOverrides({
+        nodeId: sampleId,
+        nodes,
+        liveTransforms: useLiveTransforms.getState().transforms,
+        liveOverrides,
+      })
+    : nodes
+  const siblings: AnyNode[] = []
+  for (const id of ids) {
+    const sibling = contextNodes[id]
+    if (sibling?.type === type) siblings.push(sibling)
+  }
+  const value = computeLevelData({ siblings, nodes: contextNodes })
+  levelDataCache.set(type, { nodes, liveOverrides, ids, value })
+  return value
+}
+
+// ── Interactive geometry walker ──────────────────────────────────────
+
+type InteractiveGeometryProps = {
   geometry: FloorplanGeometry
   unitsPerPixel: number
   palette: FloorplanPalette | undefined
   hatchPatternId: string | undefined
   hoveredHandleId: string | null
   activeDragId: string | null
+  activeRotateNodeId: AnyNodeId | null
   isMarqueeSelectionActive: boolean
   nodeId: AnyNodeId
   sceneRotationDeg: number
   onHandleHoverChange: (id: string | null) => void
+  onHandleDoubleClick: (
+    affordance: string,
+    payload: unknown,
+    event: ReactMouseEvent<SVGElement>,
+  ) => void
   onHandlePointerDown: (
     affordance: string,
     payload: unknown,
@@ -866,7 +1923,24 @@ function InteractiveGeometry({
     rotationPivot?: FloorplanPoint,
   ) => void
   onMoveHandlePointerDown: (event: ReactPointerEvent<SVGGElement>) => void
-}): React.ReactElement {
+}
+
+const InteractiveGeometry = memo(function InteractiveGeometry({
+  geometry,
+  unitsPerPixel,
+  palette,
+  hatchPatternId,
+  hoveredHandleId,
+  activeDragId,
+  activeRotateNodeId,
+  isMarqueeSelectionActive,
+  nodeId,
+  sceneRotationDeg,
+  onHandleDoubleClick,
+  onHandleHoverChange,
+  onHandlePointerDown,
+  onMoveHandlePointerDown,
+}: InteractiveGeometryProps): React.ReactElement {
   return renderInteractive(geometry, 0)
 
   function renderInteractive(g: FloorplanGeometry, keyHint: number): React.ReactElement {
@@ -911,6 +1985,7 @@ function InteractiveGeometry({
       case 'endpoint-handle': {
         if (!palette) return <></>
         const handleId = makeHandleId(nodeId, g.payload)
+        const doubleClickAffordance = floorplanHandleDoubleClickAffordance(g)
         const isHovered = hoveredHandleId === handleId
         const isActive = activeDragId === handleId
         // Variant picks the colour-set. Endpoint dots use the orange
@@ -992,6 +2067,15 @@ function InteractiveGeometry({
               cx={g.point[0]}
               cy={g.point[1]}
               fill="transparent"
+              onDoubleClick={
+                doubleClickAffordance
+                  ? (event) => {
+                      event.preventDefault()
+                      event.stopPropagation()
+                      onHandleDoubleClick(doubleClickAffordance, g.payload, event)
+                    }
+                  : undefined
+              }
               onPointerDown={(e) =>
                 onHandlePointerDown(g.affordance, g.payload, e as ReactPointerEvent<SVGGElement>)
               }
@@ -1095,7 +2179,7 @@ function InteractiveGeometry({
         // each end pointing tangentially in opposite directions —
         // "rotate either way."
         const handleId = makeHandleId(nodeId, g.payload)
-        const isHovered = hoveredHandleId === handleId
+        const isHovered = hoveredHandleId === handleId || activeRotateNodeId === nodeId
         // Arc geometry (all values precomputed for a 72° arc of
         // radius 0.13 — comparable footprint to `move-arrow`).
         const R = 0.13
@@ -1402,35 +2486,96 @@ function InteractiveGeometry({
         // and flip by 180° if it falls outside (-90, 90] — that keeps
         // text reading left-to-right, top-to-bottom regardless of the
         // building's orientation.
+        const degrees = resolveFloorplanLabelAngle(g.angle, sceneRotationDeg, g.screenUpright)
+
+        const labelUnitsPerPixel = Math.max(unitsPerPixel, 1e-6)
+        const outlined = g.appearance === 'outlined'
+        const padX = labelUnitsPerPixel * 6
+        const padY = labelUnitsPerPixel * 3
+        const fontSize = labelUnitsPerPixel * (outlined ? 12 : 10)
+        // Rough text width approximation — SVG can't measure text without
+        // the DOM. 6.2px per char at 10px font keeps the plate visually
+        // balanced for the short length strings ("3.24m", "1'2\"", etc.).
+        const textWidth = g.text.length * labelUnitsPerPixel * 6.2
+        const plateW = textWidth + padX * 2
+        const plateH = fontSize + padY * 2
+        return (
+          <g
+            key={keyHint}
+            pointerEvents="none"
+            transform={`translate(${g.cx} ${g.cy}) rotate(${degrees}) translate(0 ${-(g.offsetPx ?? 0) * labelUnitsPerPixel})`}
+          >
+            {outlined ? null : (
+              <rect
+                fill={palette.measurementLabelBackground}
+                height={plateH}
+                opacity={0.92}
+                rx={labelUnitsPerPixel * 3}
+                ry={labelUnitsPerPixel * 3}
+                stroke={palette.measurementStroke}
+                strokeWidth={labelUnitsPerPixel * 0.5}
+                vectorEffect="non-scaling-stroke"
+                width={plateW}
+                x={-plateW / 2}
+                y={-plateH / 2}
+              />
+            )}
+            <text
+              dominantBaseline="middle"
+              fill={outlined ? '#ffffff' : palette.measurementLabelText}
+              fontFamily={
+                outlined
+                  ? 'system-ui, -apple-system, sans-serif'
+                  : 'ui-monospace, SFMono-Regular, Menlo, monospace'
+              }
+              fontSize={fontSize}
+              fontWeight={outlined ? 500 : 600}
+              paintOrder={outlined ? 'stroke' : undefined}
+              stroke={outlined ? palette.measurementStroke : undefined}
+              strokeLinecap={outlined ? 'round' : undefined}
+              strokeLinejoin={outlined ? 'round' : undefined}
+              strokeWidth={outlined ? fontSize * 0.35 : undefined}
+              textAnchor="middle"
+              x={0}
+              y={0}
+            >
+              {g.text}
+            </text>
+          </g>
+        )
+      }
+      case 'equal-spacing-badge': {
+        // A distinct accent (Figma-style "=" rhythm) so equal spacing reads
+        // apart from the orange placement dimensions. Same screen-upright flip
+        // as the dimension-label case above.
+        const accent = '#ec4899'
         let degrees = (g.angle * 180) / Math.PI
         let screenDegrees = degrees + sceneRotationDeg
         screenDegrees = ((((screenDegrees + 180) % 360) + 360) % 360) - 180
         if (screenDegrees > 90) degrees -= 180
         else if (screenDegrees <= -90) degrees += 180
 
+        const label = `= ${g.text}`
         const padX = unitsPerPixel * 6
         const padY = unitsPerPixel * 3
         const fontSize = Math.max(unitsPerPixel * 10, 0.08)
-        // Rough text width approximation — SVG can't measure text without
-        // the DOM. 6.2px per char at 10px font keeps the plate visually
-        // balanced for the short length strings ("3.24m", "1'2\"", etc.).
-        const textWidth = g.text.length * unitsPerPixel * 6.2
+        const textWidth = label.length * unitsPerPixel * 6.2
         const plateW = textWidth + padX * 2
         const plateH = fontSize + padY * 2
         return (
           <g
             key={keyHint}
             pointerEvents="none"
-            transform={`translate(${g.cx} ${g.cy}) rotate(${degrees})`}
+            transform={`translate(${g.point[0]} ${g.point[1]}) rotate(${degrees})`}
           >
             <rect
-              fill={palette.measurementLabelBackground}
+              fill="#ffffff"
               height={plateH}
-              opacity={0.92}
+              opacity={0.95}
               rx={unitsPerPixel * 3}
               ry={unitsPerPixel * 3}
-              stroke={palette.measurementStroke}
-              strokeWidth={unitsPerPixel * 0.5}
+              stroke={accent}
+              strokeWidth={unitsPerPixel * 0.75}
               vectorEffect="non-scaling-stroke"
               width={plateW}
               x={-plateW / 2}
@@ -1438,15 +2583,15 @@ function InteractiveGeometry({
             />
             <text
               dominantBaseline="middle"
-              fill={palette.measurementLabelText}
+              fill={accent}
               fontFamily="ui-monospace, SFMono-Regular, Menlo, monospace"
               fontSize={fontSize}
-              fontWeight={600}
+              fontWeight={700}
               textAnchor="middle"
               x={0}
               y={0}
             >
-              {g.text}
+              {label}
             </text>
           </g>
         )
@@ -1634,10 +2779,25 @@ function InteractiveGeometry({
         )
     }
   }
-}
+}, shallowPropsAreEqual)
 
 // ── Helpers ──────────────────────────────────────────────────────────
 
+function shallowPropsAreEqual<T extends object>(a: T, b: T): boolean {
+  const aKeys = Object.keys(a) as Array<keyof T>
+  const bKeys = Object.keys(b) as Array<keyof T>
+  if (aKeys.length !== bKeys.length) return false
+  for (const key of aKeys) {
+    if (!Object.is(a[key], b[key])) return false
+  }
+  return true
+}
+
+function handleIdForNode(handleId: string | null, nodeId: AnyNodeId): string | null {
+  if (!handleId) return null
+  return handleId === nodeId || handleId.startsWith(`${nodeId}:`) ? handleId : null
+}
+
 function applyPositionLiveTransform(
   node: AnyNode,
   live: { position: [number, number, number]; rotation: number },
@@ -1661,16 +2821,44 @@ function applyPositionLiveTransform(
   } as AnyNode
 }
 
-function buildContext(
+export function isFloorplanNodeVisible(node: AnyNode, liveOverride?: LiveNodeOverrides): boolean {
+  const overrideVisible = liveOverride?.visible
+  if (typeof overrideVisible === 'boolean') return overrideVisible
+  return (node as { visible?: boolean }).visible !== false
+}
+
+function isFloorplanHierarchyVisible(
+  node: AnyNode,
+  nodes: Record<string, AnyNode>,
+  liveOverrides: Map<string, LiveNodeOverrides>,
+  rootId: AnyNodeId,
+): boolean {
+  let current: AnyNode | undefined = node
+  const seen = new Set<AnyNodeId>()
+  while (current) {
+    if (seen.has(current.id)) return true
+    seen.add(current.id)
+    if (!isFloorplanNodeVisible(current, liveOverrides.get(current.id))) return false
+    if (current.id === rootId) return true
+    const parentId = current.parentId as AnyNodeId | null
+    if (!parentId) return true
+    current = nodes[parentId]
+  }
+  return true
+}
+
+export function buildContext(
   node: AnyNode,
   nodes: Record<string, AnyNode>,
   viewState: {
     selected: boolean
+    unit: 'metric' | 'imperial'
     highlighted: boolean
     hovered: boolean
     moving: boolean
     palette: FloorplanPalette | undefined
   },
+  levelData?: unknown,
 ): GeometryContext {
   const resolve = <N = AnyNode>(id: AnyNodeId): N | undefined => nodes[id] as N | undefined
 
@@ -1703,9 +2891,11 @@ function buildContext(
     children,
     siblings,
     parent,
+    levelData,
     viewState: viewState.palette
       ? {
           selected: viewState.selected,
+          unit: viewState.unit,
           highlighted: viewState.highlighted,
           hovered: viewState.hovered,
           moving: viewState.moving,
@@ -1735,6 +2925,14 @@ function makeHandleId(nodeId: AnyNodeId, payload: unknown): string {
   return `${nodeId}:${String(payload)}`
 }
 
+export function floorplanHandleDoubleClickAffordance(
+  geometry: FloorplanGeometry,
+): 'delete-vertex' | null {
+  return geometry.kind === 'endpoint-handle' && geometry.affordance === 'move-vertex'
+    ? 'delete-vertex'
+    : null
+}
+
 /**
  * Geometry kinds that always render in the overlay pass — interactive
  * handles and node labels. These need to sit above every kind's base
@@ -1754,6 +2952,7 @@ const OVERLAY_KINDS = new Set<FloorplanGeometry['kind']>([
   'rotate-arrow',
   'dimension',
   'dimension-label',
+  'equal-spacing-badge',
 ])
 
 /**
@@ -1766,7 +2965,7 @@ const OVERLAY_KINDS = new Set<FloorplanGeometry['kind']>([
  * / translations apply in both passes. Empty groups collapse to `null`
  * so the caller can skip emitting an `<g>` when there's nothing to draw.
  */
-function splitFloorplanOverlay(g: FloorplanGeometry): {
+export function splitFloorplanOverlay(g: FloorplanGeometry): {
   base: FloorplanGeometry | null
   overlay: FloorplanGeometry | null
 } {
@@ -1794,6 +2993,172 @@ function splitFloorplanOverlay(g: FloorplanGeometry): {
   return { base: g, overlay: null }
 }
 
+/**
+ * Per-node edit chrome hidden while a multi-selection is active: the group is
+ * manipulated as one rigid piece (drag to move, R/T to rotate), so individual
+ * handles / dimension labels on each member would mislead. `text` stays —
+ * zone names are identification, not editing chrome.
+ */
+const HANDLE_CHROME_KINDS = new Set<FloorplanGeometry['kind']>([
+  'endpoint-handle',
+  'midpoint-handle',
+  'edge-handle',
+  'move-handle',
+  'move-arrow',
+  'rotate-arrow',
+  'dimension',
+  'dimension-label',
+  'equal-spacing-badge',
+])
+
+function stripHandleChrome(g: FloorplanGeometry): FloorplanGeometry | null {
+  if (HANDLE_CHROME_KINDS.has(g.kind)) return null
+  if (g.kind === 'group') {
+    const children = g.children
+      .map(stripHandleChrome)
+      .filter((c): c is FloorplanGeometry => c !== null)
+    if (children.length === 0) return null
+    return { kind: 'group', children, transform: g.transform }
+  }
+  return g
+}
+
+// Stable string key for a wall endpoint, rounded to 1 mm so floating-point
+// drift collapses while distinct corners stay distinct.
+function endpointKey(x: number, y: number): string {
+  return `${Math.round(x * 1000)},${Math.round(y * 1000)}`
+}
+
+// Given the sibling-dependent nodes with a live drag in flight, the set of
+// floor-plan geometries that must rebuild this frame. A node's geometry depends
+// on more than its own data:
+//   - a wall's miters depend on the walls meeting at each of its endpoints, so a
+//     dragged wall invalidates the walls at its old AND new junctions, plus its
+//     own door/window children (their cuts are drawn into it);
+//   - a door/window cut is drawn into its host wall, so it invalidates that wall;
+//   - a gutter join depends on sibling gutters under the same roof.
+// Everything else stays cached, so dragging one wall/opening rebuilds a handful
+// of geometries rather than every wall + opening on the level.
+export function computeAffectedSiblingIds(
+  liveFlaggedIds: readonly AnyNodeId[],
+  nodes: Record<string, AnyNode>,
+  liveOverrides: Map<string, Record<string, unknown>>,
+): Set<AnyNodeId> {
+  const affected = new Set<AnyNodeId>()
+  if (liveFlaggedIds.length === 0) return affected
+
+  // Junction map (committed wall endpoint → wall ids), built lazily on first use.
+  let junctions: Map<string, AnyNodeId[]> | null = null
+  const wallsAtPoint = (x: number, y: number): AnyNodeId[] => {
+    if (!junctions) {
+      junctions = new Map()
+      for (const id in nodes) {
+        const n = nodes[id]
+        if (n?.type !== 'wall') continue
+        const w = n as unknown as { start: [number, number]; end: [number, number] }
+        for (const [px, py] of [w.start, w.end]) {
+          const key = endpointKey(px, py)
+          const arr = junctions.get(key)
+          if (arr) arr.push(id as AnyNodeId)
+          else junctions.set(key, [id as AnyNodeId])
+        }
+      }
+    }
+    return junctions.get(endpointKey(x, y)) ?? []
+  }
+
+  for (const id of liveFlaggedIds) {
+    const node = nodes[id]
+    if (!node) continue
+    affected.add(id)
+    const def = nodeRegistry.get(node.type)
+    const extraAffectedIds = def?.floorplanAffectedIds?.({
+      nodeId: id,
+      node,
+      nodes: nodes as Record<AnyNodeId, AnyNode>,
+      liveTransforms: useLiveTransforms.getState().transforms,
+      liveOverrides,
+    })
+    if (extraAffectedIds) {
+      for (const extraId of extraAffectedIds) affected.add(extraId)
+    }
+    if (node.type === 'wall') {
+      const w = node as unknown as {
+        start: [number, number]
+        end: [number, number]
+        children?: AnyNodeId[]
+      }
+      // Use the live (override-merged) endpoints as well as the committed ones,
+      // so walls at both the wall's old and new junctions get fresh miters.
+      const ov = liveOverrides.get(id) as
+        | { start?: [number, number]; end?: [number, number] }
+        | undefined
+      const points: [number, number][] = [w.start, w.end]
+      if (ov?.start) points.push(ov.start)
+      if (ov?.end) points.push(ov.end)
+      for (const [px, py] of points) {
+        for (const wid of wallsAtPoint(px, py)) affected.add(wid)
+      }
+      if (Array.isArray(w.children)) {
+        for (const cid of w.children) {
+          const child = nodes[cid]
+          if (child?.type === 'door' || child?.type === 'window') affected.add(cid)
+        }
+      }
+    } else if (node.type === 'door' || node.type === 'window') {
+      const hostId = (node as { parentId?: string }).parentId
+      if (hostId) affected.add(hostId as AnyNodeId)
+      const liveHostId = (liveOverrides.get(id) as { parentId?: string } | undefined)?.parentId
+      if (liveHostId) affected.add(liveHostId as AnyNodeId)
+    } else if (node.type === 'gutter') {
+      const roofId = (node as { parentId?: string }).parentId
+      if (roofId) {
+        for (const sid in nodes) {
+          const s = nodes[sid]
+          if (s?.type === 'gutter' && (s as { parentId?: string }).parentId === roofId) {
+            affected.add(sid as AnyNodeId)
+          }
+        }
+      }
+    }
+  }
+  return affected
+}
+
+function nodeDepsEqual(a: NodeDeps, b: NodeDeps): boolean {
+  const keys: Array<keyof NodeDeps> = [
+    'node',
+    'live',
+    'unit',
+    'selected',
+    'highlighted',
+    'hovered',
+    'moving',
+    'liveOverride',
+    'palette',
+    'siblingEpoch',
+    'committedNodes',
+    'dependencyNodes',
+    'interactiveElevators',
+  ]
+  for (const key of keys) {
+    if (!depsValueEqual(a[key], b[key])) return false
+  }
+  return true
+}
+
+function depsValueEqual(a: unknown, b: unknown): boolean {
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b)) return false
+    if (a.length !== b.length) return false
+    for (let i = 0; i < a.length; i++) {
+      if (!Object.is(a[i], b[i])) return false
+    }
+    return true
+  }
+  return Object.is(a, b)
+}
+
 /**
  * Z-order bucket for floor-plan rendering. Lower rank = painted first =
  * sits under everything with a higher rank. SVG renders in document
@@ -1809,7 +3174,7 @@ function splitFloorplanOverlay(g: FloorplanGeometry): {
  * Sort is stable in modern JS engines, so siblings within the same
  * bucket keep their DFS order (= scene tree order).
  */
-function floorplanLayerRank(type: string): number {
+export function floorplanLayerRank(type: string): number {
   switch (type) {
     case 'zone':
       return 0
@@ -1855,14 +3220,17 @@ const ROTATION_WEDGE_SEGMENTS = 48
  * is in plan coords; the chip counter-rotates `sceneRotationDeg` so it reads
  * horizontally regardless of the building's on-screen orientation.
  */
-function RotationAngleOverlay({
+export function RotationAngleOverlay({
   overlay,
   palette,
   unitsPerPixel,
   sceneRotationDeg,
 }: {
   overlay: RotationOverlayState
-  palette: FloorplanPalette
+  palette: Pick<
+    FloorplanPalette,
+    'measurementLabelBackground' | 'measurementLabelText' | 'measurementStroke'
+  >
   unitsPerPixel: number
   sceneRotationDeg: number
 }): React.ReactElement {
@@ -1944,20 +3312,14 @@ function formatGroupTransform(t?: {
   return parts.length > 0 ? parts.join(' ') : undefined
 }
 
-function clientToPlan(clientX: number, clientY: number): FloorplanAffordancePoint | null {
-  // The registry layer lives under the floor-plan scene `<g>`. The
-  // legacy panel computes the same conversion via floorplanSceneRef +
-  // getScreenCTM; we replicate it by walking up to the SVG owner.
-  const target = document.querySelector('g[data-floorplan-scene]') as SVGGElement | null
-  const svg = target?.ownerSVGElement
-  if (!(svg && target)) return null
-  const ctm = target.getScreenCTM()
-  if (!ctm) return null
-  const point = svg.createSVGPoint()
-  point.x = clientX
-  point.y = clientY
-  const transformed = point.matrixTransform(ctm.inverse())
-  // The floor-plan `<g>` maps plan X/Z directly to SVG x/y (Z stored as
-  // the Y axis on screen — same convention as `toSvgPlanPoint`).
-  return [transformed.x, transformed.y]
+function swallowNextClick(timeoutMs = 0) {
+  const swallowClick = (event: MouseEvent) => {
+    event.stopPropagation()
+    event.preventDefault()
+    window.removeEventListener('click', swallowClick, true)
+  }
+  window.addEventListener('click', swallowClick, true)
+  setTimeout(() => {
+    window.removeEventListener('click', swallowClick, true)
+  }, timeoutMs)
 }