@pascal-app/editor 1.0.0-beta.5 → 1.0.0

package/src/hooks/use-keyboard.test.ts

@@ -0,0 +1,244 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeId,
+  BlockNode,
+  clearSceneHistory,
+  DuctFittingNode,
+  DuctSegmentNode,
+  emitter,
+  nodeRegistry,
+  PipeFittingNode,
+  PipeSegmentNode,
+  useScene,
+} from '@pascal-app/core'
+import { runRedo, runUndo } from '../lib/history'
+import { meshEditScope } from '../lib/interaction/scope'
+import useEditor from '../store/use-editor'
+import useInteractionScope from '../store/use-interaction-scope'
+import {
+  blocksSnappingShortcut,
+  canCycleSnappingModeShortcut,
+  canRunGlobalRotationShortcut,
+  isToolOwnedCanopyForm,
+  isToolOwnedRotation,
+  markToolCancelConsumed,
+  runHistoryShortcut,
+} from './use-keyboard'
+
+type RafFn = (callback: (time: number) => void) => number
+;(globalThis as unknown as { requestAnimationFrame?: RafFn }).requestAnimationFrame ??= (
+  callback,
+) => {
+  callback(0)
+  return 0
+}
+;(globalThis as unknown as { cancelAnimationFrame?: (id: number) => void }).cancelAnimationFrame ??=
+  () => {}
+
+const NODE_ID = 'block_history' as AnyNodeId
+
+describe('snapping shortcuts while entering a run length', () => {
+  test('allows snap mode and spacing shortcuts in the duct and pipe length field', () => {
+    expect(
+      blocksSnappingShortcut({
+        tagName: 'INPUT',
+        isContentEditable: false,
+        hasAttribute: (name) => name === 'data-run-length-input',
+      }),
+    ).toBe(false)
+  })
+
+  test('continues to protect ordinary text fields and editable content', () => {
+    for (const tagName of ['INPUT', 'TEXTAREA', 'DIV']) {
+      expect(
+        blocksSnappingShortcut({
+          tagName,
+          isContentEditable: tagName === 'DIV',
+          hasAttribute: () => false,
+        }),
+      ).toBe(true)
+    }
+    expect(blocksSnappingShortcut(null)).toBe(false)
+  })
+})
+
+beforeEach(() => {
+  const node = BlockNode.parse({ id: NODE_ID, position: [0, 0, 0] })
+  useScene.setState({
+    nodes: { [NODE_ID]: node },
+    rootNodeIds: [NODE_ID],
+    dirtyNodes: new Set<AnyNodeId>(),
+    collections: {},
+    materials: {},
+    readOnly: false,
+  } as never)
+  clearSceneHistory()
+  useScene.getState().updateNode(NODE_ID, { position: [1, 2, 3] } as Partial<AnyNode>)
+})
+
+afterEach(() => {
+  useInteractionScope.getState().end()
+  useEditor.getState().armToolMode({ mode: 'select' })
+  useEditor.setState({ selectedItem: null })
+  clearSceneHistory()
+})
+
+describe('rotation shortcut ownership', () => {
+  test('does not reserve R and T for an armed item tool without a placement item', () => {
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'item' })
+
+    expect(isToolOwnedRotation()).toBe(false)
+  })
+
+  test('leaves R and T to the active item placement tool', () => {
+    useEditor.getState().setSelectedItem({
+      asset: { id: 'asset:test' },
+    } as never)
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'item' })
+
+    expect(isToolOwnedRotation()).toBe(true)
+  })
+
+  test('leaves R and T to the active lean-to placement tool', () => {
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'lean-to-extension' })
+
+    expect(isToolOwnedRotation()).toBe(true)
+  })
+
+  test('leaves R and T to a moving lean-to extension', () => {
+    const leanTo = { id: 'lean_to_moving', type: 'lean-to-extension' } as unknown as AnyNode
+    useInteractionScope.getState().begin({
+      kind: 'moving',
+      node: leanTo,
+      nodeId: leanTo.id,
+      nodeType: leanTo.type,
+      view: '3d',
+    })
+
+    expect(isToolOwnedRotation()).toBe(true)
+  })
+
+  test('leaves F to the active lean-to placement tool', () => {
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'lean-to-extension' })
+
+    expect(isToolOwnedCanopyForm()).toBe(true)
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'wall' })
+    expect(isToolOwnedCanopyForm()).toBe(false)
+  })
+})
+
+describe('history shortcuts during block editing', () => {
+  test('reserves global rotation shortcuts for the active mesh editor', () => {
+    expect(canRunGlobalRotationShortcut()).toBe(true)
+    useInteractionScope.getState().begin(meshEditScope(NODE_ID))
+    expect(canRunGlobalRotationShortcut()).toBe(false)
+  })
+
+  test('keeps Shift available to cycle snapping while a mesh operation is active', () => {
+    useInteractionScope.getState().begin(meshEditScope(NODE_ID))
+    expect(canCycleSnappingModeShortcut(true)).toBe(true)
+
+    useInteractionScope.getState().begin(meshEditScope(NODE_ID, 'operating', 'translate'))
+    expect(canCycleSnappingModeShortcut(true)).toBe(true)
+  })
+
+  test('undoes and redoes mesh changes without leaving component selection mode', () => {
+    useInteractionScope.getState().begin(meshEditScope(NODE_ID))
+
+    expect(runHistoryShortcut('undo')).toBe(true)
+    expect((useScene.getState().nodes[NODE_ID] as BlockNode).position).toEqual([0, 0, 0])
+    expect(useInteractionScope.getState().scope).toEqual({
+      kind: 'mesh-editing',
+      nodeId: NODE_ID,
+      phase: 'selecting',
+    })
+
+    expect(runHistoryShortcut('redo')).toBe(true)
+    expect((useScene.getState().nodes[NODE_ID] as BlockNode).position).toEqual([1, 2, 3])
+    expect(useInteractionScope.getState().scope).toEqual({
+      kind: 'mesh-editing',
+      nodeId: NODE_ID,
+      phase: 'selecting',
+    })
+  })
+})
+
+describe('history while drawing distribution runs', () => {
+  let restoreRegistry = () => {}
+
+  beforeEach(() => {
+    restoreRegistry = nodeRegistry._snapshot()
+    nodeRegistry._reset()
+    for (const kind of ['duct-segment', 'pipe-segment']) {
+      nodeRegistry._register({
+        kind,
+        schemaVersion: 1,
+        drafting: { cancelOnHistoryJump: true },
+      } as never)
+    }
+  })
+
+  afterEach(() => {
+    restoreRegistry()
+    restoreRegistry = () => {}
+  })
+
+  for (const [kind, schema, fittingSchema] of [
+    ['duct', DuctSegmentNode, DuctFittingNode],
+    ['pipe', PipeSegmentNode, PipeFittingNode],
+  ] as const) {
+    test(`undoes and redoes individual ${kind} commits while drafting`, () => {
+      clearSceneHistory()
+      const first = schema.parse({
+        path: [
+          [0, 1, 0],
+          [1, 1, 0],
+        ],
+      })
+      const second = schema.parse({
+        path: [
+          [1, 1, 0],
+          [2, 1, 0],
+        ],
+      })
+      useScene.getState().applyNodeChanges({ create: [{ node: first }] })
+      const fitting = fittingSchema.parse({ position: [1, 1, 0] })
+      const trimmedPath: [number, number, number][] = [
+        [0, 1, 0],
+        [0.8, 1, 0],
+      ]
+      useScene.getState().applyNodeChanges({
+        create: [{ node: second }, { node: fitting }],
+        update: [{ id: first.id, data: { path: trimmedPath } }],
+      })
+      expect(useScene.temporal.getState().pastStates).toHaveLength(2)
+      useInteractionScope.getState().begin({ kind: 'drafting', tool: first.type })
+      let cancellations = 0
+      const cancel = () => {
+        cancellations += 1
+        markToolCancelConsumed()
+      }
+      emitter.on('tool:cancel', cancel)
+      try {
+        expect(runHistoryShortcut('undo')).toBe(true)
+        expect(useScene.getState().nodes[second.id]).toBeUndefined()
+        expect(useScene.getState().nodes[fitting.id]).toBeUndefined()
+        expect(useScene.getState().nodes[first.id]).toMatchObject({ path: first.path })
+        expect(runUndo().kind).toBe('applied')
+        expect(useScene.getState().nodes[first.id]).toBeUndefined()
+        expect(runRedo().kind).toBe('applied')
+        expect(useScene.getState().nodes[first.id]).toBeDefined()
+        expect(useScene.getState().nodes[second.id]).toBeUndefined()
+        expect(runHistoryShortcut('redo')).toBe(true)
+        expect(useScene.getState().nodes[second.id]).toBeDefined()
+        expect(useScene.getState().nodes[fitting.id]).toBeDefined()
+        expect(useScene.getState().nodes[first.id]).toMatchObject({ path: trimmedPath })
+        expect(cancellations).toBe(4)
+        expect(useInteractionScope.getState().scope).toEqual({ kind: 'drafting', tool: first.type })
+      } finally {
+        emitter.off('tool:cancel', cancel)
+      }
+    })
+  }
+})

package/src/hooks/use-keyboard.ts

@@ -7,7 +7,7 @@ import {
   resumeSpaceDetection,
   useScene,
 } from '@pascal-app/core'
-import { useViewer } from '@pascal-app/viewer'
+import { cancelPerfAction, markPerfAction, useViewer } from '@pascal-app/viewer'
 import { useEffect } from 'react'
 import { Vector3 } from 'three'
 import {
@@ -27,7 +27,7 @@ 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 { isHistoryShortcut, runRedo, runUndo, shouldCancelDraftOnHistoryJump } from '../lib/history'
 import { isActive } from '../lib/interaction/scope'
 import { copySelectedNodesToEditorClipboard } from '../lib/scene-clipboard'
 import { sfxEmitter } from '../lib/sfx-bus'
@@ -102,6 +102,9 @@ function rotateGroupSelection(direction: 1 | -1): boolean {
 let _toolCancelConsumed = false
 export const markToolCancelConsumed = () => {
   _toolCancelConsumed = true
+  // A consumed cancel means the active gesture reverted — the perf ledger must
+  // not measure the restore as a committed action's settle.
+  cancelPerfAction()
 }
 
 // Escape's fall-through when no tool consumed the cancel: drop back to the
@@ -117,10 +120,10 @@ const exitToSelectAfterUnconsumedCancel = () => {
   // From zone mode, return to structure select
   if (currentPhase === 'structure' && currentStructureLayer === 'zones') {
     useEditor.getState().setStructureLayer('elements')
-    useEditor.getState().setMode('select')
+    useEditor.getState().armToolMode({ mode: 'select' })
   } else {
     // Return to the default select tool while keeping the active building/level context.
-    useEditor.getState().setMode('select')
+    useEditor.getState().armToolMode({ mode: 'select' })
   }
 
   useEditor.getState().setFloorplanSelectionTool('click')
@@ -141,6 +144,9 @@ const cancelInteractionForHistoryShortcut = () => {
     guideEmitter.emit('guide:cancel-reference-scale')
     return true
   }
+  const activeScope = useInteractionScope.getState().scope
+  if (shouldCancelDraftOnHistoryJump()) return false
+  if (activeScope.kind === 'mesh-editing' && activeScope.phase === 'selecting') return false
   _toolCancelConsumed = false
   emitter.emit('tool:cancel')
   if (_toolCancelConsumed) return true
@@ -162,6 +168,56 @@ const cancelInteractionForHistoryShortcut = () => {
   return false
 }
 
+export const runHistoryShortcut = (direction: 'undo' | 'redo') => {
+  if (cancelInteractionForHistoryShortcut()) return false
+  if (direction === 'redo') runRedo()
+  else runUndo()
+  return true
+}
+
+export const isToolOwnedRotation = () => {
+  const editor = useEditor.getState()
+  const moving = getMovingNode()
+  if (
+    moving?.type === 'door' ||
+    moving?.type === 'window' ||
+    moving?.type === 'item' ||
+    moving?.type === 'lean-to-extension'
+  )
+    return true
+  return (
+    editor.mode === 'build' &&
+    (editor.tool === 'door' ||
+      editor.tool === 'window' ||
+      editor.tool === 'roof' ||
+      // The item tool is mounted for the build mode, but it only owns R/T
+      // when a catalog item is actually selected and a placement draft can
+      // exist. Without this check, selecting an existing item in the 2D plan
+      // while the item tool is armed silently drops the global rotate key.
+      (editor.tool === 'item' && editor.selectedItem !== null) ||
+      editor.tool === 'lean-to-extension')
+  )
+}
+
+export const isToolOwnedCanopyForm = () => {
+  const editor = useEditor.getState()
+  return editor.mode === 'build' && editor.tool === 'lean-to-extension'
+}
+
+export const canRunGlobalRotationShortcut = () =>
+  useInteractionScope.getState().scope.kind !== 'mesh-editing'
+
+export const canCycleSnappingModeShortcut = (hasActiveContext = getActiveSnapContext() != null) =>
+  hasActiveContext
+
+export function blocksSnappingShortcut(
+  target: Pick<HTMLElement, 'tagName' | 'isContentEditable' | 'hasAttribute'> | null,
+): boolean {
+  if (!target) return false
+  if (target.tagName === 'INPUT' && target.hasAttribute('data-run-length-input')) return false
+  return target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable
+}
+
 export const useKeyboard = ({
   isVersionPreviewMode = false,
   disabled = false,
@@ -174,32 +230,30 @@ 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')
-    }
-
+    // True while an active placement tool owns R/T. Door/window tools flip the
+    // draft, item / lean-to placement rotates its draft, and the roof tool turns
+    // its draft axes. The global selection handler must stand down to avoid double-firing.
     // 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
+    let shiftTapClean = false
 
     const handleKeyDown = (e: KeyboardEvent) => {
+      if (e.key === 'Shift') {
+        shiftTapClean = !e.repeat && !e.metaKey && !e.ctrlKey && !e.altKey
+      } else {
+        shiftTapClean = false
+      }
+
       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.
@@ -210,6 +264,18 @@ export const useKeyboard = ({
         ctrlTapClean = false
       }
 
+      if (
+        shouldCancelDraftOnHistoryJump() &&
+        isHistoryShortcut(e) &&
+        e.target instanceof HTMLInputElement &&
+        e.target.hasAttribute('data-run-length-input')
+      ) {
+        if (isVersionPreviewMode || useDeleteConfirmation.getState().request) return
+        e.preventDefault()
+        runHistoryShortcut(e.shiftKey ? 'redo' : 'undo')
+        return
+      }
+
       // Don't handle shortcuts if user is typing in an input
       if (
         e.target instanceof HTMLInputElement ||
@@ -261,15 +327,6 @@ export const useKeyboard = ({
         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 &&
@@ -338,32 +395,28 @@ export const useKeyboard = ({
       } else if (e.key === '1' && !e.metaKey && !e.ctrlKey) {
         e.preventDefault()
         useEditor.getState().setPhase('site')
-        useEditor.getState().setMode('select')
+        useEditor.getState().armToolMode({ mode: 'select' })
       } else if (e.key === '2' && !e.metaKey && !e.ctrlKey) {
         e.preventDefault()
         useEditor.getState().setPhase('structure')
-        useEditor.getState().setMode('select')
+        useEditor.getState().armToolMode({ mode: 'select' })
       } else if (e.key === '3' && !e.metaKey && !e.ctrlKey) {
         e.preventDefault()
         useEditor.getState().setPhase('furnish')
-        useEditor.getState().setMode('select')
+        useEditor.getState().armToolMode({ mode: 'select' })
       } else if (e.key === 'f' && !e.metaKey && !e.ctrlKey) {
         if (isVersionPreviewMode) return
+        if (isToolOwnedCanopyForm()) return
         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().armToolMode({ mode: 'build', tool: 'item' })
         useEditor.getState().setActiveSidebarPanel('items')
       } else if (e.key === 'z' && !e.metaKey && !e.ctrlKey) {
         if (isVersionPreviewMode) return
         e.preventDefault()
         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')
+        useEditor.getState().armToolMode({ mode: 'build', tool: 'zone' })
       } else if (e.key === 'm' && !e.metaKey && !e.ctrlKey) {
         if (isVersionPreviewMode) return
         e.preventDefault()
@@ -371,39 +424,33 @@ export const useKeyboard = ({
         editor.setPhase('structure')
         editor.setStructureLayer('elements')
         editor.setToolDefaults('measurement', { kind: editor.lastMeasurementKind })
-        editor.setMode('build')
-        editor.setTool('measurement')
+        editor.armToolMode({ mode: 'build', tool: 'measurement' })
       }
       if (e.key === 'v' && !e.metaKey && !e.ctrlKey) {
         e.preventDefault()
-        useEditor.getState().setMode('select')
+        useEditor.getState().armToolMode({ mode: 'select' })
         useEditor.getState().setFloorplanSelectionTool('click')
       } else if (e.key === 'b' && !e.metaKey && !e.ctrlKey) {
         if (isVersionPreviewMode) return
         e.preventDefault()
         useEditor.getState().setPhase('structure')
         useEditor.getState().setStructureLayer('elements')
-        useEditor.getState().setMode('build')
-        // 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')
+        useEditor.getState().armToolMode({ mode: 'build', tool: 'wall' })
       } else if (e.key === 'x' && !e.metaKey && !e.ctrlKey) {
         if (isVersionPreviewMode) return
         e.preventDefault()
-        useEditor.getState().setMode('delete')
+        useEditor.getState().armToolMode({ mode: 'delete' })
       } else if (e.key === 'p' && !e.metaKey && !e.ctrlKey) {
         if (isVersionPreviewMode) return
         e.preventDefault()
-        useEditor.getState().primeMaterialPaintFromSelection()
         useEditor.getState().setPhase('structure')
         useEditor.getState().setStructureLayer('elements')
-        useEditor.getState().setMode('material-paint')
+        useEditor.getState().armMaterialPaint()
       } else if (e.key === 'g' && !e.metaKey && !e.ctrlKey) {
         if (isVersionPreviewMode) return
         e.preventDefault()
-        // G for ground. No `setPhase` — `setMode` moves to the site phase itself,
-        // and doing it here would set the phase twice with a mode reset between.
-        useEditor.getState().setMode('terrain-sculpt')
+        // G for ground. The ToolMode transition moves to the site phase itself.
+        useEditor.getState().armToolMode({ mode: 'terrain-sculpt' })
       } else if (e.key === 'c' && (e.metaKey || e.ctrlKey) && !e.shiftKey) {
         if (isVersionPreviewMode) return
         e.preventDefault()
@@ -419,13 +466,11 @@ export const useKeyboard = ({
       } else if (e.key.toLowerCase() === 'z' && e.shiftKey && (e.metaKey || e.ctrlKey)) {
         if (isVersionPreviewMode) return
         e.preventDefault()
-        if (cancelInteractionForHistoryShortcut()) return
-        runRedo()
+        runHistoryShortcut('redo')
       } else if (e.key.toLowerCase() === 'z' && !e.shiftKey && (e.metaKey || e.ctrlKey)) {
         if (isVersionPreviewMode) return
         e.preventDefault()
-        if (cancelInteractionForHistoryShortcut()) return
-        runUndo()
+        runHistoryShortcut('undo')
       } else if (e.key === 'ArrowUp' && (e.metaKey || e.ctrlKey)) {
         e.preventDefault()
         const { buildingId, levelId } = useViewer.getState().selection
@@ -441,8 +486,10 @@ export const useKeyboard = ({
             const currentIdx = levelId ? levels.indexOf(levelId as any) : -1
             const nextIdx = currentIdx < levels.length - 1 ? currentIdx + 1 : currentIdx
             if (nextIdx !== -1 && nextIdx !== currentIdx) {
+              markPerfAction('level-switch', levels[nextIdx] as string)
               useViewer.getState().setSelection({ levelId: levels[nextIdx] as any })
             } else if (currentIdx === -1) {
+              markPerfAction('level-switch', levels[0] as string)
               useViewer.getState().setSelection({ levelId: levels[0] as any })
             }
           }
@@ -462,8 +509,10 @@ export const useKeyboard = ({
             const currentIdx = levelId ? levels.indexOf(levelId as any) : -1
             const prevIdx = currentIdx > 0 ? currentIdx - 1 : currentIdx
             if (prevIdx !== -1 && prevIdx !== currentIdx) {
+              markPerfAction('level-switch', levels[prevIdx] as string)
               useViewer.getState().setSelection({ levelId: levels[prevIdx] as any })
             } else if (currentIdx === -1) {
+              markPerfAction('level-switch', levels[levels.length - 1] as string)
               useViewer.getState().setSelection({ levelId: levels[levels.length - 1] as any })
             }
           }
@@ -473,7 +522,8 @@ export const useKeyboard = ({
         !e.metaKey &&
         !e.ctrlKey &&
         !isVersionPreviewMode &&
-        !isPlacingOpening()
+        !isToolOwnedRotation() &&
+        canRunGlobalRotationShortcut()
       ) {
         // `!metaKey && !ctrlKey` lets Cmd/Ctrl+R reach the browser reload instead
         // of rotating/flipping the selected node.
@@ -482,10 +532,9 @@ export const useKeyboard = ({
         // 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).
+        // Skipped while an item, door, window, or roof placement owns rotation.
+        // The user can still have a node selected during placement; without this
+        // guard both the draft and the selection would rotate.
         //
         // References (guide/scan) live in `selectedReferenceId`, not the viewer
         // selection — check them first, like the Delete arm below.
@@ -565,7 +614,12 @@ export const useKeyboard = ({
             sfxEmitter.emit('sfx:item-rotate')
           }
         }
-      } else if ((e.key === 't' || e.key === 'T') && !isVersionPreviewMode && !isPlacingOpening()) {
+      } else if (
+        (e.key === 't' || e.key === 'T') &&
+        !isVersionPreviewMode &&
+        !isToolOwnedRotation() &&
+        canRunGlobalRotationShortcut()
+      ) {
         // Rotate selected node counter-clockwise
         // Multi-selection → group rotate, mirroring the R arm above.
         if (rotateGroupSelection(-1)) {
@@ -683,16 +737,27 @@ export const useKeyboard = ({
       }
     }
     const handleKeyUp = (e: KeyboardEvent) => {
+      if (e.key === 'Shift') {
+        const wasClean = shiftTapClean
+        shiftTapClean = false
+        if (!wasClean) return
+        if (blocksSnappingShortcut(e.target instanceof HTMLElement ? e.target : null)) {
+          return
+        }
+        if (!canCycleSnappingModeShortcut()) return
+        e.preventDefault()
+        useEditor.getState().cycleSnappingMode()
+        sfxEmitter.emit('sfx:grid-snap')
+        return
+      }
       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) {
+        if (blocksSnappingShortcut(e.target instanceof HTMLElement ? e.target : null)) {
           return
         }
-        if (!isSnappingCycleContext()) return
+        if (!canCycleSnappingModeShortcut()) return
         // Cycle the grid / measurement step (0.5 → 0.25 → 0.1 → 0.05).
         useEditor.getState().cycleGridSnapStep()
         sfxEmitter.emit('sfx:grid-snap')
@@ -706,6 +771,8 @@ export const useKeyboard = ({
     // registry move overlay) — safe only because none of them claim Ctrl/Cmd+G.
     // `e.code` keeps it on the physical G key across keyboard layouts.
     const handleSessionGroupKeyDown = (e: KeyboardEvent) => {
+      if (e.key !== 'Shift') shiftTapClean = false
+      if (e.key !== 'Control' && e.key !== 'Meta') ctrlTapClean = false
       if (
         e.target instanceof HTMLInputElement ||
         e.target instanceof HTMLTextAreaElement ||

package/src/hooks/use-registered-tool-enabled.ts

@@ -0,0 +1,20 @@
+'use client'
+
+import { isNodeKindEnabled, useScene } from '@pascal-app/core'
+import { useEffect } from 'react'
+import useEditor, { type Tool } from '../store/use-editor'
+
+export function useRegisteredToolEnabled(tool: Tool | null): boolean {
+  const installedPlugins = useScene((state) => state.installedPlugins)
+  const enabled = tool === null || isNodeKindEnabled(tool, installedPlugins)
+
+  useEffect(() => {
+    if (enabled || tool === null) return
+
+    // The render gate has already unmounted the tool, so its own cleanup cancels
+    // any draft before clearing the stale selection prevents reinstall remounts.
+    if (useEditor.getState().tool === tool) useEditor.getState().setTool(null)
+  }, [enabled, tool])
+
+  return enabled
+}

package/src/hooks/use-save-shortcut.ts

@@ -0,0 +1,33 @@
+'use client'
+
+import { useEffect, useRef } from 'react'
+
+/**
+ * Claims Cmd/Ctrl+S for the app's save.
+ *
+ * Capture phase and ungated on purpose: the browser's "Save page" dialog must
+ * never appear anywhere in the editor — including first-person, studio mode and
+ * while focus sits in an input, where people still expect the chord to save.
+ * `e.code` keeps it on the physical S key across keyboard layouts.
+ */
+export function useSaveShortcut(onSave: () => void) {
+  const onSaveRef = useRef(onSave)
+
+  useEffect(() => {
+    onSaveRef.current = onSave
+  }, [onSave])
+
+  useEffect(() => {
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if (!(e.metaKey || e.ctrlKey) || e.altKey || e.shiftKey) return
+      if (e.code !== 'KeyS') return
+
+      e.preventDefault()
+      e.stopPropagation()
+      onSaveRef.current()
+    }
+
+    window.addEventListener('keydown', handleKeyDown, true)
+    return () => window.removeEventListener('keydown', handleKeyDown, true)
+  }, [])
+}