@pascal-app/editor 0.8.0 → 0.9.2

package/src/hooks/use-keyboard.ts

@@ -1,11 +1,96 @@
-import { type AnyNodeId, emitter, useScene } from '@pascal-app/core'
+import {
+  type AnyNode,
+  type AnyNodeId,
+  emitter,
+  nodeRegistry,
+  pauseSpaceDetection,
+  resumeSpaceDetection,
+  useScene,
+} from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { useEffect } from 'react'
-import { closeDoorOpenState, toggleDoorOpenState } from '../lib/door-interaction'
+import { Vector3 } from 'three'
+import {
+  classifyParticipant,
+  collectParticipants,
+  computeGroupBox,
+  expandToComponent,
+  levelFrame,
+  rotateGroupPatches,
+} from '../components/editor/group-transform-shared'
+import { steppedRotation } from '../components/tools/item/placement-math'
+import { resolveDirectManipulationNode } from '../lib/direct-manipulation'
+import { toggleDoorOpenState } from '../lib/door-interaction'
+import { guideEmitter } from '../lib/guide-events'
 import { runRedo, runUndo } from '../lib/history'
-import { sfxEmitter } from '../lib/sfx-bus'
-import { closeWindowOpenState, toggleWindowOpenState } from '../lib/window-interaction'
-import useEditor from '../store/use-editor'
+import { isActive } from '../lib/interaction/scope'
+import {
+  copySelectedNodesToEditorClipboard,
+  pasteEditorClipboardToLevel,
+} from '../lib/scene-clipboard'
+import { emitDeleteSFX, sfxEmitter } from '../lib/sfx-bus'
+import { toggleWindowOpenState } from '../lib/window-interaction'
+import useEditor, { getActiveContinuationContext, getActiveSnapContext } from '../store/use-editor'
+import useInteractionScope, { getMovingNode } from '../store/use-interaction-scope'
+
+// References (guide/scan) are selected via `useEditor.selectedReferenceId`, not
+// the viewer selection, so selection-based key arms (R/T rotate) need this
+// separate lookup. Locked guides don't rotate, matching direct manipulation.
+function getRotatableSelectedReference() {
+  const refId = useEditor.getState().selectedReferenceId
+  if (!refId) return null
+  const node = useScene.getState().nodes[refId as AnyNodeId]
+  if (!node || (node.type !== 'guide' && node.type !== 'scan')) return null
+  if (useEditor.getState().guideUi[refId]?.locked === true) return null
+  return node
+}
+
+// Group rotate: R/T on a multi-selection spins the whole selection rigidly
+// ±45° around its bbox center — the keyboard sibling of the 3D group-rotate
+// gizmo, sharing its participant snapshot + rigid-rotation math (welded
+// wall/fence junctions, connected-component expansion). One batched
+// `updateNodes` call = one undo step. Returns false when the selection holds
+// no transformable participants so the caller can fall through to the
+// single-selection arms.
+function rotateGroupSelection(direction: 1 | -1): boolean {
+  const { selectedIds, levelId } = useViewer.getState().selection
+  if (selectedIds.length <= 1) return false
+  const nodes = useScene.getState().nodes
+  const participantIds = selectedIds.filter(
+    (id) => classifyParticipant(nodes[id as AnyNodeId], levelId, nodes) !== null,
+  )
+  if (participantIds.length === 0) return false
+  const fullIds = expandToComponent(participantIds, nodes, levelId)
+  const { starts, links } = collectParticipants(fullIds, nodes, levelId)
+  if (starts.length === 0) return false
+
+  // Same pivot as the 3D gizmo: the selection's world bbox center, converted
+  // into the level frame before orbiting placements (a rotated building would
+  // otherwise displace the centre).
+  const box = computeGroupBox(fullIds)
+  if (!box) return false
+  const worldCenter = new Vector3(
+    (box.min.x + box.max.x) / 2,
+    box.min.y,
+    (box.min.z + box.max.z) / 2,
+  )
+  const localCenter = worldCenter.applyMatrix4(levelFrame(levelId).inverse)
+
+  // R (+45° yaw) orbits by -45° in the atan2 x→z sense: yaw = rotation - delta
+  // (see rotateGroupPatches), so keyboard direction matches the single-node
+  // steppedRotation sense.
+  const delta = -direction * (Math.PI / 4)
+  const patches = rotateGroupPatches(starts, links, { x: localCenter.x, z: localCenter.z }, delta)
+  // Space detection stays out: a rigid rotation of existing walls must not
+  // re-create the room's auto floors/ceilings at the new bearing.
+  pauseSpaceDetection()
+  useScene
+    .getState()
+    .updateNodes(patches.map(([id, data]) => ({ id, data: data as Partial<AnyNode> })))
+  resumeSpaceDetection()
+  sfxEmitter.emit('sfx:item-rotate')
+  return true
+}
 
 // Tools call this in their onCancel handler when they have an active mid-action to cancel,
 // so that the global Escape handler knows not to also switch to select mode.
@@ -14,6 +99,64 @@ export const markToolCancelConsumed = () => {
   _toolCancelConsumed = true
 }
 
+// Escape's fall-through when no tool consumed the cancel: drop back to the
+// select tool (keeping building/level context) and close panels. Tools like
+// preset/item placement rely on this — they pass no coordinator onCancel, and
+// it is the mode switch unmounting them that destroys the draft.
+const exitToSelectAfterUnconsumedCancel = () => {
+  const currentPhase = useEditor.getState().phase
+  const currentStructureLayer = useEditor.getState().structureLayer
+
+  useInteractionScope.getState().endIf((sc) => sc.kind === 'reshaping' && sc.reshape === 'hole')
+
+  // From zone mode, return to structure select
+  if (currentPhase === 'structure' && currentStructureLayer === 'zones') {
+    useEditor.getState().setStructureLayer('elements')
+    useEditor.getState().setMode('select')
+  } else {
+    // Return to the default select tool while keeping the active building/level context.
+    useEditor.getState().setMode('select')
+  }
+
+  useEditor.getState().setFloorplanSelectionTool('click')
+
+  // Clear selections to close UI panels, but KEEP the active building and level context.
+  useViewer.getState().setSelection({ selectedIds: [], zoneId: null })
+  useEditor.getState().setSelectedReferenceId(null)
+}
+
+// ⌘Z pressed mid-interaction (moving a node, drawing a wall, mid-placement…)
+// reads as "abort this action", not history undo — behave exactly like Escape
+// and report whether anything was in flight so the undo/redo arms know to
+// skip the history jump. Pointer drags that only listen for their own
+// capture-phase keydown never reach here — they stopPropagation first (see
+// isHistoryShortcut call sites).
+const cancelInteractionForHistoryShortcut = () => {
+  if (useEditor.getState().referenceScaleActiveGuideId) {
+    guideEmitter.emit('guide:cancel-reference-scale')
+    return true
+  }
+  _toolCancelConsumed = false
+  emitter.emit('tool:cancel')
+  if (_toolCancelConsumed) return true
+  if (
+    isActive(useInteractionScope.getState().scope) ||
+    useViewer.getState().inputDragging ||
+    // Paused history means a gesture session is live (draft placement, adopted
+    // move, …) even when no scope/drag flag is set — the preset/item draft
+    // cycle keeps temporal paused for the whole session, and a history jump
+    // against a paused store would land on a stale baseline anyway.
+    !useScene.temporal.getState().isTracking
+  ) {
+    // A gesture is live but nothing consumed the cancel: finish it the way
+    // Escape does — the mode switch is what actually cancels tools that hook
+    // their teardown to unmount (preset/item placement).
+    exitToSelectAfterUnconsumedCancel()
+    return true
+  }
+  return false
+}
+
 export const useKeyboard = ({
   isVersionPreviewMode = false,
   disabled = false,
@@ -26,39 +169,130 @@ export const useKeyboard = ({
       return
     }
 
+    // True while a door/window is being placed: either a fresh clone is moving
+    // (preset / duplicate path) or a door/window build tool is armed. The
+    // placement tool owns R/T then (flip the draft before commit), so the
+    // global selection-based R/T handler must stand down to avoid double-firing.
+    const isPlacingOpening = () => {
+      const ed = useEditor.getState()
+      const moving = getMovingNode()
+      if (moving?.type === 'door' || moving?.type === 'window') return true
+      return ed.mode === 'build' && (ed.tool === 'door' || ed.tool === 'window')
+    }
+
+    // Shift cycles the snapping mode (and a clean-tap Ctrl the grid step)
+    // whenever there's an active snapping context — i.e. exactly when the HUD
+    // shows a snapping chip. That single source covers wall/fence/item drafting,
+    // every node move (including wall-hosted items + door/window openings, which
+    // now declare `snapProfile`), and endpoint/polygon reshaping, so the keys
+    // never silently stop working. Force-place lives on Alt where a tool supports it.
+    const isSnappingCycleContext = () => getActiveSnapContext() != null
+    // A "clean tap" of Ctrl/Meta (pressed and released with NO other key in
+    // between) cycles the grid step — same context as the Shift snapping-mode
+    // cycle. `ctrlTapClean` starts true the moment Ctrl/Meta goes down alone
+    // and is cleared the instant any other key fires, so chords like Ctrl+Z /
+    // Ctrl+C never cycle.
+    let ctrlTapClean = false
+
     const handleKeyDown = (e: KeyboardEvent) => {
+      if (e.key === 'Control' || e.key === 'Meta') {
+        // Only a fresh, modifier-free press starts a clean-tap candidate;
+        // ignore key-repeat and presses already part of a combo.
+        ctrlTapClean = !e.repeat && !e.shiftKey && !e.altKey
+      } else {
+        // Any non-modifier key (or a modifier combined with Ctrl/Meta) breaks
+        // the clean tap.
+        ctrlTapClean = false
+      }
+
       // Don't handle shortcuts if user is typing in an input
       if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement) {
         return
       }
 
+      if (e.key === 'Shift' && !e.repeat && useEditor.getState().mode === 'material-paint') {
+        // In paint mode Shift cycles the application scope (this surface →
+        // whole item / all matching / room) — the paint-mode analogue of the
+        // snapping-mode cycle below. The scope chip mirrors this key.
+        e.preventDefault()
+        useEditor.getState().cyclePaintScope()
+        sfxEmitter.emit('sfx:grid-snap')
+        return
+      }
+
+      if (e.key === 'Shift' && !e.repeat && isSnappingCycleContext()) {
+        // Cycle the global snapping mode (grid → lines → angles → off).
+        // `'off'` is the snap bypass now, so Shift no longer holds-to-bypass.
+        e.preventDefault()
+        useEditor.getState().cycleSnappingMode()
+        sfxEmitter.emit('sfx:grid-snap')
+        return
+      }
+
+      if (
+        (e.key === 't' || e.key === 'T') &&
+        !e.repeat &&
+        !e.metaKey &&
+        !e.ctrlKey &&
+        !e.shiftKey &&
+        !e.altKey
+      ) {
+        const context = getActiveContinuationContext()
+        if (context === 'fence') {
+          e.preventDefault()
+          const current = useEditor.getState().getContinuation('fence')
+          useEditor
+            .getState()
+            .setContinuation('fence', current === 'curved' ? 'continuous' : 'curved')
+          sfxEmitter.emit('sfx:grid-snap')
+          return
+        }
+      }
+
+      if (
+        (e.key === 'c' || e.key === 'C') &&
+        !e.repeat &&
+        !e.metaKey &&
+        !e.ctrlKey &&
+        !e.shiftKey &&
+        !e.altKey
+      ) {
+        const context = getActiveContinuationContext()
+        if (context) {
+          e.preventDefault()
+          if (context === 'fence') {
+            const current = useEditor.getState().getContinuation('fence')
+            if (current !== 'curved') {
+              useEditor
+                .getState()
+                .setContinuation('fence', current === 'single' ? 'continuous' : 'single')
+              sfxEmitter.emit('sfx:grid-snap')
+            }
+            return
+          }
+          useEditor.getState().cycleContinuation(context)
+          sfxEmitter.emit('sfx:grid-snap')
+          return
+        }
+      }
+
       if (e.key === 'Escape') {
         e.preventDefault()
+
+        // An in-flight reference-scale measurement swallows Escape whole:
+        // cancel the flow but keep the reference selected and its panel open.
+        if (useEditor.getState().referenceScaleActiveGuideId) {
+          guideEmitter.emit('guide:cancel-reference-scale')
+          return
+        }
+
         _toolCancelConsumed = false
         emitter.emit('tool:cancel')
 
         // Only switch to select mode if no tool had an active mid-action to cancel.
         // (e.g. mid-wall draw or mid-slab polygon should only cancel the action, not exit the tool)
         if (!_toolCancelConsumed) {
-          const currentPhase = useEditor.getState().phase
-          const currentStructureLayer = useEditor.getState().structureLayer
-
-          useEditor.getState().setEditingHole(null)
-
-          // From zone mode, return to structure select
-          if (currentPhase === 'structure' && currentStructureLayer === 'zones') {
-            useEditor.getState().setStructureLayer('elements')
-            useEditor.getState().setMode('select')
-          } else {
-            // Return to the default select tool while keeping the active building/level context.
-            useEditor.getState().setMode('select')
-          }
-
-          useEditor.getState().setFloorplanSelectionTool('click')
-
-          // Clear selections to close UI panels, but KEEP the active building and level context.
-          useViewer.getState().setSelection({ selectedIds: [], zoneId: null })
-          useEditor.getState().setSelectedReferenceId(null)
+          exitToSelectAfterUnconsumedCancel()
         }
       } else if (e.key === '1' && !e.metaKey && !e.ctrlKey) {
         e.preventDefault()
@@ -77,6 +311,9 @@ export const useKeyboard = ({
         e.preventDefault()
         useEditor.getState().setPhase('furnish')
         useEditor.getState().setMode('build')
+        // Set the item tool explicitly so the active tool never inherits a
+        // stale tool from a prior build session.
+        useEditor.getState().setTool('item')
         useEditor.getState().setActiveSidebarPanel('items')
       } else if (e.key === 'z' && !e.metaKey && !e.ctrlKey) {
         if (isVersionPreviewMode) return
@@ -84,6 +321,17 @@ export const useKeyboard = ({
         useEditor.getState().setPhase('structure')
         useEditor.getState().setStructureLayer('zones')
         useEditor.getState().setMode('build')
+        // Set the zone tool explicitly so it never inherits a stale tool.
+        useEditor.getState().setTool('zone')
+      } else if (e.key === 'm' && !e.metaKey && !e.ctrlKey) {
+        if (isVersionPreviewMode) return
+        e.preventDefault()
+        const editor = useEditor.getState()
+        editor.setPhase('structure')
+        editor.setStructureLayer('elements')
+        editor.setToolDefaults('measurement', { kind: editor.lastMeasurementKind })
+        editor.setMode('build')
+        editor.setTool('measurement')
       }
       if (e.key === 'v' && !e.metaKey && !e.ctrlKey) {
         e.preventDefault()
@@ -95,7 +343,10 @@ export const useKeyboard = ({
         useEditor.getState().setPhase('structure')
         useEditor.getState().setStructureLayer('elements')
         useEditor.getState().setMode('build')
-      } else if (e.key === 'd' && !e.metaKey && !e.ctrlKey) {
+        // Set the wall tool explicitly so B never inherits a stale tool
+        // (e.g. fence) left over from a prior build session.
+        useEditor.getState().setTool('wall')
+      } else if (e.key === 'x' && !e.metaKey && !e.ctrlKey) {
         if (isVersionPreviewMode) return
         e.preventDefault()
         useEditor.getState().setMode('delete')
@@ -106,26 +357,45 @@ export const useKeyboard = ({
         useEditor.getState().setPhase('structure')
         useEditor.getState().setStructureLayer('elements')
         useEditor.getState().setMode('material-paint')
-      } else if (e.key === 'z' && (e.metaKey || e.ctrlKey)) {
+      } else if (e.key === 'c' && (e.metaKey || e.ctrlKey) && !e.shiftKey) {
         if (isVersionPreviewMode) return
         e.preventDefault()
-        runUndo()
-      } else if (e.key === 'Z' && e.shiftKey && (e.metaKey || e.ctrlKey)) {
+        copySelectedNodesToEditorClipboard()
+      } else if (e.key === 'v' && (e.metaKey || e.ctrlKey) && !e.shiftKey) {
         if (isVersionPreviewMode) return
         e.preventDefault()
+        const result = pasteEditorClipboardToLevel()
+        if (result?.pastedIds.length) {
+          sfxEmitter.emit('sfx:item-place')
+        }
+      } else if (e.key.toLowerCase() === 'z' && e.shiftKey && (e.metaKey || e.ctrlKey)) {
+        if (isVersionPreviewMode) return
+        e.preventDefault()
+        if (cancelInteractionForHistoryShortcut()) return
         runRedo()
+      } else if (e.key.toLowerCase() === 'z' && !e.shiftKey && (e.metaKey || e.ctrlKey)) {
+        if (isVersionPreviewMode) return
+        e.preventDefault()
+        if (cancelInteractionForHistoryShortcut()) return
+        runUndo()
       } else if (e.key === 'ArrowUp' && (e.metaKey || e.ctrlKey)) {
         e.preventDefault()
         const { buildingId, levelId } = useViewer.getState().selection
         if (buildingId) {
           const building = useScene.getState().nodes[buildingId]
-          if (building && building.type === 'building' && building.children.length > 0) {
-            const currentIdx = levelId ? building.children.indexOf(levelId as any) : -1
-            const nextIdx = currentIdx < building.children.length - 1 ? currentIdx + 1 : currentIdx
+          const levels =
+            building?.type === 'building'
+              ? building.children.filter(
+                  (childId) => useScene.getState().nodes[childId as AnyNodeId]?.type === 'level',
+                )
+              : []
+          if (levels.length > 0) {
+            const currentIdx = levelId ? levels.indexOf(levelId as any) : -1
+            const nextIdx = currentIdx < levels.length - 1 ? currentIdx + 1 : currentIdx
             if (nextIdx !== -1 && nextIdx !== currentIdx) {
-              useViewer.getState().setSelection({ levelId: building.children[nextIdx] as any })
+              useViewer.getState().setSelection({ levelId: levels[nextIdx] as any })
             } else if (currentIdx === -1) {
-              useViewer.getState().setSelection({ levelId: building.children[0] as any })
+              useViewer.getState().setSelection({ levelId: levels[0] as any })
             }
           }
         }
@@ -134,70 +404,192 @@ export const useKeyboard = ({
         const { buildingId, levelId } = useViewer.getState().selection
         if (buildingId) {
           const building = useScene.getState().nodes[buildingId]
-          if (building && building.type === 'building' && building.children.length > 0) {
-            const currentIdx = levelId ? building.children.indexOf(levelId as any) : -1
+          const levels =
+            building?.type === 'building'
+              ? building.children.filter(
+                  (childId) => useScene.getState().nodes[childId as AnyNodeId]?.type === 'level',
+                )
+              : []
+          if (levels.length > 0) {
+            const currentIdx = levelId ? levels.indexOf(levelId as any) : -1
             const prevIdx = currentIdx > 0 ? currentIdx - 1 : currentIdx
             if (prevIdx !== -1 && prevIdx !== currentIdx) {
-              useViewer.getState().setSelection({ levelId: building.children[prevIdx] as any })
+              useViewer.getState().setSelection({ levelId: levels[prevIdx] as any })
             } else if (currentIdx === -1) {
-              useViewer
-                .getState()
-                .setSelection({ levelId: building.children[building.children.length - 1] as any })
+              useViewer.getState().setSelection({ levelId: levels[levels.length - 1] as any })
             }
           }
         }
-      } else if ((e.key === 'r' || e.key === 'R') && !isVersionPreviewMode) {
+      } else if (
+        (e.key === 'r' || e.key === 'R') &&
+        !e.metaKey &&
+        !e.ctrlKey &&
+        !isVersionPreviewMode &&
+        !isPlacingOpening()
+      ) {
+        // `!metaKey && !ctrlKey` lets Cmd/Ctrl+R reach the browser reload instead
+        // of rotating/flipping the selected node.
         // Rotate selected node clockwise if it supports rotation (items, roofs, etc.)
-        // Operable doors/windows use R to toggle their open/closed state.
+        // Doors use R to flip side (front ↔ back, rotation += π); their
+        // open/close toggle lives on E. Windows still use R to toggle
+        // their open/closed state.
+        //
+        // Skipped entirely while a door/window placement is active
+        // (`isPlacingOpening`): the placement tool owns R then (flip the draft
+        // before commit), and the user can have a node selected at the same
+        // time — without this guard both would fire (double flip + sfx).
+        //
+        // References (guide/scan) live in `selectedReferenceId`, not the viewer
+        // selection — check them first, like the Delete arm below.
+        //
+        // Multi-selection branches to the group rotate before any of the
+        // single-selection arms (reference, door/window flip, registry
+        // keyboardActions, plain rotate) — those stay single-selection-only.
+        if (rotateGroupSelection(1)) {
+          e.preventDefault()
+          return
+        }
+        const rotatableReference = getRotatableSelectedReference()
+        if (rotatableReference) {
+          e.preventDefault()
+          useScene.getState().updateNode(rotatableReference.id, {
+            rotation: [
+              rotatableReference.rotation[0],
+              steppedRotation(rotatableReference.rotation[1], 1),
+              rotatableReference.rotation[2],
+            ],
+          })
+          sfxEmitter.emit('sfx:item-rotate')
+          return
+        }
         const selectedNodeIds = useViewer.getState().selection.selectedIds as AnyNodeId[]
         if (selectedNodeIds.length === 1) {
-          const node = useScene.getState().nodes[selectedNodeIds[0]!]
+          const sceneNodes = useScene.getState().nodes
+          const selectedNode = sceneNodes[selectedNodeIds[0]!]
+          const node = selectedNode ? resolveDirectManipulationNode(selectedNode, sceneNodes) : null
           if (node?.type === 'door') {
             e.preventDefault()
-            if (node.openingKind !== 'opening') {
-              toggleDoorOpenState(node.id)
-              sfxEmitter.emit('sfx:item-rotate')
+            useScene.getState().updateNode(node.id, {
+              side: node.side === 'front' ? 'back' : 'front',
+              rotation: [node.rotation[0], node.rotation[1] + Math.PI, node.rotation[2]],
+            })
+            if (node.parentId) {
+              useScene.getState().dirtyNodes.add(node.parentId as AnyNodeId)
             }
-          } else if (
-            node?.type === 'window' &&
-            node.openingKind !== 'opening' &&
-            (node.windowType === 'sliding' ||
-              node.windowType === 'casement' ||
-              node.windowType === 'awning' ||
-              node.windowType === 'hopper' ||
-              node.windowType === 'single-hung' ||
-              node.windowType === 'double-hung' ||
-              node.windowType === 'louvered')
-          ) {
+            sfxEmitter.emit('sfx:item-rotate')
+          } else if (node?.type === 'window') {
+            // Windows: R flips side (front ↔ back, rotation += π). Open/
+            // close toggle for operable windows lives on E.
             e.preventDefault()
-            toggleWindowOpenState(node.id)
+            useScene.getState().updateNode(node.id, {
+              side: node.side === 'front' ? 'back' : 'front',
+              rotation: [node.rotation[0], node.rotation[1] + Math.PI, node.rotation[2]],
+            })
+            if (node.parentId) {
+              useScene.getState().dirtyNodes.add(node.parentId as AnyNodeId)
+            }
+            sfxEmitter.emit('sfx:item-rotate')
+          } else if (node && nodeRegistry.get(node.type)?.keyboardActions?.r?.appliesTo(node)) {
+            // Registry-driven R action. Skylight uses this for open/
+            // close toggling; future kinds with custom R behaviour
+            // declare it on their `def.keyboardActions` without
+            // touching this hook. Door / window still use the legacy
+            // direct calls above (follow-up to migrate).
+            e.preventDefault()
+            nodeRegistry.get(node.type)?.keyboardActions?.r?.run(node)
             sfxEmitter.emit('sfx:item-rotate')
           } else if (node && 'rotation' in node) {
             e.preventDefault()
-            const ROTATION_STEP = Math.PI / 4
-
-            // Handle different rotation types (number for roof, array for items/windows/doors)
+            // Round to the nearest 45° then step one increment (not a blind +45°).
             if (typeof node.rotation === 'number') {
-              useScene.getState().updateNode(node.id, { rotation: node.rotation + ROTATION_STEP })
+              useScene
+                .getState()
+                .updateNode(node.id, { rotation: steppedRotation(node.rotation, 1) })
             } else if (Array.isArray(node.rotation)) {
               useScene.getState().updateNode(node.id, {
-                rotation: [node.rotation[0], node.rotation[1] + ROTATION_STEP, node.rotation[2]],
+                rotation: [
+                  node.rotation[0],
+                  steppedRotation(node.rotation[1], 1),
+                  node.rotation[2],
+                ],
               })
             }
             sfxEmitter.emit('sfx:item-rotate')
           }
         }
-      } else if ((e.key === 't' || e.key === 'T') && !isVersionPreviewMode) {
+      } else if ((e.key === 't' || e.key === 'T') && !isVersionPreviewMode && !isPlacingOpening()) {
         // Rotate selected node counter-clockwise
+        // Multi-selection → group rotate, mirroring the R arm above.
+        if (rotateGroupSelection(-1)) {
+          e.preventDefault()
+          return
+        }
+        const rotatableReference = getRotatableSelectedReference()
+        if (rotatableReference) {
+          e.preventDefault()
+          useScene.getState().updateNode(rotatableReference.id, {
+            rotation: [
+              rotatableReference.rotation[0],
+              steppedRotation(rotatableReference.rotation[1], -1),
+              rotatableReference.rotation[2],
+            ],
+          })
+          sfxEmitter.emit('sfx:item-rotate')
+          return
+        }
         const selectedNodeIds = useViewer.getState().selection.selectedIds as AnyNodeId[]
         if (selectedNodeIds.length === 1) {
-          const node = useScene.getState().nodes[selectedNodeIds[0]!]
+          const sceneNodes = useScene.getState().nodes
+          const selectedNode = sceneNodes[selectedNodeIds[0]!]
+          const node = selectedNode ? resolveDirectManipulationNode(selectedNode, sceneNodes) : null
           if (node?.type === 'door') {
+            // Door's open/close moved to E; T is a no-op for doors so
+            // it doesn't free-rotate a wall-bound node by π/4.
+            e.preventDefault()
+          } else if (node?.type === 'window') {
+            // Window's open/close moved to E; T is a no-op so it doesn't
+            // free-rotate a wall-bound node by π/4.
+            e.preventDefault()
+          } else if (node && nodeRegistry.get(node.type)?.keyboardActions?.t?.appliesTo(node)) {
+            // Registry-driven T action. Same shape as the R arm above.
             e.preventDefault()
-            if (node.openingKind !== 'opening') {
-              closeDoorOpenState(node.id)
-              sfxEmitter.emit('sfx:item-rotate')
+            nodeRegistry.get(node.type)?.keyboardActions?.t?.run(node)
+            sfxEmitter.emit('sfx:item-rotate')
+          } else if (node && 'rotation' in node) {
+            e.preventDefault()
+            // Round to the nearest 45° then step one increment back.
+            if (typeof node.rotation === 'number') {
+              useScene
+                .getState()
+                .updateNode(node.id, { rotation: steppedRotation(node.rotation, -1) })
+            } else if (Array.isArray(node.rotation)) {
+              useScene.getState().updateNode(node.id, {
+                rotation: [
+                  node.rotation[0],
+                  steppedRotation(node.rotation[1], -1),
+                  node.rotation[2],
+                ],
+              })
             }
+            sfxEmitter.emit('sfx:item-rotate')
+          }
+        }
+      } else if ((e.key === 'e' || e.key === 'E') && !isVersionPreviewMode) {
+        // Toggle door / operable-window open/closed state. Moved off R,
+        // which now flips the opening (side + π rotation).
+        const selectedNodeIds = useViewer.getState().selection.selectedIds as AnyNodeId[]
+        if (selectedNodeIds.length === 1) {
+          const node = useScene.getState().nodes[selectedNodeIds[0]!]
+          const registryE = node && nodeRegistry.get(node.type)?.keyboardActions?.e
+          if (node && registryE?.appliesTo(node)) {
+            // Registry-driven E interaction. Same shape as the R/T arms.
+            e.preventDefault()
+            registryE.run(node)
+            sfxEmitter.emit('sfx:item-rotate')
+          } else if (node?.type === 'door' && node.openingKind !== 'opening') {
+            e.preventDefault()
+            toggleDoorOpenState(node.id)
+            sfxEmitter.emit('sfx:item-rotate')
           } else if (
             node?.type === 'window' &&
             node.openingKind !== 'opening' &&
@@ -210,19 +602,7 @@ export const useKeyboard = ({
               node.windowType === 'louvered')
           ) {
             e.preventDefault()
-            closeWindowOpenState(node.id)
-            sfxEmitter.emit('sfx:item-rotate')
-          } else if (node && 'rotation' in node) {
-            e.preventDefault()
-            const ROTATION_STEP = Math.PI / 4
-
-            if (typeof node.rotation === 'number') {
-              useScene.getState().updateNode(node.id, { rotation: node.rotation - ROTATION_STEP })
-            } else if (Array.isArray(node.rotation)) {
-              useScene.getState().updateNode(node.id, {
-                rotation: [node.rotation[0], node.rotation[1] - ROTATION_STEP, node.rotation[2]],
-              })
-            }
+            toggleWindowOpenState(node.id)
             sfxEmitter.emit('sfx:item-rotate')
           }
         }
@@ -241,15 +621,6 @@ export const useKeyboard = ({
           }
         }
 
-        // Delete selected zone
-        const selectedZoneId = useViewer.getState().selection.zoneId
-        if (selectedZoneId) {
-          sfxEmitter.emit('sfx:structure-delete')
-          useScene.getState().deleteNode(selectedZoneId as AnyNodeId)
-          useViewer.getState().setSelection({ zoneId: null })
-          return
-        }
-
         const selectedNodeIds = useViewer.getState().selection.selectedIds as AnyNodeId[]
 
         if (selectedNodeIds.length > 0) {
@@ -265,21 +636,48 @@ export const useKeyboard = ({
           // Play appropriate SFX based on what's being deleted
           if (selectedNodeIds.length === 1) {
             const node = useScene.getState().nodes[selectedNodeIds[0]!]
-            if (node?.type === 'item') {
-              sfxEmitter.emit('sfx:item-delete')
-            } else {
-              sfxEmitter.emit('sfx:structure-delete')
-            }
+            emitDeleteSFX(node?.type)
           } else {
             sfxEmitter.emit('sfx:structure-delete')
           }
 
           useScene.getState().deleteNodes(selectedNodeIds)
+          return
         }
+
+        // Delete selected zone when no explicit element selection is active.
+        const selectedZoneId = useViewer.getState().selection.zoneId
+        if (selectedZoneId) {
+          sfxEmitter.emit('sfx:structure-delete')
+          useScene.getState().deleteNode(selectedZoneId as AnyNodeId)
+          useViewer.getState().setSelection({ zoneId: null })
+        }
+      }
+    }
+    const handleKeyUp = (e: KeyboardEvent) => {
+      if (e.key === 'Control' || e.key === 'Meta') {
+        const wasClean = ctrlTapClean
+        ctrlTapClean = false
+        if (!wasClean) return
+        // Same scope as the Shift snapping-mode cycle, and never while typing
+        // in an input.
+        if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement) {
+          return
+        }
+        if (!isSnappingCycleContext()) return
+        // Cycle the grid / measurement step (0.5 → 0.25 → 0.1 → 0.05).
+        useEditor.getState().cycleGridSnapStep()
+        sfxEmitter.emit('sfx:grid-snap')
+        return
       }
     }
+
     window.addEventListener('keydown', handleKeyDown)
-    return () => window.removeEventListener('keydown', handleKeyDown)
+    window.addEventListener('keyup', handleKeyUp)
+    return () => {
+      window.removeEventListener('keydown', handleKeyDown)
+      window.removeEventListener('keyup', handleKeyUp)
+    }
   }, [disabled, isVersionPreviewMode])
 
   return null