@pascal-app/editor 0.9.1 → 1.0.0-beta.1

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

@@ -2,38 +2,121 @@
 
 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 {
+  type ComponentProps,
   memo,
+  type MouseEvent as ReactMouseEvent,
   type PointerEvent as ReactPointerEvent,
   useCallback,
   useEffect,
+  useLayoutEffect,
   useMemo,
   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 {
+  type FloorplanAnnotationVisibility,
+  filterFloorplanAnnotationGeometry,
+} from '../../../lib/floorplan/annotation-visibility'
+import { resolveNodeForDrawingType } from '../../../lib/floorplan/drawing-coordination'
+import {
+  createFloorplanContextExtensions,
+  type FloorplanAnnotationRole,
+  type FloorplanWallDimensionReference,
+  getFloorplanNodeExtension,
+  readFloorplanGeometryMetadata,
+  withFloorplanGeometryMetadata,
+} from '../../../lib/floorplan/floorplan-extension'
+import {
+  type FloorplanMode,
+  resolveFloorplanAnnotationVisibility,
+  resolveFloorplanWallDimensionReference,
+} from '../../../lib/floorplan/floorplan-mode'
+import { clientToPlan } from '../../../lib/floorplan/plan-coords'
+import {
+  type ActiveInteractionScope,
+  boundaryReshapeScope,
+  controlPointReshapeScope,
+  curveReshapeScope,
+  endpointReshapeScope,
+  holeEditScope,
+  isIdle,
+  tangentReshapeScope,
+} from '../../../lib/interaction/scope'
+import { emitCanvasNodeSelection } from '../../../lib/selection-routing'
 import { sfxEmitter } from '../../../lib/sfx-bus'
-import useEditor from '../../../store/use-editor'
-import { useFloorplanRender } from '../floorplan-render-context'
+import { clearSurfacePlanSnapFeedback } from '../../../lib/surface-plan-snap'
+import useDirectManipulationFeedback from '../../../store/use-direct-manipulation-feedback'
+import useDrawingView from '../../../store/use-drawing-view'
+import useEditor, { isAngleSnapActive } from '../../../store/use-editor'
+import useFloorplanAnnotationVisibility from '../../../store/use-floorplan-annotation-visibility'
+import useFloorplanMode from '../../../store/use-floorplan-mode'
+import useInteractionScope, {
+  getMovingNode,
+  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 {
+  useFloorplanSceneRotation,
+  useFloorplanStaticRender,
+  useFloorplanStaticUnitsPerPixel,
+} from '../floorplan-render-context'
+import {
+  floorplanAnnotationObstacleMode,
+  isFloorplanAnnotationObstacleGeometry,
+  resolveSvgAnnotationCollisions,
+  svgAnnotationLabelId,
+} from './floorplan-annotation-layout'
+import { FloorplanDimensionRenderer } from './floorplan-dimension-renderer'
 import { FloorplanGeometryRenderer } from './floorplan-geometry-renderer'
+import {
+  resolveFloorplanAnnotationUpdate,
+  resolveFloorplanLabelAngle,
+  updateSvgFloorplanLabelOrientations,
+} from './floorplan-label-angle'
 
 /**
  * Registry-driven floor-plan layer.
@@ -60,8 +143,8 @@ import { FloorplanGeometryRenderer } from './floorplan-geometry-renderer'
  */
 // Handle / hit-area sizes mirror the legacy `FLOORPLAN_ENDPOINT_HANDLE_*`
 // constants in floorplan-panel.tsx. Sizes are in screen pixels — the
-// dispatcher multiplies by `unitsPerPixel` so handles stay the same on-
-// screen size at any zoom.
+// dispatcher multiplies by `unitsPerPixel` so handles stay screen-sized
+// until the world-space ceiling takes over at extreme zoom-out.
 const ENDPOINT_HANDLE_SELECTED_RADIUS_PX = 8
 const ENDPOINT_HANDLE_ACTIVE_RADIUS_PX = 9
 const ENDPOINT_HANDLE_DOT_RADIUS_PX = 3
@@ -70,6 +153,21 @@ 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
+const MAX_HANDLE_UNITS_PER_PIXEL = 0.015
+
+export function resolveFloorplanHandleUnitsPerPixel(unitsPerPixel: number): number {
+  return Math.min(unitsPerPixel, MAX_HANDLE_UNITS_PER_PIXEL)
+}
+
+const ScaleAwareFloorplanGroupSelectionBox = memo(function ScaleAwareFloorplanGroupSelectionBox(
+  props: Omit<ComponentProps<typeof FloorplanGroupSelectionBox>, 'unitsPerPixel'>,
+) {
+  const unitsPerPixel = useFloorplanStaticUnitsPerPixel()
+  return <FloorplanGroupSelectionBox {...props} unitsPerPixel={unitsPerPixel} />
+})
 
 /**
  * Snapshot of node fields captured at drag-start, used by the single-undo
@@ -82,11 +180,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 +199,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`).
+export function floorplanAffordanceReshapeScope(
+  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, driver: 'floorplan' })
+      : boundaryReshapeScope(nodeId, 'floorplan')
+  }
+  if (affordance.includes('curve')) {
+    return curveReshapeScope(nodeId, 'floorplan')
+  }
+  if (affordance.includes('control-point')) {
+    const index = (payload as { index?: number } | undefined)?.index ?? 0
+    return controlPointReshapeScope(nodeId, index, 'floorplan')
+  }
+  if (affordance.includes('tangent')) {
+    const target = payload as { index?: number; side?: 'in' | 'out' } | undefined
+    return tangentReshapeScope(nodeId, target?.index ?? 0, target?.side ?? 'out', 'floorplan')
+  }
+  if (affordance.includes('endpoint')) {
+    const endpoint = (payload as { endpoint?: 'start' | 'end' } | undefined)?.endpoint ?? 'end'
+    return endpointReshapeScope(nodeId, endpoint, 'floorplan')
+  }
+  // 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, 'floorplan')
+  }
+  // 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 +318,93 @@ type RotationOverlayState = {
   sweep: number
 }
 
+type FloorplanEntryDescriptor = {
+  id: AnyNodeId
+  node: AnyNode
+  dependsOnSiblingInputs: boolean
+  ctxOverrides?: FloorplanContextOverrides
+}
+
+type NodeDeps = {
+  automaticDimensions: boolean
+  node: AnyNode
+  live: LiveTransform | undefined
+  unit: 'metric' | 'imperial'
+  metricNotation: 'meters' | 'millimeters'
+  wallDimensionReference: FloorplanWallDimensionReference
+  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
+
+export function isFloorplanOpeningPlacementState({
+  phase,
+  mode,
+  tool,
+  movingNodeHasWallOpeningPlacement,
+}: {
+  phase: string
+  mode: string
+  tool: string | null
+  movingNodeHasWallOpeningPlacement: boolean
+}): boolean {
+  return (
+    (phase === 'structure' && mode === 'build' && (tool === 'door' || tool === 'window')) ||
+    movingNodeHasWallOpeningPlacement
+  )
+}
+
+function isFloorplanOpeningPlacementActiveNow(): boolean {
+  const { phase, mode, tool } = useEditor.getState()
+  const movingNode = getMovingNode()
+  return isFloorplanOpeningPlacementState({
+    phase,
+    mode,
+    tool,
+    movingNodeHasWallOpeningPlacement:
+      movingNode != null && !!nodeRegistry.get(movingNode.type)?.capabilities?.wallOpeningPlacement,
+  })
+}
+
 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 +420,27 @@ 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 selectedIds = useViewer((s) => s.selection.selectedIds)
-  const previewSelectedIds = useViewer((s) => s.previewSelectedIds)
-  const hoveredId = useViewer((s) => s.hoveredId)
-  const setHoveredId = useViewer((s) => s.setHoveredId)
+  const unit = useViewer((s) => s.unit)
+  const metricNotation = useViewer((s) => s.metricNotation)
   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 +450,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
@@ -174,9 +472,10 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
 
   const levelId = selectedLevelId ?? ambientLevelId
   const isAmbient = !selectedLevelId && !!ambientLevelId
-  const renderCtx = useFloorplanRender()
-  const movingNode = useEditor((s) => s.movingNode)
+  const renderCtx = useFloorplanStaticRender()
+  const sceneRotationDeg = renderCtx?.getSceneRotationDeg() ?? 0
   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
@@ -184,53 +483,124 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
   // wall's registry entry would otherwise swallow the click via
   // `handleClickStop` / `handleSelect`, so the placement never fires.
   // Pass clicks through in that case.
-  const editorPhase = useEditor((s) => s.phase)
   const editorMode = useEditor((s) => s.mode)
-  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 isOpeningPlacementActive =
-    (editorPhase === 'structure' &&
-      editorMode === 'build' &&
-      (editorTool === 'door' || editorTool === 'window')) ||
-    (movingNode != null && !!nodeRegistry.get(movingNode.type)?.capabilities?.wallOpeningPlacement)
+  const endpointReshape = useEndpointReshape()
   const isMarqueeSelectionActive =
     editorMode === 'select' &&
     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')
+  const drawingType = useDrawingView((s) => s.drawingType)
+  const annotationVisibility = useFloorplanAnnotationVisibility((s) => s.visibility)
+  const wallDimensionReference = useFloorplanAnnotationVisibility((s) => s.wallDimensionReference)
+  const floorplanMode = useFloorplanMode((s) => s.mode)
+  const effectiveWallDimensionReference = resolveFloorplanWallDimensionReference(
+    floorplanMode,
+    wallDimensionReference,
+  )
+  // 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])
-
   // Interactive state lives in refs; only the visible feedback bits go
   // into React state to keep re-renders cheap during drag.
   const dragRef = useRef<ActiveDrag | null>(null)
   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
+      const nextSelectedIds = shouldToggle
+        ? currentSelectedIds.includes(id)
+          ? currentSelectedIds.filter((selectedId) => selectedId !== id)
+          : [...currentSelectedIds, id]
+        : [id]
+      setSelection({ selectedIds: nextSelectedIds })
+      if (nextSelectedIds.length === 1 && nextSelectedIds[0] === id) {
+        const node = useScene.getState().nodes[id]
+        if (node) emitCanvasNodeSelection(node)
+      }
       // 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 +609,329 @@ 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>) => {
+    if (isFloorplanOpeningPlacementActiveNow()) return
     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,
+          !isAngleSnapActive(),
         )
-        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>) => {
+      // Keep this handler mounted during opening placement and arbitrate from
+      // the stores at event time. Commit clears the interaction scope before
+      // React paints the next frame; a render-time `undefined` handler leaves
+      // a short dead zone where the first post-placement selection is lost.
+      if (isFloorplanOpeningPlacementActiveNow()) return
+      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 drawingNode = resolveNodeForDrawingType(node, nodes, drawingType)
+      if (!drawingNode) return
+      const def = nodeRegistry.get(drawingNode.type)
+      if (!def?.floorplan) return
+      const dependsOnSiblingInputs = !!(
+        def.floorplanDependsOnSiblings ||
+        def.floorplanSiblingOverrides ||
+        def.floorplanAffectedIds
+      )
+      const descriptor: FloorplanEntryDescriptor = { id, node: drawingNode, 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)
       }
@@ -369,6 +939,22 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
 
     visit(levelId as AnyNodeId)
 
+    const activeLevelNode = nodes[levelId as AnyNodeId] as AnyNode | undefined
+    if (activeLevelNode) {
+      const collectedIds = new Set(out.map((entry) => entry.id))
+      for (const linked of collectFloorplanLinkedLevelNodes(
+        nodes,
+        levelId as AnyNodeId,
+        collectedIds,
+      )) {
+        pushEntry(linked.id, linked.node, {
+          children: linked.children,
+          siblings: [],
+          parent: activeLevelNode,
+        })
+      }
+    }
+
     // Building-scoped kinds (`def.floorplanScope === 'building'`) live
     // as siblings of the level, not under it — the `visit(levelId)` DFS
     // above doesn't reach them. Walk every node of those kinds whose
@@ -377,7 +963,6 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
     // builders that gate on the current floor — e.g. elevator service
     // range — keep working). Pure registry-driven dispatch: no kind
     // name appears in this file.
-    const activeLevelNode = nodes[levelId as AnyNodeId] as AnyNode | undefined
     const activeBuildingId = activeLevelNode
       ? resolveBuildingForLevel(levelId as AnyNodeId, nodes)
       : null
@@ -386,54 +971,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 +990,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 }
+  }, [drawingType, installedPlugins, levelId, nodes])
 
   // ── Generic 2D affordance dispatch ─────────────────────────────────
   //
@@ -466,6 +1007,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 +1065,7 @@ export const FloorplanRegistryLayer = memo(function FloorplanRegistryLayer() {
 
       event.preventDefault()
       event.stopPropagation()
+      suppressBoxSelectForPointer(event)
 
       const session = handler.start({
         node,
@@ -525,22 +1098,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 = floorplanAffordanceReshapeScope(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 +1172,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 +1194,7 @@ 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
+        delta = snapDirectRotationDelta(delta, !isAngleSnapActive())
         if (Math.abs(delta) < 0.0087) {
           setRotationOverlay(null)
         } else {
@@ -603,14 +1229,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 +1259,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,209 +1284,1033 @@ 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)
+      window.removeEventListener('keydown', onModifierKeyChange)
+      window.removeEventListener('keyup', onModifierKeyChange)
+      unsubscribeToolCancel()
+      if (!cancelActiveDrag(undefined, false)) {
+        clearSurfacePlanSnapFeedback()
+      }
+    }
+  }, [])
+
+  const entries = floorplanData.entries
+  if (entries.length === 0) return null
+
+  const palette = renderCtx?.palette
+
+  return (
+    // The outer wrapper stops `click` events that escape an entry's
+    // `onClick={handleClickStop}`. The base+overlay split means
+    // pointer-down can land on the base `<g>` and pointer-up on the
+    // overlay `<g>` (selection mounts the overlay on top mid-gesture).
+    // When the down/up targets differ, the browser dispatches `click`
+    // to the lowest common ancestor — which sits ABOVE the entry-level
+    // handler. Without this guard the click reaches the SVG's
+    // `handleBackgroundClick`, which calls
+    // `resolveFloorplanBackgroundSelection` → `clear-elements` (because
+    // registry-driven items aren't in the legacy hit-test set) →
+    // clearing the selection that pointer-down just set, so items
+    // appear to "deselect themselves a fraction of a second after
+    // clicking." Scoped to `onClick` so hover / drag / pointer events
+    // still propagate normally inside the registry tree.
+    <g
+      className="floorplan-registry-layer"
+      onClick={handleClickStop}
+      opacity={isAmbient ? 0.3 : 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((entry) => (
+          <FloorplanRegistryEntry
+            activeDragId={handleIdForNode(activeDragId, entry.id)}
+            annotationVisibility={annotationVisibility}
+            floorplanMode={floorplanMode}
+            floorplanVisible={floorplanVisible}
+            geometryCacheRef={geometryCacheRef}
+            hatchPatternId={renderCtx?.hatchPatternId}
+            hoveredHandleId={handleIdForNode(hoveredHandleId, entry.id)}
+            interactiveElevators={interactiveElevators}
+            isMarqueeSelectionActive={isMarqueeSelectionActive}
+            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}
+            palette={palette}
+            pass="base"
+            sceneRotationDeg={sceneRotationDeg}
+            setMovingNode={setMovingNode}
+            setMovingNodeOrigin={setMovingNodeOrigin}
+            siblingEpoch={entry.dependsOnSiblingInputs ? (siblingEpochs.get(entry.id) ?? 0) : 0}
+            unit={unit}
+            metricNotation={metricNotation}
+            wallDimensionReference={effectiveWallDimensionReference}
+            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
+          entry so polygon-editor chrome on a selected slab stays above
+          neighbouring walls, and a zone name stays readable above the
+          slab + wall geometry sitting on top of the zone. Each overlay
+          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((entry) => (
+          <FloorplanRegistryEntry
+            activeDragId={handleIdForNode(activeDragId, entry.id)}
+            annotationVisibility={annotationVisibility}
+            floorplanMode={floorplanMode}
+            floorplanVisible={floorplanVisible}
+            geometryCacheRef={geometryCacheRef}
+            hatchPatternId={renderCtx?.hatchPatternId}
+            hoveredHandleId={handleIdForNode(hoveredHandleId, entry.id)}
+            interactiveElevators={interactiveElevators}
+            isMarqueeSelectionActive={isMarqueeSelectionActive}
+            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}
+            palette={palette}
+            pass="overlay"
+            sceneRotationDeg={sceneRotationDeg}
+            setMovingNode={setMovingNode}
+            setMovingNodeOrigin={setMovingNodeOrigin}
+            siblingEpoch={entry.dependsOnSiblingInputs ? (siblingEpochs.get(entry.id) ?? 0) : 0}
+            unit={unit}
+            metricNotation={metricNotation}
+            wallDimensionReference={effectiveWallDimensionReference}
+            visibilityRootId={entry.ctxOverrides ? undefined : (levelId as AnyNodeId)}
+            ctxOverrides={entry.ctxOverrides}
+          />
+        ))}
+      </g>
+      <FloorplanAnnotationLayoutResolver active={floorplanVisible} />
+      {/* 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. */}
+      <ScaleAwareFloorplanGroupSelectionBox
+        onPointerDown={handleGroupBoxPointerDown}
+        onRotatePointerDown={handleGroupBoxRotatePointerDown}
+        palette={palette}
+      />
+      {/* Transient live-rotation readout — drawn last so the wedge + degree
+          chip sit above all handle chrome while a rotate-arrow is dragged. */}
+      {rotationOverlay && palette ? (
+        <RotationAngleOverlay
+          overlay={rotationOverlay}
+          palette={palette}
+          sceneRotationDeg={sceneRotationDeg}
+        />
+      ) : null}
+    </g>
+  )
+})
+
+function FloorplanAnnotationLayoutResolver({ active }: { active: boolean }) {
+  const markerRef = useRef<SVGGElement>(null)
+  const collisionLabelElementsRef = useRef<SVGGElement[]>([])
+  const registryLabelElementsRef = useRef<SVGGElement[]>([])
+  const registryOrientationElementsRef = useRef<SVGGElement[]>([])
+  const appliedRotationDegRef = useRef<number | null>(null)
+  const appliedLayoutInputsRef = useRef<object | null>(null)
+  const interactionIdle = useInteractionScope((state) => isIdle(state.scope))
+  const sceneRotationDeg = useFloorplanSceneRotation()
+  const [settledLayoutEpoch, setSettledLayoutEpoch] = useState(0)
+  const drawingType = useDrawingView((state) => state.drawingType)
+  const annotationLayoutOverrides = useDrawingView((state) => state.annotationLayoutOverrides)
+  const annotationVisibility = useFloorplanAnnotationVisibility((state) => state.visibility)
+  const wallDimensionReference = useFloorplanAnnotationVisibility(
+    (state) => state.wallDimensionReference,
+  )
+  const floorplanMode = useFloorplanMode((state) => state.mode)
+  const layoutInputs = useMemo(
+    () => ({
+      annotationVisibility,
+      annotationLayoutOverrides,
+      drawingType,
+      interactionIdle,
+      settledLayoutEpoch,
+      wallDimensionReference,
+      floorplanMode,
+    }),
+    [
+      annotationVisibility,
+      annotationLayoutOverrides,
+      drawingType,
+      interactionIdle,
+      settledLayoutEpoch,
+      wallDimensionReference,
+      floorplanMode,
+    ],
+  )
+  const setAnnotationLayoutOverride = useDrawingView((state) => state.setAnnotationLayoutOverride)
+  const layoutEnabled = active && interactionIdle
+
+  useEffect(() => {
+    if (!layoutEnabled) return
+    let frame: number | null = null
+    const invalidateLayout = () => {
+      if (frame !== null) return
+      frame = window.requestAnimationFrame(() => {
+        frame = null
+        setSettledLayoutEpoch((epoch) => epoch + 1)
+      })
+    }
+    const unsubscribeScene = useScene.subscribe((state, previousState) => {
+      if (
+        state.nodes !== previousState.nodes ||
+        state.installedPlugins !== previousState.installedPlugins
+      ) {
+        invalidateLayout()
+      }
+    })
+    const unsubscribeTransforms = useLiveTransforms.subscribe((state, previousState) => {
+      if (state.transforms !== previousState.transforms) invalidateLayout()
+    })
+    const unsubscribeOverrides = useLiveNodeOverrides.subscribe((state, previousState) => {
+      if (state.overrides !== previousState.overrides) invalidateLayout()
+    })
+    const unsubscribeInteractive = useInteractive.subscribe((state, previousState) => {
+      if (state.elevators !== previousState.elevators) invalidateLayout()
+    })
+
+    return () => {
+      unsubscribeScene()
+      unsubscribeTransforms()
+      unsubscribeOverrides()
+      unsubscribeInteractive()
+      if (frame !== null) window.cancelAnimationFrame(frame)
+    }
+  }, [layoutEnabled])
+
+  useLayoutEffect(() => {
+    // Explicit layout inputs replace the former whole-subtree MutationObserver.
+    if (!active) {
+      appliedLayoutInputsRef.current = null
+      return
+    }
+    if (!interactionIdle) return
+    const registryLayer = markerRef.current?.parentElement
+    if (!registryLayer) return
+    const update = resolveFloorplanAnnotationUpdate({
+      layoutInputsChanged: appliedLayoutInputsRef.current !== layoutInputs,
+      nextRotationDeg: sceneRotationDeg,
+      previousRotationDeg: appliedRotationDegRef.current,
+    })
+    if (update.resolveCollisions) {
+      const svg = markerRef.current?.ownerSVGElement
+      if (!svg) return
+      collisionLabelElementsRef.current = Array.from(
+        svg.querySelectorAll<SVGGElement>('[data-floorplan-annotation-label]'),
+      )
+      registryLabelElementsRef.current = collisionLabelElementsRef.current.filter((label) =>
+        registryLayer.contains(label),
+      )
+      registryOrientationElementsRef.current = Array.from(
+        registryLayer.querySelectorAll<SVGGElement>('[data-floorplan-annotation-angle-radians]'),
+      )
+    }
+    if (update.updateLabelPresentation) {
+      updateSvgFloorplanLabelOrientations(registryOrientationElementsRef.current, sceneRotationDeg)
+      appliedRotationDegRef.current = sceneRotationDeg
+    }
+    if (!update.resolveCollisions) return
+    const svg = markerRef.current?.ownerSVGElement
+    if (!svg) return
+    resolveSvgAnnotationCollisions(svg, {
+      labels: collisionLabelElementsRef.current,
+      layoutOverrides: annotationLayoutOverrides,
+    })
+    appliedLayoutInputsRef.current = layoutInputs
+
+    for (const [index, label] of registryLabelElementsRef.current.entries()) {
+      const id = svgAnnotationLabelId(label, index)
+      label.dataset.floorplanAnnotationId = id
+      label.style.pointerEvents = 'all'
+      label.style.cursor = annotationLayoutOverrides[id]?.pinned ? 'grab' : 'move'
+    }
+  }, [active, annotationLayoutOverrides, interactionIdle, layoutInputs, sceneRotationDeg])
+
+  useEffect(() => {
+    if (!layoutEnabled) return
+    const registryLayer = markerRef.current?.parentElement
+    if (!registryLayer) return
+    let cleanupPointerDrag: (() => void) | null = null
+    let cancelActivePointerDrag: (() => void) | null = null
+
+    const findLabel = (target: EventTarget | null): SVGGElement | null => {
+      if (!(target instanceof Element)) return null
+      const label = target.closest<SVGGElement>('[data-floorplan-annotation-label]')
+      return label && registryLayer.contains(label) ? label : null
+    }
+
+    const labelId = (label: SVGGElement): string => {
+      const labels = registryLabelElementsRef.current
+      return svgAnnotationLabelId(label, Math.max(0, labels.indexOf(label)))
+    }
+
+    const onPointerDown = (event: PointerEvent) => {
+      const label = findLabel(event.target)
+      if (!(label && event.button === 0)) return
+      const matrix = label.getScreenCTM()
+      if (!matrix) return
+      event.preventDefault()
+      event.stopPropagation()
+      cancelActivePointerDrag?.()
+      label.style.cursor = 'grabbing'
+      const id = labelId(label)
+      const start = { x: event.clientX, y: event.clientY }
+      const existing = useDrawingView.getState().annotationLayoutOverrides[id] ?? {
+        ...readFloorplanAnnotationLayoutOffset(label),
+        pinned: true,
+      }
+      const wasPinned = useDrawingView.getState().annotationLayoutOverrides[id]?.pinned === true
+      let latest = existing
+      let moved = false
+
+      const onPointerMove = (moveEvent: PointerEvent) => {
+        if (moveEvent.pointerId !== event.pointerId) return
+        moved = true
+        const local = screenVectorToFloorplanAnnotationLocal(
+          matrix,
+          moveEvent.clientX - start.x,
+          moveEvent.clientY - start.y,
+        )
+        latest = {
+          dx: existing.dx + local.x,
+          dy: existing.dy + local.y,
+          pinned: true,
         }
-        const overrides = useLiveNodeOverrides.getState()
-        for (const id of drag.session.affectedIds) overrides.clear(id)
-        dragRef.current = null
+        const defaultTransform = label.dataset.floorplanAnnotationDefaultTransform ?? ''
+        label.setAttribute(
+          'transform',
+          `${defaultTransform} translate(${latest.dx} ${latest.dy})`.trim(),
+        )
+      }
+
+      const finishPointerDrag = (endEvent: PointerEvent) => {
+        if (endEvent.pointerId !== event.pointerId) return
+        cleanupPointerDrag?.()
+        label.style.cursor = moved || wasPinned ? 'grab' : 'move'
+        if (moved) setAnnotationLayoutOverride(id, latest)
+      }
+
+      const cancelPointerDrag = (cancelEvent: PointerEvent) => {
+        if (cancelEvent.pointerId !== event.pointerId) return
+        cancelActivePointerDrag?.()
+      }
+
+      cancelActivePointerDrag = () => {
+        cleanupPointerDrag?.()
+        label.style.cursor = wasPinned ? 'grab' : 'move'
+        const defaultTransform = label.dataset.floorplanAnnotationDefaultTransform ?? ''
+        label.setAttribute(
+          'transform',
+          `${defaultTransform} translate(${existing.dx} ${existing.dy})`.trim(),
+        )
+      }
+
+      cleanupPointerDrag = () => {
+        window.removeEventListener('pointermove', onPointerMove)
+        window.removeEventListener('pointerup', finishPointerDrag)
+        window.removeEventListener('pointercancel', cancelPointerDrag)
+        cleanupPointerDrag = null
+        cancelActivePointerDrag = null
+      }
+      window.addEventListener('pointermove', onPointerMove)
+      window.addEventListener('pointerup', finishPointerDrag)
+      window.addEventListener('pointercancel', cancelPointerDrag)
+    }
+
+    const onDoubleClick = (event: MouseEvent) => {
+      const label = findLabel(event.target)
+      if (!label) return
+      event.preventDefault()
+      event.stopPropagation()
+      label.style.cursor = 'move'
+      setAnnotationLayoutOverride(labelId(label), null)
+    }
+
+    registryLayer.addEventListener('pointerdown', onPointerDown)
+    registryLayer.addEventListener('dblclick', onDoubleClick)
+    return () => {
+      cancelActivePointerDrag?.()
+      registryLayer.removeEventListener('pointerdown', onPointerDown)
+      registryLayer.removeEventListener('dblclick', onDoubleClick)
+      for (const label of registryLabelElementsRef.current) {
+        label.style.pointerEvents = ''
+        label.style.cursor = ''
+      }
+    }
+  }, [layoutEnabled, setAnnotationLayoutOverride])
+  return <g pointerEvents="none" ref={markerRef} />
+}
+
+function screenVectorToFloorplanAnnotationLocal(matrix: DOMMatrix, dx: number, dy: number) {
+  const determinant = matrix.a * matrix.d - matrix.b * matrix.c
+  if (Math.abs(determinant) < 1e-9) return { x: 0, y: 0 }
+  return {
+    x: (matrix.d * dx - matrix.c * dy) / determinant,
+    y: (-matrix.b * dx + matrix.a * dy) / determinant,
+  }
+}
+
+function readFloorplanAnnotationLayoutOffset(label: SVGGElement) {
+  const dx = Number(label.dataset.floorplanAnnotationLayoutDx ?? 0)
+  const dy = Number(label.dataset.floorplanAnnotationLayoutDy ?? 0)
+  return {
+    dx: Number.isFinite(dx) ? dx : 0,
+    dy: Number.isFinite(dy) ? dy : 0,
+  }
+}
+
+type FloorplanRegistryEntryProps = {
+  activeDragId: string | null
+  annotationVisibility: FloorplanAnnotationVisibility
+  floorplanMode: FloorplanMode
+  ctxOverrides: FloorplanContextOverrides | undefined
+  floorplanVisible: boolean
+  geometryCacheRef: { current: Map<string, CacheEntry> }
+  hatchPatternId: string | undefined
+  hoveredHandleId: string | null
+  interactiveElevators: unknown
+  isMarqueeSelectionActive: boolean
+  levelDataCacheRef: { current: Map<string, LevelDataCacheEntry> }
+  levelNodeIdsByType: ReadonlyMap<string, readonly AnyNodeId[]>
+  moving: boolean
+  node: AnyNode
+  nodeId: AnyNodeId
+  nodes: Record<string, AnyNode>
+  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
+  palette: FloorplanPalette | undefined
+  pass: FloorplanRenderPass
+  sceneRotationDeg: number
+  setMovingNode: ReturnType<typeof useEditor.getState>['setMovingNode']
+  setMovingNodeOrigin: ReturnType<typeof useEditor.getState>['setMovingNodeOrigin']
+  siblingEpoch: number
+  unit: 'metric' | 'imperial'
+  metricNotation: 'meters' | 'millimeters'
+  wallDimensionReference: FloorplanWallDimensionReference
+  visibilityRootId: AnyNodeId | undefined
+}
+
+const FloorplanRegistryEntry = memo(function FloorplanRegistryEntry({
+  activeDragId,
+  annotationVisibility,
+  floorplanMode,
+  ctxOverrides,
+  floorplanVisible,
+  geometryCacheRef,
+  hatchPatternId,
+  hoveredHandleId,
+  interactiveElevators,
+  isMarqueeSelectionActive,
+  levelDataCacheRef,
+  levelNodeIdsByType,
+  moving,
+  node,
+  nodeId,
+  nodes,
+  onClickStop,
+  onEntryPointerDown,
+  onGroupMovePointerDown,
+  onHandleHoverChange,
+  onHandleDoubleClick,
+  onHandlePointerDown,
+  palette,
+  pass,
+  sceneRotationDeg,
+  setMovingNode,
+  setMovingNodeOrigin,
+  siblingEpoch,
+  unit,
+  metricNotation,
+  wallDimensionReference,
+  visibilityRootId,
+}: FloorplanRegistryEntryProps): React.ReactElement | null {
+  const selected = useViewer((state) => state.selection.selectedIds.includes(nodeId))
+  const highlighted = useViewer((state) => state.previewSelectedIds.includes(nodeId))
+  const suppressHandles = useViewer(
+    (state) =>
+      state.selection.selectedIds.length > 1 && state.selection.selectedIds.includes(nodeId),
+  )
+  const selectedLevelId = useViewer((state) => state.selection.levelId)
+  const selectionProxyId = resolveSelectionProxyId(
+    node,
+    nodes as Record<string, AnyNode | undefined>,
+  )
+  const hovered = useViewer((state) => state.hoveredId === selectionProxyId)
+  const setHoveredId = useViewer((state) => state.setHoveredId)
+  const referencedAnnotationRole = useViewer((state) =>
+    floorplanEntryReferencedAnnotationRole(node, new Set(state.selection.selectedIds)),
+  )
+  const activeRotateNodeId = useDirectManipulationFeedback((state) =>
+    state.activeRotateNodeId === nodeId ? nodeId : null,
+  )
+  const groupMoveCursor =
+    suppressHandles && classifyParticipant(node, selectedLevelId, nodes) !== 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 presentationVisibility = resolveFloorplanAnnotationVisibility(
+    floorplanMode,
+    annotationVisibility,
+    {
+      referencedAnnotationRole,
+      selected,
+      target: 'editor',
+    },
+  )
+
+  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 currentNode = useScene.getState().nodes[nodeId]
+    setHoveredId(
+      currentNode
+        ? resolveSelectionProxyId(
+            currentNode,
+            useScene.getState().nodes as Record<string, AnyNode | undefined>,
+          )
+        : nodeId,
+    )
+  }, [nodeId, setHoveredId])
+
+  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) setHoveredId(null)
+  }, [nodeId, setHoveredId])
+
+  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({
+    automaticDimensions: presentationVisibility.automaticDimensions,
+    ctxOverrides,
+    geometryCache: geometryCacheRef.current,
+    highlighted,
+    hovered,
+    interactiveElevators,
+    levelDataCache: levelDataCacheRef.current,
+    levelNodeIdsByType,
+    live,
+    liveOverride,
+    liveOverrides,
+    moving,
+    node,
+    nodeId,
+    nodes,
+    palette,
+    selected,
+    siblingEpoch,
+    unit,
+    metricNotation,
+    wallDimensionReference,
+    visibilityRootId,
+  })
+  const rawGeometry = cacheEntry ? (pass === 'base' ? cacheEntry.base : cacheEntry.overlay) : null
+  const visibleGeometry = rawGeometry
+    ? filterFloorplanAnnotationGeometry(rawGeometry, presentationVisibility)
+    : 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 =
+    visibleGeometry && suppressHandles && pass === 'overlay'
+      ? stripHandleChrome(visibleGeometry)
+      : visibleGeometry
+  if (!geometry) return null
+
+  const entryClick = isMarqueeSelectionActive ? undefined : onClickStop
+  const entryPointerDown = 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}
+      />
+    </g>
+  )
+}, shallowPropsAreEqual)
+
+type BuildFloorplanEntryGeometryArgs = {
+  automaticDimensions: boolean
+  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'
+  metricNotation: 'meters' | 'millimeters'
+  wallDimensionReference: FloorplanWallDimensionReference
+  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 floorplanEntryReferencedAnnotationRole(
+  node: AnyNode,
+  selectedIds: ReadonlySet<string>,
+): FloorplanAnnotationRole | undefined {
+  if (selectedIds.size === 0) return undefined
+  const definition = nodeRegistry.get(node.type)
+  const role = getFloorplanNodeExtension(definition)?.referencedSelectionAnnotationRole
+  if (!role) return undefined
+  const dependencyIds = definition?.floorplanDependencies?.(node) ?? []
+  return dependencyIds.some((id) => selectedIds.has(id)) ? role : undefined
+}
+
+function buildFloorplanEntryGeometry({
+  automaticDimensions,
+  ctxOverrides,
+  geometryCache,
+  highlighted,
+  hovered,
+  interactiveElevators,
+  levelDataCache,
+  levelNodeIdsByType,
+  live,
+  liveOverride,
+  liveOverrides,
+  moving,
+  node,
+  nodeId,
+  nodes,
+  palette,
+  selected,
+  siblingEpoch,
+  unit,
+  metricNotation,
+  wallDimensionReference,
+  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 = {
+    automaticDimensions,
+    node,
+    live,
+    unit,
+    metricNotation,
+    wallDimensionReference,
+    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 = {
+    automaticDimensions,
+    selected,
+    unit,
+    metricNotation,
+    wallDimensionReference,
+    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,
+        extensions: createFloorplanContextExtensions({
+          automaticDimensions,
+          metricNotation,
+          purpose: 'edit',
+          wallDimensionReference,
+        }),
+        viewState: palette
+          ? {
+              selected,
+              unit,
+              highlighted,
+              hovered,
+              moving,
+              palette,
+            }
+          : undefined,
       }
-      // Clear any alignment guide a session left behind on mid-drag unmount.
-      useAlignmentGuides.getState().clear()
-    }
-  }, [])
-
-  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)
+    : {
+        ...buildContext(effectiveNode, contextNodes, viewState, levelData),
+        resolve: resolveContextNode,
       }
-      // 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>
+  const modelGeometry = (builder as (n: AnyNode, c: GeometryContext) => FloorplanGeometry | null)(
+    effectiveNode,
+    ctx,
   )
+  const contextualGeometry = selected
+    ? (getFloorplanNodeExtension(def)?.contextualDimensions?.(effectiveNode, ctx) ?? null)
+    : null
+  const taggedContextualGeometry = withFloorplanGeometryMetadata(contextualGeometry, {
+    annotationRole: 'contextual-dimension',
+  })
+  const geometry =
+    modelGeometry && taggedContextualGeometry
+      ? { kind: 'group' as const, children: [modelGeometry, taggedContextualGeometry] }
+      : (modelGeometry ?? taggedContextualGeometry)
+  const { base, overlay } = geometry
+    ? splitFloorplanOverlay(geometry)
+    : { base: null, overlay: null }
+  const entry: CacheEntry = { deps, base, overlay, node: effectiveNode }
+  geometryCache.set(nodeId, entry)
+  return entry
+}
 
-  return (
-    // The outer wrapper stops `click` events that escape an entry's
-    // `onClick={handleClickStop}`. The base+overlay split means
-    // pointer-down can land on the base `<g>` and pointer-up on the
-    // overlay `<g>` (selection mounts the overlay on top mid-gesture).
-    // When the down/up targets differ, the browser dispatches `click`
-    // to the lowest common ancestor — which sits ABOVE the entry-level
-    // handler. Without this guard the click reaches the SVG's
-    // `handleBackgroundClick`, which calls
-    // `resolveFloorplanBackgroundSelection` → `clear-elements` (because
-    // registry-driven items aren't in the legacy hit-test set) →
-    // clearing the selection that pointer-down just set, so items
-    // appear to "deselect themselves a fraction of a second after
-    // clicking." Scoped to `onClick` so hover / drag / pointer events
-    // still propagate normally inside the registry tree.
-    <g
-      className="floorplan-registry-layer"
-      onClick={isOpeningPlacementActive ? undefined : handleClickStop}
-      opacity={isAmbient ? 0.3 : undefined}
-      style={isAmbient ? { pointerEvents: 'none' } : 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))}
-      </g>
-      {/* Overlay pass — interactive handles (vertex / midpoint / edge /
-          move) and labels (text / dimensions). Painted after every base
-          entry so polygon-editor chrome on a selected slab stays above
-          neighbouring walls, and a zone name stays readable above the
-          slab + wall geometry sitting on top of the zone. Each overlay
-          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,
-        )}
-      </g>
-      {/* Transient live-rotation readout — drawn last so the wedge + degree
-          chip sit above all handle chrome while a rotate-arrow is dragged. */}
-      {rotationOverlay && palette ? (
-        <RotationAngleOverlay
-          overlay={rotationOverlay}
-          palette={palette}
-          sceneRotationDeg={renderCtx?.sceneRotationDeg ?? 0}
-          unitsPerPixel={unitsPerPixel}
-        />
-      ) : null}
-    </g>
-  )
-})
+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 ──────────────────────────────────────
 
-function InteractiveGeometry({
-  geometry,
-  unitsPerPixel,
-  palette,
-  hatchPatternId,
-  hoveredHandleId,
-  activeDragId,
-  isMarqueeSelectionActive,
-  nodeId,
-  sceneRotationDeg,
-  onHandleHoverChange,
-  onHandlePointerDown,
-  onMoveHandlePointerDown,
-}: {
+type InteractiveGeometryProps = {
   geometry: FloorplanGeometry
-  unitsPerPixel: number
+  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 +2320,30 @@ function InteractiveGeometry({
     rotationPivot?: FloorplanPoint,
   ) => void
   onMoveHandlePointerDown: (event: ReactPointerEvent<SVGGElement>) => void
-}): React.ReactElement {
+}
+
+export const InteractiveGeometry = memo(function InteractiveGeometry({
+  geometry,
+  unitsPerPixel: unitsPerPixelOverride,
+  palette,
+  hatchPatternId,
+  hoveredHandleId,
+  activeDragId,
+  activeRotateNodeId,
+  isMarqueeSelectionActive,
+  nodeId,
+  sceneRotationDeg,
+  onHandleDoubleClick,
+  onHandleHoverChange,
+  onHandlePointerDown,
+  onMoveHandlePointerDown,
+}: InteractiveGeometryProps): React.ReactElement {
+  const liveUnitsPerPixel = useFloorplanStaticUnitsPerPixel()
+  const unitsPerPixel = unitsPerPixelOverride ?? liveUnitsPerPixel
+  // Keep handles pixel-sized through normal navigation, then let them shrink
+  // with the plan once zoom compensation would make them dominate the geometry.
+  const handleUnitsPerPixel = resolveFloorplanHandleUnitsPerPixel(unitsPerPixel)
+
   return renderInteractive(geometry, 0)
 
   function renderInteractive(g: FloorplanGeometry, keyHint: number): React.ReactElement {
@@ -874,7 +2351,14 @@ function InteractiveGeometry({
       case 'group': {
         const transform = formatGroupTransform(g.transform)
         return (
-          <g key={keyHint} transform={transform}>
+          <g
+            data-floorplan-annotation-obstacle={
+              floorplanAnnotationObstacleMode(g) ??
+              (isFloorplanAnnotationObstacleGeometry(g) ? '' : undefined)
+            }
+            key={keyHint}
+            transform={transform}
+          >
             {g.children.map((child, i) => renderInteractive(child, i))}
           </g>
         )
@@ -911,6 +2395,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
@@ -934,10 +2419,10 @@ function InteractiveGeometry({
             : palette.endpointHandleFill
         const outerRadius =
           (isActive ? ENDPOINT_HANDLE_ACTIVE_RADIUS_PX : ENDPOINT_HANDLE_SELECTED_RADIUS_PX) *
-          unitsPerPixel
+          handleUnitsPerPixel
         const dotRadius =
           (isActive ? ENDPOINT_HANDLE_ACTIVE_DOT_RADIUS_PX : ENDPOINT_HANDLE_DOT_RADIUS_PX) *
-          unitsPerPixel
+          handleUnitsPerPixel
         return (
           <g
             key={keyHint}
@@ -953,7 +2438,7 @@ function InteractiveGeometry({
               r={outerRadius}
               stroke={hoverStroke}
               strokeOpacity={isActive ? 0.24 : 0.16}
-              strokeWidth={ENDPOINT_HOVER_GLOW_STROKE_WIDTH_PX * unitsPerPixel}
+              strokeWidth={ENDPOINT_HOVER_GLOW_STROKE_WIDTH_PX * handleUnitsPerPixel}
               style={{ opacity: isHovered || isActive ? 1 : 0, transition: HOVER_TRANSITION }}
               vectorEffect="non-scaling-stroke"
             />
@@ -965,7 +2450,7 @@ function InteractiveGeometry({
               r={outerRadius}
               stroke={hoverStroke}
               strokeOpacity={isActive ? 0.72 : 0.52}
-              strokeWidth={ENDPOINT_HOVER_RING_STROKE_WIDTH_PX * unitsPerPixel}
+              strokeWidth={ENDPOINT_HOVER_RING_STROKE_WIDTH_PX * handleUnitsPerPixel}
               style={{ opacity: isHovered || isActive ? 1 : 0, transition: HOVER_TRANSITION }}
               vectorEffect="non-scaling-stroke"
             />
@@ -992,6 +2477,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 +2589,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
@@ -1317,8 +2811,8 @@ function InteractiveGeometry({
         // Slightly smaller than endpoint dots; hover-expanded.
         const baseRadiusPx = 6
         const hoverRadiusPx = 8
-        const radius = (isHovered || isActive ? hoverRadiusPx : baseRadiusPx) * unitsPerPixel
-        const plusHalf = 3 * unitsPerPixel
+        const radius = (isHovered || isActive ? hoverRadiusPx : baseRadiusPx) * handleUnitsPerPixel
+        const plusHalf = 3 * handleUnitsPerPixel
         return (
           <g
             key={keyHint}
@@ -1331,10 +2825,10 @@ function InteractiveGeometry({
               cy={g.point[1]}
               fill="none"
               pointerEvents="none"
-              r={radius + 2 * unitsPerPixel}
+              r={radius + 2 * handleUnitsPerPixel}
               stroke={hoverStroke}
               strokeOpacity={0.16}
-              strokeWidth={ENDPOINT_HOVER_RING_STROKE_WIDTH_PX * unitsPerPixel}
+              strokeWidth={ENDPOINT_HOVER_RING_STROKE_WIDTH_PX * handleUnitsPerPixel}
               style={{ opacity: isHovered || isActive ? 1 : 0, transition: HOVER_TRANSITION }}
               vectorEffect="non-scaling-stroke"
             />
@@ -1402,35 +2896,106 @@ 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
+        const labelTransform = `translate(${g.cx} ${g.cy}) rotate(${degrees}) translate(0 ${-(g.offsetPx ?? 0) * labelUnitsPerPixel})`
+        return (
+          <g
+            data-floorplan-annotation-angle-radians={g.angle}
+            data-floorplan-annotation-default-transform={labelTransform}
+            data-floorplan-annotation-label=""
+            data-floorplan-annotation-priority="20"
+            data-floorplan-annotation-screen-upright={g.screenUpright ? 'true' : undefined}
+            data-floorplan-annotation-transform-after-rotation={`translate(0 ${
+              -(g.offsetPx ?? 0) * labelUnitsPerPixel
+            })`}
+            data-floorplan-annotation-transform-before-rotation={`translate(${g.cx} ${g.cy})`}
+            key={keyHint}
+            pointerEvents="none"
+            transform={labelTransform}
+          >
+            {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,162 +3003,28 @@ 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>
         )
       }
       case 'dimension': {
         if (!palette) return <></>
-        const stroke = g.stroke ?? palette.measurementStroke
-        // Offset endpoints along the outward normal — this is where the
-        // dimension line sits, parallel to the edge.
-        const ox = g.offsetNormal[0] * g.offsetDistance
-        const oy = g.offsetNormal[1] * g.offsetDistance
-        const dStart: [number, number] = [g.start[0] + ox, g.start[1] + oy]
-        const dEnd: [number, number] = [g.end[0] + ox, g.end[1] + oy]
-
-        // Extension line endpoints — extend past the dimension line by
-        // `extensionOvershoot` so the tip clears the dimension stroke.
-        const eOvershoot = g.extensionOvershoot
-        const eOx = g.offsetNormal[0] * (g.offsetDistance + eOvershoot)
-        const eOy = g.offsetNormal[1] * (g.offsetDistance + eOvershoot)
-        const eStartTip: [number, number] = [g.start[0] + eOx, g.start[1] + eOy]
-        const eEndTip: [number, number] = [g.end[0] + eOx, g.end[1] + eOy]
-
-        const dx = dEnd[0] - dStart[0]
-        const dy = dEnd[1] - dStart[1]
-        const length = Math.hypot(dx, dy)
-        if (length < 1e-6) return <></>
-        const dirX = dx / length
-        const dirY = dy / length
-
-        // Plan-unit constants matching the legacy `floorplan-
-        // measurements-layer.tsx`. `strokeWidth` is intentionally a
-        // raw value (not multiplied by `unitsPerPixel`) because every
-        // stroke here uses `vectorEffect: non-scaling-stroke` — the
-        // browser interprets it as screen-pixel-stable. Multiplying
-        // by `unitsPerPixel` would shrink the strokes by ~100× and
-        // make them invisible. Tick length, dash pattern, font size,
-        // and the label gap stay in plan units (they're geometry,
-        // not stroke width).
-        const tickHalf = 0.09 // FLOORPLAN_MEASUREMENT_END_TICK / 2 = 0.18 / 2
-        const perpX = -dirY * tickHalf
-        const perpY = dirX * tickHalf
-
-        const fontSize = 0.15 // FLOORPLAN_MEASUREMENT_LABEL_FONT_SIZE
-        const labelGap = 0.5 // plan units — gap in the dimension line for the label
-        const gapHalf = Math.min(labelGap / 2, length / 2 - 0.04)
-
-        const midX = (dStart[0] + dEnd[0]) / 2
-        const midY = (dStart[1] + dEnd[1]) / 2
-        const gapStart: [number, number] = [midX - dirX * gapHalf, midY - dirY * gapHalf]
-        const gapEnd: [number, number] = [midX + dirX * gapHalf, midY + dirY * gapHalf]
-
-        // Keep the label parallel to the dimension line, but decide the
-        // 180° flip from the on-SCREEN angle, not the local one. The parent
-        // `<g>` is rotated by `sceneRotationDeg` (default 90° in the floor
-        // plan), so a label kept upright in local coords still renders
-        // upside down for half of the wall orientations. Same fix as the
-        // `dimension-label` case above.
-        let labelDeg = (Math.atan2(dy, dx) * 180) / Math.PI
-        let screenDeg = labelDeg + sceneRotationDeg
-        screenDeg = ((((screenDeg + 180) % 360) + 360) % 360) - 180
-        if (screenDeg > 90) labelDeg -= 180
-        else if (screenDeg <= -90) labelDeg += 180
-
         return (
-          <g key={keyHint} pointerEvents="none">
-            {/* Extension lines (dashed). */}
-            <line
-              stroke={stroke}
-              strokeDasharray="0.08 0.12"
-              strokeLinecap="round"
-              strokeOpacity={0.95}
-              strokeWidth={1.35}
-              vectorEffect="non-scaling-stroke"
-              x1={g.start[0]}
-              x2={eStartTip[0]}
-              y1={g.start[1]}
-              y2={eStartTip[1]}
-            />
-            <line
-              stroke={stroke}
-              strokeDasharray="0.08 0.12"
-              strokeLinecap="round"
-              strokeOpacity={0.95}
-              strokeWidth={1.35}
-              vectorEffect="non-scaling-stroke"
-              x1={g.end[0]}
-              x2={eEndTip[0]}
-              y1={g.end[1]}
-              y2={eEndTip[1]}
-            />
-            {/* Dimension line: two halves with the label in between. */}
-            <line
-              stroke={stroke}
-              strokeLinecap="round"
-              strokeWidth={1.35}
-              vectorEffect="non-scaling-stroke"
-              x1={dStart[0]}
-              x2={gapStart[0]}
-              y1={dStart[1]}
-              y2={gapStart[1]}
-            />
-            <line
-              stroke={stroke}
-              strokeLinecap="round"
-              strokeWidth={1.35}
-              vectorEffect="non-scaling-stroke"
-              x1={gapEnd[0]}
-              x2={dEnd[0]}
-              y1={gapEnd[1]}
-              y2={dEnd[1]}
-            />
-            {/* End ticks. */}
-            <line
-              stroke={stroke}
-              strokeLinecap="round"
-              strokeWidth={1.35}
-              vectorEffect="non-scaling-stroke"
-              x1={dStart[0] - perpX}
-              x2={dStart[0] + perpX}
-              y1={dStart[1] - perpY}
-              y2={dStart[1] + perpY}
-            />
-            <line
-              stroke={stroke}
-              strokeLinecap="round"
-              strokeWidth={1.35}
-              vectorEffect="non-scaling-stroke"
-              x1={dEnd[0] - perpX}
-              x2={dEnd[0] + perpX}
-              y1={dEnd[1] - perpY}
-              y2={dEnd[1] + perpY}
-            />
-            {/* Rotated label centered in the gap. */}
-            <text
-              dominantBaseline="central"
-              fill={stroke}
-              fontFamily="ui-monospace, SFMono-Regular, Menlo, monospace"
-              fontSize={fontSize}
-              fontWeight={600}
-              textAnchor="middle"
-              transform={`rotate(${labelDeg} ${midX} ${midY})`}
-              x={midX}
-              y={midY}
-            >
-              {g.text}
-            </text>
-          </g>
+          <FloorplanDimensionRenderer
+            geometry={g}
+            key={keyHint}
+            sceneRotationDeg={sceneRotationDeg}
+            stroke={g.stroke ?? palette.measurementStroke}
+          />
         )
       }
       case 'text': {
@@ -1601,8 +3032,18 @@ function InteractiveGeometry({
         // Counter-rotate by the scene rotation so the label reads
         // horizontally on screen even when the floor-plan view is
         // rotated (default `sceneRotationDeg` is 90°).
+        const beforeRotation = `translate(${g.x} ${g.y})`
+        const transform = `${beforeRotation} rotate(${-sceneRotationDeg})`
         return (
-          <g key={keyHint} transform={`translate(${g.x} ${g.y}) rotate(${-sceneRotationDeg})`}>
+          <g
+            data-floorplan-annotation-obstacle={floorplanAnnotationObstacleMode(g)}
+            data-floorplan-annotation-angle-radians={0}
+            data-floorplan-annotation-default-transform={transform}
+            data-floorplan-annotation-screen-upright="true"
+            data-floorplan-annotation-transform-before-rotation={beforeRotation}
+            key={keyHint}
+            transform={transform}
+          >
             <text
               dominantBaseline={g.dominantBaseline ?? 'middle'}
               fill={g.fill ?? '#171717'}
@@ -1630,14 +3071,30 @@ function InteractiveGeometry({
             geometry={g}
             key={keyHint}
             pointerEventsOverride={isMarqueeSelectionActive ? 'none' : undefined}
+            sceneRotationDeg={sceneRotationDeg}
           />
         )
     }
   }
-}
+}, 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 +3118,48 @@ 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: {
+    automaticDimensions?: boolean
     selected: boolean
+    unit: 'metric' | 'imperial'
+    metricNotation?: 'meters' | 'millimeters'
+    purpose?: 'edit' | 'document'
+    wallDimensionReference?: FloorplanWallDimensionReference
     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 +3192,17 @@ function buildContext(
     children,
     siblings,
     parent,
+    levelData,
+    extensions: createFloorplanContextExtensions({
+      automaticDimensions: viewState.automaticDimensions,
+      metricNotation: viewState.metricNotation ?? 'meters',
+      purpose: viewState.purpose ?? 'edit',
+      wallDimensionReference: viewState.wallDimensionReference,
+    }),
     viewState: viewState.palette
       ? {
           selected: viewState.selected,
+          unit: viewState.unit,
           highlighted: viewState.highlighted,
           hovered: viewState.hovered,
           moving: viewState.moving,
@@ -1715,6 +3212,29 @@ function buildContext(
   }
 }
 
+export function collectFloorplanLinkedLevelNodes(
+  nodes: Record<string, AnyNode>,
+  levelId: AnyNodeId,
+  excludedIds: ReadonlySet<AnyNodeId> = new Set(),
+): Array<{ id: AnyNodeId; node: AnyNode; children: AnyNode[] }> {
+  const linked: Array<{ id: AnyNodeId; node: AnyNode; children: AnyNode[] }> = []
+  for (const [rawId, node] of Object.entries(nodes)) {
+    if (!node) continue
+    const definition = nodeRegistry.get(node.type)
+    const linkedLevelIds = getFloorplanNodeExtension(definition)?.linkedLevelIds
+    if (!definition?.floorplan || !linkedLevelIds) continue
+    const id = rawId as AnyNodeId
+    if (excludedIds.has(id)) continue
+    if (!linkedLevelIds(node).includes(levelId)) continue
+    const childIds = (node as { children?: AnyNodeId[] }).children
+    const children = Array.isArray(childIds)
+      ? childIds.map((childId) => nodes[childId]).filter((child): child is AnyNode => !!child)
+      : []
+    linked.push({ id, node, children })
+  }
+  return linked
+}
+
 /**
  * Stable id for a handle on a node, derived from the node id + opaque
  * payload. Used to track hover / active visual state when multiple
@@ -1735,6 +3255,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
@@ -1753,7 +3281,9 @@ const OVERLAY_KINDS = new Set<FloorplanGeometry['kind']>([
   'move-arrow',
   'rotate-arrow',
   'dimension',
+  'dimension-string',
   'dimension-label',
+  'equal-spacing-badge',
 ])
 
 /**
@@ -1766,10 +3296,16 @@ 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
 } {
+  if (readFloorplanGeometryMetadata(g).renderPass === 'overlay') {
+    return { base: null, overlay: g }
+  }
+  if (isFloorplanAnnotationObstacleGeometry(g)) {
+    return { base: null, overlay: g }
+  }
   if (OVERLAY_KINDS.has(g.kind)) {
     return { base: null, overlay: g }
   }
@@ -1782,18 +3318,185 @@ function splitFloorplanOverlay(g: FloorplanGeometry): {
       if (split.overlay) overlayChildren.push(split.overlay)
     }
     const base: FloorplanGeometry | null =
-      baseChildren.length > 0
-        ? { kind: 'group', children: baseChildren, transform: g.transform }
-        : null
+      baseChildren.length > 0 ? { ...g, children: baseChildren, transform: g.transform } : null
     const overlay: FloorplanGeometry | null =
       overlayChildren.length > 0
-        ? { kind: 'group', children: overlayChildren, transform: g.transform }
+        ? { ...g, children: overlayChildren, transform: g.transform }
         : null
     return { base, overlay }
   }
   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> = [
+    'automaticDimensions',
+    'node',
+    'live',
+    'unit',
+    'metricNotation',
+    'wallDimensionReference',
+    '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 +3512,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,17 +3558,22 @@ 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,
+  unitsPerPixel: unitsPerPixelOverride,
   sceneRotationDeg,
 }: {
   overlay: RotationOverlayState
-  palette: FloorplanPalette
-  unitsPerPixel: number
+  palette: Pick<
+    FloorplanPalette,
+    'measurementLabelBackground' | 'measurementLabelText' | 'measurementStroke'
+  >
+  unitsPerPixel?: number
   sceneRotationDeg: number
 }): React.ReactElement {
+  const liveUnitsPerPixel = useFloorplanStaticUnitsPerPixel()
+  const unitsPerPixel = unitsPerPixelOverride ?? liveUnitsPerPixel
   const { pivot, startAngle, endAngle, radius, sweep } = overlay
   const span = endAngle - startAngle
   const count = Math.max(8, Math.ceil((Math.abs(span) / Math.PI) * ROTATION_WEDGE_SEGMENTS))
@@ -1944,20 +3652,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)
 }