@pascal-app/editor 1.0.1 → 1.0.4

package/src/hooks/use-ceiling-events.ts

@@ -56,6 +56,8 @@ export function useCeilingEvents() {
   const hoveredRef = useRef<string | null>(null)
 
   useEffect(() => {
+    // XR placement is driven by the controller-ray bridge, never screen coordinates.
+    if (gl.xr.isPresenting) return
     const canvas = gl.domElement
 
     const isActive = (): boolean => {

package/src/hooks/use-grid-events.test.ts

@@ -70,6 +70,7 @@ test('grid moves throttle camera drags at 100 ms and resume immediately during t
         render() {},
         setSize() {},
         setPixelRatio() {},
+        xr: { isPresenting: false },
       } as unknown as WebGLRenderer,
       camera,
       frameloop: 'never',
@@ -199,6 +200,7 @@ test.each([
         render() {},
         setSize() {},
         setPixelRatio() {},
+        xr: { isPresenting: false },
       } as unknown as WebGLRenderer,
       camera,
       frameloop: 'never',

package/src/hooks/use-grid-events.ts

@@ -3,6 +3,7 @@ import {
   type EventSuffix,
   emitter,
   type GridEvent,
+  hiddenWallPointerEventsHeld,
   nodeRegistry,
   sceneRegistry,
   useScene,
@@ -58,6 +59,8 @@ export function useGridEvents(gridY: number) {
   }, [gridY])
 
   useEffect(() => {
+    // XR placement is driven by the controller-ray bridge, never screen coordinates.
+    if (gl.xr.isPresenting) return
     const canvas = gl.domElement
     setSurfaceRaycastLayers(raycaster.current.layers)
 
@@ -132,7 +135,10 @@ export function useGridEvents(gridY: number) {
       // Architectural meshes are expensive to raycast and are meaningful only
       // to an active placement/drafting interaction. Floor tools retain the
       // ordinary terrain/grid intersection without scanning every wall.
-      const surfaceHit = semanticSurfaceQueryRef.current ? getSurfaceIntersection() : null
+      const surfaceHit =
+        semanticSurfaceQueryRef.current || hiddenWallPointerEventsHeld()
+          ? getSurfaceIntersection()
+          : null
 
       // A semantic architectural hit is the authoritative cursor position.
       // Do not replace it with the terrain/grid intersection below: that would
@@ -244,16 +250,15 @@ export function useGridEvents(gridY: number) {
           : undefined,
         surfaceNormal: localNormal ? [localNormal.x, localNormal.y, localNormal.z] : undefined,
         surfaceObject: point.surface?.object,
-        surfaceHit:
-          semanticSurfaceQueryRef.current && point.surface
-            ? {
-                kind: point.surface.descriptor.kind,
-                hostId: point.surface.hostId,
-                face: classifiedFace?.face ?? 'unknown',
-                levelId: useViewer.getState().selection.levelId ?? undefined,
-                side: classifiedFace?.side,
-              }
-            : undefined,
+        surfaceHit: point.surface
+          ? {
+              kind: point.surface.descriptor.kind,
+              hostId: point.surface.hostId,
+              face: classifiedFace?.face ?? 'unknown',
+              levelId: useViewer.getState().selection.levelId ?? undefined,
+              side: classifiedFace?.side,
+            }
+          : undefined,
         nativeEvent: nativeEvent as any, // Type compatibility with ThreeEvent
       }
 

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

@@ -10,20 +10,29 @@ import {
   nodeRegistry,
   PipeFittingNode,
   PipeSegmentNode,
+  registerNode,
+  useInteractive,
   useScene,
 } from '@pascal-app/core'
+import { useSidebarStore } from '../components/ui/primitives/sidebar'
 import { runRedo, runUndo } from '../lib/history'
 import { meshEditScope } from '../lib/interaction/scope'
+import { setSidebarTabIds } from '../lib/sidebar-panel'
 import useEditor from '../store/use-editor'
 import useInteractionScope from '../store/use-interaction-scope'
 import {
+  armPaintFromShortcut,
+  armWallToolFromShortcut,
   blocksSnappingShortcut,
   canCycleSnappingModeShortcut,
   canRunGlobalRotationShortcut,
   isToolOwnedCanopyForm,
   isToolOwnedRotation,
   markToolCancelConsumed,
+  openItemCatalogFromShortcut,
   runHistoryShortcut,
+  runNodeInteraction,
+  switchPhaseFromShortcut,
 } from './use-keyboard'
 
 type RafFn = (callback: (time: number) => void) => number
@@ -106,6 +115,12 @@ describe('rotation shortcut ownership', () => {
     expect(isToolOwnedRotation()).toBe(true)
   })
 
+  test('does not reserve R for the wall tool: its shape is picked in the Build panel', () => {
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'wall' })
+
+    expect(isToolOwnedRotation()).toBe(false)
+  })
+
   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({
@@ -242,3 +257,170 @@ describe('history while drawing distribution runs', () => {
     })
   }
 })
+
+describe('E on a single selected node', () => {
+  function registerKind(overrides: Record<string, unknown>) {
+    const kind = `test:e-${crypto.randomUUID()}`
+    registerNode({
+      kind,
+      schemaVersion: 1,
+      category: 'furnish',
+      defaults: () => ({}),
+      capabilities: {},
+      ...overrides,
+    } as never)
+    return { object: 'node', id: `${kind}_1`, type: kind } as unknown as AnyNode
+  }
+
+  const switchMechanism = {
+    has: () => true,
+    isOn: (node: AnyNode, state: ReturnType<typeof useInteractive.getState>) =>
+      Boolean(state.mechanisms[node.id]),
+    set: (node: AnyNode, on: boolean) => useInteractive.getState().setMechanism(node.id, on),
+  }
+
+  test('runs the mechanism of a kind that declares only the capability', () => {
+    const node = registerKind({ capabilities: { mechanism: switchMechanism } })
+    try {
+      expect(runNodeInteraction(node)).toBe(true)
+      expect(useInteractive.getState().mechanisms[node.id]).toBe(true)
+      expect(runNodeInteraction(node)).toBe(true)
+      expect(useInteractive.getState().mechanisms[node.id]).toBe(false)
+    } finally {
+      useInteractive.getState().removeMechanism(node.id)
+    }
+  })
+
+  test("prefers the kind's own E action over its mechanism", () => {
+    let ran = 0
+    const node = registerKind({
+      capabilities: { mechanism: switchMechanism },
+      keyboardActions: { e: { appliesTo: () => true, run: () => (ran += 1) } },
+    })
+    expect(runNodeInteraction(node)).toBe(true)
+    expect(ran).toBe(1)
+    expect(useInteractive.getState().mechanisms[node.id]).toBeUndefined()
+  })
+
+  test('leaves E to the door and window fallbacks when nothing applies', () => {
+    const node = registerKind({
+      capabilities: { mechanism: { ...switchMechanism, has: () => false } },
+    })
+    expect(runNodeInteraction(node)).toBe(false)
+    expect(runNodeInteraction(registerKind({}))).toBe(false)
+  })
+})
+
+describe('B and P open their panel', () => {
+  afterEach(() => {
+    setSidebarTabIds([])
+    useSidebarStore.getState().setIsCollapsed(false)
+    useEditor.getState().setContinuation('wall', 'room')
+    useEditor.getState().armToolMode({ mode: 'select' })
+  })
+
+  test('1 goes to site and 2 into the building; 3 is no longer a shortcut', () => {
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'wall' })
+    expect(switchPhaseFromShortcut('1')).toBe(true)
+    expect(useEditor.getState().phase).toBe('site')
+    expect(useEditor.getState().mode).toBe('select')
+    expect(switchPhaseFromShortcut('2')).toBe(true)
+    expect(useEditor.getState().phase).toBe('building')
+    expect(switchPhaseFromShortcut('3')).toBe(false)
+    expect(useEditor.getState().phase).toBe('building')
+  })
+
+  test('F, B and P arm their tool and keep the building', () => {
+    setSidebarTabIds(['site', 'build', 'paint', 'items'])
+    useEditor.getState().setPhase('building')
+    for (const [arm, mode, tool] of [
+      [openItemCatalogFromShortcut, 'build', 'item'],
+      [armWallToolFromShortcut, 'build', 'wall'],
+      [armPaintFromShortcut, 'material-paint', null],
+    ] as const) {
+      arm()
+      expect(useEditor.getState().phase).toBe('building')
+      expect(useEditor.getState().mode).toBe(mode)
+      expect(useEditor.getState().tool).toBe(tool)
+    }
+    openItemCatalogFromShortcut()
+    expect(useEditor.getState().activeSidebarPanel).toBe('items')
+  })
+
+  test('F, B and P also keep Site when arming their tool', () => {
+    setSidebarTabIds(['site', 'build', 'paint', 'items'])
+    for (const arm of [
+      openItemCatalogFromShortcut,
+      armWallToolFromShortcut,
+      armPaintFromShortcut,
+    ]) {
+      useEditor.getState().setPhase('site')
+      useEditor.getState().armToolMode({ mode: 'select' })
+      arm()
+      expect(useEditor.getState().phase).toBe('site')
+    }
+  })
+
+  test('F opens a collapsed catalog sidebar', () => {
+    setSidebarTabIds(['site', 'build', 'items'])
+    useSidebarStore.getState().setIsCollapsed(true)
+    openItemCatalogFromShortcut()
+    expect(useEditor.getState().activeSidebarPanel).toBe('items')
+    expect(useSidebarStore.getState().isCollapsed).toBe(false)
+  })
+
+  test('B arms the wall tool on Rectangle and shows the Build panel', () => {
+    setSidebarTabIds(['site', 'build', 'paint', 'items'])
+    useEditor.getState().setActiveSidebarPanel('items')
+    useSidebarStore.getState().setIsCollapsed(true)
+    useEditor.getState().setContinuation('wall', 'single')
+
+    armWallToolFromShortcut()
+
+    const editor = useEditor.getState()
+    expect(editor.mode).toBe('build')
+    expect(editor.tool).toBe('wall')
+    expect(editor.getContinuation('wall')).toBe('rectangle')
+    expect(editor.activeSidebarPanel).toBe('build')
+    expect(useSidebarStore.getState().isCollapsed).toBe(false)
+  })
+
+  // A host may drop the armed tool when the panel changes (the community does,
+  // with any placement in flight), so B and F open their panel first.
+  test('B and F keep their tool from another panel where the host disarms on a panel change', () => {
+    setSidebarTabIds(['build', 'paint', 'items', 'ai'])
+    const unsubscribe = useEditor.subscribe((state, prev) => {
+      if (state.activeSidebarPanel !== prev.activeSidebarPanel) {
+        useEditor.getState().armToolMode({ mode: 'select' })
+      }
+    })
+    try {
+      for (const [arm, from, panel, tool] of [
+        [armWallToolFromShortcut, 'ai', 'build', 'wall'],
+        [openItemCatalogFromShortcut, 'paint', 'items', 'item'],
+      ] as const) {
+        useEditor.getState().setActiveSidebarPanel(from)
+        arm()
+        const editor = useEditor.getState()
+        expect(editor.activeSidebarPanel).toBe(panel)
+        expect(editor.mode).toBe('build')
+        expect(editor.tool).toBe(tool)
+      }
+    } finally {
+      unsubscribe()
+    }
+  })
+
+  test('P arms paint and shows the Paint panel, or Build where the host has none', () => {
+    setSidebarTabIds(['build', 'paint', 'items'])
+    useEditor.getState().setActiveSidebarPanel('items')
+    armPaintFromShortcut()
+    expect(useEditor.getState().mode).toBe('material-paint')
+    expect(useEditor.getState().activeSidebarPanel).toBe('paint')
+
+    setSidebarTabIds(['site', 'build', 'items'])
+    useEditor.getState().setActiveSidebarPanel('items')
+    armPaintFromShortcut()
+    expect(useEditor.getState().activeSidebarPanel).toBe('build')
+  })
+})

package/src/hooks/use-keyboard.ts

@@ -5,11 +5,11 @@ import {
   nodeRegistry,
   pauseSpaceDetection,
   resumeSpaceDetection,
+  toggleNodeMechanism,
   useScene,
 } from '@pascal-app/core'
 import { cancelPerfAction, markPerfAction, useViewer } from '@pascal-app/viewer'
 import { useEffect } from 'react'
-import { Vector3 } from 'three'
 import {
   cutSelectionToEditorClipboard,
   deleteSelection,
@@ -18,25 +18,32 @@ import {
 import {
   classifyParticipant,
   collectParticipants,
-  computeGroupBox,
-  expandToComponent,
+  groupPlanBounds,
   levelFrame,
+  planBoundsCenter,
   rotateGroupPatches,
 } from '../components/editor/group-transform-shared'
 import { steppedRotation } from '../components/tools/item/placement-math'
+import { keyCyclableContinuationContext } from '../lib/continuation'
 import { resolveDirectManipulationNode } from '../lib/direct-manipulation'
-import { toggleDoorOpenState } from '../lib/door-interaction'
+import { cancelGestures } from '../lib/gesture-lifecycle'
 import { guideEmitter } from '../lib/guide-events'
 import { isHistoryShortcut, runRedo, runUndo, shouldCancelDraftOnHistoryJump } from '../lib/history'
 import { isActive } from '../lib/interaction/scope'
+import { paintRegionModeActive } from '../lib/paint-region-mode'
+import { popRoomSelection } from '../lib/room-selection-commands'
 import { copySelectedNodesToEditorClipboard } from '../lib/scene-clipboard'
 import { sfxEmitter } from '../lib/sfx-bus'
+import { openSidebarPanel } from '../lib/sidebar-panel'
 import { activeSiteNode, clampBrushRadius } from '../lib/terrain-sculpt'
 import { leaveUnitFocus } from '../lib/units'
-import { toggleWindowOpenState } from '../lib/window-interaction'
+import { selectWallDrawVariant } from '../lib/wall-draw-variant'
 import useDeleteConfirmation from '../store/use-delete-confirmation'
 import useEditor, { getActiveContinuationContext, getActiveSnapContext } from '../store/use-editor'
-import useInteractionScope, { getMovingNode } from '../store/use-interaction-scope'
+import useInteractionScope, {
+  getMovingNode,
+  isInteractionSubtreeDraft,
+} from '../store/use-interaction-scope'
 import { groupCurrentSelection, ungroupCurrentSelection } from '../store/use-session-groups'
 
 // References (guide/scan) are selected via `useEditor.selectedReferenceId`, not
@@ -66,27 +73,20 @@ function rotateGroupSelection(direction: 1 | -1): boolean {
     (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)
+  const { starts, links } = collectParticipants(participantIds, 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)
+  // Same pivot as the dashed boxes and the rotate gizmo: the selection's box
+  // centre in the level frame.
+  const bounds = groupPlanBounds(starts, levelFrame(levelId).inverse)
+  if (!bounds) return false
+  const [pivotX, pivotZ] = planBoundsCenter(bounds)
 
   // 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)
+  const patches = rotateGroupPatches(starts, links, { x: pivotX, z: pivotZ }, 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()
@@ -113,19 +113,23 @@ export const markToolCancelConsumed = () => {
 // 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().armToolMode({ mode: 'select' })
-  } else {
-    // Return to the default select tool while keeping the active building/level context.
-    useEditor.getState().armToolMode({ mode: 'select' })
-  }
+  const editor = useEditor.getState()
+  if (
+    editor.mode === 'select' &&
+    useInteractionScope.getState().scope.kind === 'idle' &&
+    popRoomSelection()
+  )
+    return
+  useInteractionScope
+    .getState()
+    .endIf(
+      (sc) =>
+        (sc.kind === 'placing' && isInteractionSubtreeDraft()) ||
+        (sc.kind === 'reshaping' && sc.reshape === 'hole'),
+    )
+
+  // Back to the select tool, keeping the active building/level context.
+  useEditor.getState().armToolMode({ mode: 'select' })
 
   useEditor.getState().setFloorplanSelectionTool('click')
 
@@ -134,6 +138,20 @@ const exitToSelectAfterUnconsumedCancel = () => {
   useEditor.getState().setSelectedReferenceId(null)
 }
 
+// Cancel the active editor action with the same consume-or-exit semantics as
+// Escape. Spatial inputs use this instead of unconditionally selecting the
+// Select tool, so multi-step tools can keep their tool active after clearing
+// the current draft.
+export const cancelActiveTool = () => {
+  _toolCancelConsumed = false
+  emitter.emit('tool:cancel')
+  if (!_toolCancelConsumed) {
+    if (leaveUnitFocus()) useEditor.getState().armToolMode({ mode: 'select' })
+    else exitToSelectAfterUnconsumedCancel()
+  }
+  return _toolCancelConsumed
+}
+
 // ⌘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
@@ -145,6 +163,11 @@ const cancelInteractionForHistoryShortcut = () => {
     guideEmitter.emit('guide:cancel-reference-scale')
     return true
   }
+  // A live gesture reads ⌘Z as "abort", never as a jump under the pointer.
+  if (cancelGestures('history')) {
+    cancelPerfAction()
+    return true
+  }
   const activeScope = useInteractionScope.getState().scope
   if (shouldCancelDraftOnHistoryJump()) return false
   if (activeScope.kind === 'mesh-editing' && activeScope.phase === 'selecting') return false
@@ -176,6 +199,41 @@ export const runHistoryShortcut = (direction: 'undo' | 'redo') => {
   return true
 }
 
+/**
+ * B: the wall tool on Rectangle — the quickest room — with the Build panel
+ * showing, so the lit tile says what is in hand. The panel's tiles still pick
+ * another shape for the session. The panel opens before the tool is armed: a
+ * host may drop the armed tool when the panel changes.
+ */
+export const armWallToolFromShortcut = () => {
+  selectWallDrawVariant('rectangle')
+  openSidebarPanel(['build'])
+  useEditor.getState().armToolMode({ mode: 'build', tool: 'wall' })
+}
+
+/** 1: site, 2: the building — each back on the select tool. Returns whether `key` was one. */
+export const switchPhaseFromShortcut = (key: string): boolean => {
+  const phase = key === '1' ? 'site' : key === '2' ? 'building' : null
+  if (!phase) return false
+  useEditor.getState().setPhase(phase)
+  useEditor.getState().armToolMode({ mode: 'select' })
+  return true
+}
+
+/** F: the item tool with the items catalog showing, opened first as B's is. */
+export const openItemCatalogFromShortcut = () => {
+  openSidebarPanel(['items'])
+  useEditor.getState().setActiveSidebarPanel('items')
+  useEditor.getState().armToolMode({ mode: 'build', tool: 'item' })
+}
+
+/** P: paint mode, with the Paint panel showing (the Build panel where a host has no Paint tab). */
+export const armPaintFromShortcut = () => {
+  useEditor.getState().armMaterialPaint()
+  openSidebarPanel(['paint', 'build'])
+}
+
+/** Whether an armed tool owns the rotation keys (`R` / `T`) instead of the selection. */
 export const isToolOwnedRotation = () => {
   const editor = useEditor.getState()
   const moving = getMovingNode()
@@ -219,6 +277,16 @@ export function blocksSnappingShortcut(
   return target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable
 }
 
+/** E on one selected node: the kind's own E action, else its mechanism. False when neither applies. */
+export function runNodeInteraction(node: AnyNode): boolean {
+  const action = nodeRegistry.get(node.type)?.keyboardActions?.e
+  if (action?.appliesTo(node)) {
+    action.run(node)
+    return true
+  }
+  return toggleNodeMechanism(node)
+}
+
 export const useKeyboard = ({
   isVersionPreviewMode = false,
   disabled = false,
@@ -290,7 +358,12 @@ export const useKeyboard = ({
         return
       }
 
-      if (e.key === 'Shift' && !e.repeat && useEditor.getState().mode === 'material-paint') {
+      if (
+        e.key === 'Shift' &&
+        !e.repeat &&
+        useEditor.getState().mode === 'material-paint' &&
+        !paintRegionModeActive('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.
@@ -342,7 +415,10 @@ export const useKeyboard = ({
           const current = useEditor.getState().getContinuation('fence')
           useEditor
             .getState()
-            .setContinuation('fence', current === 'curved' ? 'continuous' : 'curved')
+            .setContinuation(
+              'fence',
+              current === 'curved' ? 'freehand' : current === 'freehand' ? 'continuous' : 'curved',
+            )
           sfxEmitter.emit('sfx:grid-snap')
           return
         }
@@ -356,12 +432,13 @@ export const useKeyboard = ({
         !e.shiftKey &&
         !e.altKey
       ) {
-        const context = getActiveContinuationContext()
+        // The wall's drawing mode is picked in the Build panel, not cycled here.
+        const context = keyCyclableContinuationContext(getActiveContinuationContext())
         if (context) {
           e.preventDefault()
           if (context === 'fence') {
             const current = useEditor.getState().getContinuation('fence')
-            if (current !== 'curved') {
+            if (current !== 'curved' && current !== 'freehand') {
               useEditor
                 .getState()
                 .setContinuation('fence', current === 'single' ? 'continuous' : 'single')
@@ -385,46 +462,24 @@ export const useKeyboard = ({
           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) {
-          if (leaveUnitFocus()) useEditor.getState().armToolMode({ mode: 'select' })
-          else exitToSelectAfterUnconsumedCancel()
-        }
-      } else if (e.key === '1' && !e.metaKey && !e.ctrlKey) {
-        e.preventDefault()
-        useEditor.getState().setPhase('site')
-        useEditor.getState().armToolMode({ mode: 'select' })
-      } else if (e.key === '2' && !e.metaKey && !e.ctrlKey) {
-        e.preventDefault()
-        useEditor.getState().setPhase('structure')
-        useEditor.getState().armToolMode({ mode: 'select' })
-      } else if (e.key === '3' && !e.metaKey && !e.ctrlKey) {
+        cancelActiveTool()
+      } else if (!e.metaKey && !e.ctrlKey && switchPhaseFromShortcut(e.key)) {
         e.preventDefault()
-        useEditor.getState().setPhase('furnish')
-        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().armToolMode({ mode: 'build', tool: 'item' })
-        useEditor.getState().setActiveSidebarPanel('items')
+        openItemCatalogFromShortcut()
       } else if (e.key === 'z' && !e.metaKey && !e.ctrlKey) {
         if (isVersionPreviewMode) return
         e.preventDefault()
-        useEditor.getState().setPhase('structure')
-        useEditor.getState().setStructureLayer('zones')
         useEditor.getState().armToolMode({ mode: 'build', tool: '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.armToolMode({ mode: 'build', tool: 'measurement' })
       }
@@ -435,9 +490,7 @@ export const useKeyboard = ({
       } else if (e.key === 'b' && !e.metaKey && !e.ctrlKey) {
         if (isVersionPreviewMode) return
         e.preventDefault()
-        useEditor.getState().setPhase('structure')
-        useEditor.getState().setStructureLayer('elements')
-        useEditor.getState().armToolMode({ mode: 'build', tool: 'wall' })
+        armWallToolFromShortcut()
       } else if (e.key === 'x' && !e.metaKey && !e.ctrlKey) {
         if (isVersionPreviewMode) return
         e.preventDefault()
@@ -445,9 +498,7 @@ export const useKeyboard = ({
       } else if (e.key === 'p' && !e.metaKey && !e.ctrlKey) {
         if (isVersionPreviewMode) return
         e.preventDefault()
-        useEditor.getState().setPhase('structure')
-        useEditor.getState().setStructureLayer('elements')
-        useEditor.getState().armMaterialPaint()
+        armPaintFromShortcut()
       } else if (e.key === 'g' && !e.metaKey && !e.ctrlKey) {
         if (isVersionPreviewMode) return
         e.preventDefault()
@@ -679,34 +730,14 @@ export const useKeyboard = ({
           }
         }
       } 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).
+        // E runs the kind's interaction or mechanism (doors and windows open and
+        // close). 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)) {
+          if (node && runNodeInteraction(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' &&
-            (node.windowType === 'sliding' ||
-              node.windowType === 'casement' ||
-              node.windowType === 'awning' ||
-              node.windowType === 'hopper' ||
-              node.windowType === 'single-hung' ||
-              node.windowType === 'double-hung' ||
-              node.windowType === 'louvered')
-          ) {
-            e.preventDefault()
-            toggleWindowOpenState(node.id)
             sfxEmitter.emit('sfx:item-rotate')
           }
         }