@pascal-app/editor 1.0.0 → 1.0.3

package/src/hooks/use-auto-save.integration.test.tsx

@@ -0,0 +1,197 @@
+import { afterEach, expect, test } from 'bun:test'
+import {
+  BuildingNode,
+  ColumnNode,
+  clearSceneHistory,
+  LevelNode,
+  SiteNode,
+  useScene,
+} from '@pascal-app/core'
+import { create } from '@react-three/test-renderer'
+import { type SaveStatus, useAutoSave } from './use-auto-save'
+
+const originalWindow = globalThis.window
+const previousScene = useScene.getState()
+let renderer: Awaited<ReturnType<typeof create>> | undefined
+
+afterEach(async () => {
+  await renderer?.unmount()
+  renderer = undefined
+  globalThis.window = originalWindow
+  useScene.setState(previousScene, true)
+  clearSceneHistory()
+})
+
+function graph(count: number) {
+  if (count === 0) return { nodes: {}, rootNodeIds: [] }
+  const columns = Array.from({ length: count - 3 }, (_, index) =>
+    ColumnNode.parse({ id: `column_autosave_${index}`, parentId: 'level_autosave' }),
+  )
+  const level = LevelNode.parse({
+    id: 'level_autosave',
+    parentId: 'building_autosave',
+    children: columns.map((node) => node.id),
+  })
+  const building = BuildingNode.parse({
+    id: 'building_autosave',
+    parentId: 'site_autosave',
+    children: [level.id],
+  })
+  const site = SiteNode.parse({ id: 'site_autosave', children: [building.id] })
+  const nodes = [site, building, level, ...columns]
+  return { nodes: Object.fromEntries(nodes.map((node) => [node.id, node])), rootNodeIds: [site.id] }
+}
+
+async function mount(
+  loadedCount: number,
+  guardAgainstSceneWipe?: boolean,
+  save?: () => Promise<void>,
+) {
+  globalThis.window = new EventTarget() as unknown as Window & typeof globalThis
+  useScene.setState({ ...graph(0), readOnly: false })
+  clearSceneHistory()
+  const writes: number[] = []
+  const statuses: SaveStatus[] = []
+  let controls: ReturnType<typeof useAutoSave> | undefined
+  function Host(props: { guardAgainstSceneWipe?: boolean; isVersionPreviewMode?: boolean }) {
+    controls = useAutoSave({
+      ...props,
+      onSave: async (scene) => {
+        writes.push(Object.keys(scene.nodes).length)
+        await save?.()
+      },
+      onSaveStatusChange: (status) => statuses.push(status),
+    })
+    return null
+  }
+  renderer = await create(<Host guardAgainstSceneWipe={guardAgainstSceneWipe} />)
+  useScene.setState(graph(loadedCount))
+  clearSceneHistory()
+  controls!.isLoadingSceneRef.current = false
+  statuses.length = 0
+  return {
+    writes,
+    statuses,
+    controls: controls!,
+    update: (props: { guardAgainstSceneWipe?: boolean; isVersionPreviewMode?: boolean }) =>
+      renderer!.update(<Host {...props} />),
+  }
+}
+
+test.each([
+  'undo',
+  'redo',
+  'delete',
+] as const)('autosave permits a 5 to 4 single-node %s', async (action) => {
+  const { writes, statuses } = await mount(5)
+  if (action === 'undo') {
+    useScene.setState(graph(4))
+    clearSceneHistory()
+    useScene.setState(graph(5))
+    useScene.temporal.getState().undo()
+  } else if (action === 'redo') {
+    useScene.getState().deleteNode('column_autosave_1')
+    useScene.temporal.getState().undo()
+    useScene.temporal.getState().redo()
+  } else {
+    useScene.getState().deleteNode('column_autosave_1')
+  }
+  expect(Object.keys(useScene.getState().nodes)).toHaveLength(4)
+  await Bun.sleep(1100)
+  expect(statuses).not.toContain('error')
+  expect(writes).toEqual([4])
+  expect(statuses.at(-1)).toBe('saved')
+})
+
+test('autosave permits a single-node deletion on exit', async () => {
+  const { writes, statuses } = await mount(5)
+  useScene.getState().deleteNode('column_autosave_1')
+  window.dispatchEvent(new Event('pagehide'))
+  expect(statuses).not.toContain('error')
+  expect(writes).toEqual([4])
+})
+
+test('autosave blocks a full wipe and resumes after an allowed edit', async () => {
+  const { writes, statuses, controls } = await mount(78)
+  useScene.setState(graph(4))
+  controls.saveNow()
+  window.dispatchEvent(new Event('pagehide'))
+  expect(statuses).toContain('error')
+  expect(writes).toEqual([])
+  useScene.setState(graph(5))
+  controls.saveNow()
+  await Bun.sleep(0)
+  expect(writes).toEqual([5])
+  expect(statuses.at(-1)).toBe('saved')
+})
+
+test('collaboration scaffold deletion waits for persistence and reports saved', async () => {
+  const idle = Promise.withResolvers<void>()
+  const { writes, statuses } = await mount(78, false, () => idle.promise)
+  useScene.setState(graph(4))
+  await Bun.sleep(1100)
+  expect(statuses).not.toContain('error')
+  expect(writes).toEqual([4])
+  expect(statuses).toEqual(['pending', 'saving'])
+  idle.resolve()
+  await Bun.sleep(0)
+  expect(statuses).toEqual(['pending', 'saving', 'saved'])
+})
+
+test.each([
+  'pagehide',
+  'unmount',
+])('collaboration scaffold deletion still flushes on %s', async (event) => {
+  const { writes, statuses } = await mount(78, false)
+  useScene.setState(graph(4))
+  if (event === 'pagehide') window.dispatchEvent(new Event(event))
+  else {
+    await renderer!.unmount()
+    renderer = undefined
+  }
+  expect(statuses).not.toContain('error')
+  expect(writes).toEqual([4])
+})
+
+test('collaboration guard exemption preserves preview pause and resume', async () => {
+  const { writes, statuses, update } = await mount(78, false)
+  useScene.setState(graph(4))
+  await update({ guardAgainstSceneWipe: false, isVersionPreviewMode: true })
+  expect(statuses.at(-1)).toBe('paused')
+  await Bun.sleep(1100)
+  expect(writes).toEqual([])
+  await update({ guardAgainstSceneWipe: false, isVersionPreviewMode: false })
+  await Bun.sleep(1100)
+  expect(writes).toEqual([4])
+  expect(statuses.at(-1)).toBe('saved')
+  expect(statuses).not.toContain('error')
+})
+
+test('changing guard ownership recovers an error and keeps the new stored baseline', async () => {
+  const { writes, statuses, controls, update } = await mount(78)
+  useScene.setState(graph(4))
+  controls.saveNow()
+  expect(statuses.at(-1)).toBe('error')
+  await update({ guardAgainstSceneWipe: false })
+  controls.saveNow()
+  await Bun.sleep(0)
+  expect(writes).toEqual([4])
+  expect(statuses.at(-1)).toBe('saved')
+  await update({ guardAgainstSceneWipe: true })
+  useScene.setState(graph(3))
+  controls.saveNow()
+  await Bun.sleep(0)
+  expect(writes).toEqual([4, 3])
+  expect(statuses.at(-1)).toBe('saved')
+})
+
+test('collaboration callback failures still report error', async () => {
+  const { writes, statuses, controls } = await mount(78, false, async () => {
+    throw new Error('Collaboration failed')
+  })
+  useScene.setState(graph(4))
+  controls.saveNow()
+  await Bun.sleep(0)
+  expect(writes).toEqual([4])
+  expect(statuses).toEqual(['pending', 'saving', 'error'])
+})

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

@@ -8,7 +8,11 @@ const AUTOSAVE_DEBOUNCE_MS = 1000
 const STRUCTURAL_NODE_COUNT = 4
 
 export function isSuspiciousNodeDrop(previousNodeCount: number, currentNodeCount: number) {
-  return previousNodeCount > STRUCTURAL_NODE_COUNT && currentNodeCount <= STRUCTURAL_NODE_COUNT
+  return (
+    previousNodeCount > STRUCTURAL_NODE_COUNT &&
+    currentNodeCount <= STRUCTURAL_NODE_COUNT &&
+    previousNodeCount - currentNodeCount > 1
+  )
 }
 
 /**
@@ -37,8 +41,8 @@ export function createStoredNodeCountTracker(initialNodeCount: number) {
      * which is an accidental full deletion far more often than an intent. The
      * caller reports the block; on `true` the write becomes the new baseline.
      */
-    allowWrite(nodeCount: number) {
-      if (isSuspiciousNodeDrop(count, nodeCount)) return false
+    allowWrite(nodeCount: number, guardAgainstSceneWipe = true) {
+      if (guardAgainstSceneWipe && isSuspiciousNodeDrop(count, nodeCount)) return false
       count = nodeCount
       return true
     },
@@ -65,10 +69,14 @@ export function decideExitFlush(opts: {
   hasDirtyChanges: boolean
   storedNodeCount: number
   currentNodeCount: number
+  guardAgainstSceneWipe?: boolean
 }): ExitFlushDecision {
   if (!opts.hasDirtyChanges) return 'skip-clean'
   if (opts.isLoadingScene) return 'skip-loading'
-  if (isSuspiciousNodeDrop(opts.storedNodeCount, opts.currentNodeCount)) {
+  if (
+    opts.guardAgainstSceneWipe !== false &&
+    isSuspiciousNodeDrop(opts.storedNodeCount, opts.currentNodeCount)
+  ) {
     return 'blocked-suspicious'
   }
   return 'flush'
@@ -77,6 +85,7 @@ export function decideExitFlush(opts: {
 export type SaveStatus = 'idle' | 'pending' | 'saving' | 'saved' | 'paused' | 'error'
 
 interface UseAutoSaveOptions {
+  guardAgainstSceneWipe?: boolean
   onSave?: (scene: SceneGraph, options?: { keepalive?: boolean }) => Promise<void>
   onDirty?: () => void
   onSaveStatusChange?: (status: SaveStatus) => void
@@ -90,6 +99,7 @@ interface UseAutoSaveOptions {
  * ⚠️  Mount in exactly ONE component (the Editor).
  */
 export function useAutoSave({
+  guardAgainstSceneWipe = true,
   onSave,
   onDirty,
   onSaveStatusChange,
@@ -116,6 +126,7 @@ export function useAutoSave({
   const onDirtyRef = useRef(onDirty)
   const onSaveStatusChangeRef = useRef(onSaveStatusChange)
   const isVersionPreviewModeRef = useRef(isVersionPreviewMode)
+  const guardAgainstSceneWipeRef = useRef(guardAgainstSceneWipe)
 
   useEffect(() => {
     onSaveRef.current = onSave
@@ -129,6 +140,9 @@ export function useAutoSave({
   useEffect(() => {
     isVersionPreviewModeRef.current = isVersionPreviewMode
   }, [isVersionPreviewMode])
+  useEffect(() => {
+    guardAgainstSceneWipeRef.current = guardAgainstSceneWipe
+  }, [guardAgainstSceneWipe])
 
   const setSaveStatus = useCallback((status: SaveStatus) => {
     onSaveStatusChangeRef.current?.(status)
@@ -166,7 +180,7 @@ export function useAutoSave({
 
       const currentNodeCount = Object.keys(nodes).length
       const previousNodeCount = storedNodeCount.count
-      if (!storedNodeCount.allowWrite(currentNodeCount)) {
+      if (!storedNodeCount.allowWrite(currentNodeCount, guardAgainstSceneWipeRef.current)) {
         console.warn(
           `[autosave] Blocked: scene dropped from ${previousNodeCount} to ${currentNodeCount} nodes. Likely accidental deletion.`,
         )
@@ -266,6 +280,7 @@ export function useAutoSave({
         hasDirtyChanges: hasDirtyChangesRef.current,
         storedNodeCount: previousNodeCount,
         currentNodeCount,
+        guardAgainstSceneWipe: guardAgainstSceneWipeRef.current,
       })
       if (decision === 'skip-clean') return
       if (decision === 'skip-loading') {
@@ -282,7 +297,7 @@ export function useAutoSave({
         return
       }
       // 'flush' — adopt the write as the new stored baseline.
-      storedNodeCount.allowWrite(currentNodeCount)
+      storedNodeCount.allowWrite(currentNodeCount, guardAgainstSceneWipeRef.current)
 
       hasDirtyChangesRef.current = false
       const sceneGraph = {

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

@@ -7,6 +7,7 @@ import {
   sceneRegistry,
   useScene,
 } from '@pascal-app/core'
+import { ProceduralItemNode, shelfRecipe } from '@pascal-app/core/procedural-items'
 import { hideFromScene, showInScene, useViewer } from '@pascal-app/viewer'
 import { _roots, act, createRoot } from '@react-three/fiber'
 import { createElement } from 'react'
@@ -18,11 +19,16 @@ import {
   type WebGLRenderer,
 } from 'three'
 import useEditor from '../store/use-editor'
+import useInteractionScope from '../store/use-interaction-scope'
 import { useCeilingEvents } from './use-ceiling-events'
 
-test('ceiling-item placement keeps move and commit hits while an unhovered ceiling is batched', async () => {
+test.each([
+  'item',
+  'procedural-item',
+])('%s ceiling placement keeps move and commit hits while an unhovered ceiling is batched', async (kind) => {
   const previousViewer = useViewer.getState()
   const previousEditor = useEditor.getState()
+  const previousInteraction = useInteractionScope.getState()
   const previousScene = useScene.getState()
   const actGlobal = globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }
   const previousAct = actGlobal.IS_REACT_ACT_ENVIRONMENT
@@ -73,13 +79,29 @@ test('ceiling-item placement keeps move and commit hits while an unhovered ceili
       cameraDragging: false,
       selection: { buildingId: null, levelId: level.id, zoneId: null, selectedIds: [] },
     })
-    useEditor.setState({ selectedItem: { attachTo: 'ceiling' } as never })
+    if (kind === 'item') useEditor.setState({ selectedItem: { attachTo: 'ceiling' } as never })
+    else {
+      useEditor.setState({ selectedItem: null })
+      useEditor.getState().setMovingNode(
+        ProceduralItemNode.parse({
+          recipe: {
+            ...shelfRecipe,
+            mounting: { attachTo: 'ceiling', reference: 'top' },
+            surfaces: [
+              { id: 'top', label: 'Top', position: [0, 'height', 0], size: ['width', 'depth'] },
+            ],
+          },
+          parentId: ceiling.id,
+        }) as never,
+      )
+    }
     await root.configure({
       gl: {
         domElement: canvas,
         render() {},
         setSize() {},
         setPixelRatio() {},
+        xr: { isPresenting: false },
       } as unknown as WebGLRenderer,
       camera,
       frameloop: 'never',
@@ -116,6 +138,7 @@ test('ceiling-item placement keeps move and commit hits while an unhovered ceili
     surface.material.dispose()
     useScene.setState(previousScene)
     useEditor.setState(previousEditor)
+    useInteractionScope.setState(previousInteraction)
     useViewer.setState(previousViewer)
     actGlobal.IS_REACT_ACT_ENVIRONMENT = previousAct
   }

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

@@ -7,6 +7,7 @@ import {
   sceneRegistry,
   useScene,
 } from '@pascal-app/core'
+import { isProceduralItem } from '@pascal-app/core/procedural-items'
 import { useViewer } from '@pascal-app/viewer'
 import { useThree } from '@react-three/fiber'
 import { useEffect, useRef } from 'react'
@@ -55,13 +56,18 @@ 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 => {
       const ed = useEditor.getState()
       if (ed.selectedItem?.attachTo === 'ceiling') return true
       const moving = getMovingNode()
-      return moving?.type === 'item' && moving.asset?.attachTo === 'ceiling'
+      return (
+        (moving?.type === 'item' && moving.asset?.attachTo === 'ceiling') ||
+        (isProceduralItem(moving) && moving.recipe.mounting?.attachTo === 'ceiling')
+      )
     }
 
     type Hit = { node: CeilingNode; mesh: Object3D; world: Vector3; local: Vector3 }

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

@@ -106,6 +106,13 @@ describe('rotation shortcut ownership', () => {
     expect(isToolOwnedRotation()).toBe(true)
   })
 
+  test('leaves R to the wall tool for its line / rectangle toggle, but not T', () => {
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'wall' })
+
+    expect(isToolOwnedRotation('r')).toBe(true)
+    expect(isToolOwnedRotation('t')).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({

package/src/hooks/use-keyboard.ts

@@ -9,7 +9,6 @@ import {
 } from '@pascal-app/core'
 import { cancelPerfAction, markPerfAction, useViewer } from '@pascal-app/viewer'
 import { useEffect } from 'react'
-import { Vector3 } from 'three'
 import {
   cutSelectionToEditorClipboard,
   deleteSelection,
@@ -18,9 +17,9 @@ import {
 import {
   classifyParticipant,
   collectParticipants,
-  computeGroupBox,
-  expandToComponent,
+  groupPlanBounds,
   levelFrame,
+  planBoundsCenter,
   rotateGroupPatches,
 } from '../components/editor/group-transform-shared'
 import { steppedRotation } from '../components/tools/item/placement-math'
@@ -32,10 +31,14 @@ import { isActive } from '../lib/interaction/scope'
 import { copySelectedNodesToEditorClipboard } from '../lib/scene-clipboard'
 import { sfxEmitter } from '../lib/sfx-bus'
 import { activeSiteNode, clampBrushRadius } from '../lib/terrain-sculpt'
+import { leaveUnitFocus } from '../lib/units'
 import { toggleWindowOpenState } from '../lib/window-interaction'
 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
@@ -65,27 +68,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()
@@ -115,7 +111,13 @@ const exitToSelectAfterUnconsumedCancel = () => {
   const currentPhase = useEditor.getState().phase
   const currentStructureLayer = useEditor.getState().structureLayer
 
-  useInteractionScope.getState().endIf((sc) => sc.kind === 'reshaping' && sc.reshape === 'hole')
+  useInteractionScope
+    .getState()
+    .endIf(
+      (sc) =>
+        (sc.kind === 'placing' && isInteractionSubtreeDraft()) ||
+        (sc.kind === 'reshaping' && sc.reshape === 'hole'),
+    )
 
   // From zone mode, return to structure select
   if (currentPhase === 'structure' && currentStructureLayer === 'zones') {
@@ -133,6 +135,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
@@ -175,7 +191,8 @@ export const runHistoryShortcut = (direction: 'undo' | 'redo') => {
   return true
 }
 
-export const isToolOwnedRotation = () => {
+/** Whether an armed tool owns the rotation key (`R` or `T`) instead of the selection. */
+export const isToolOwnedRotation = (key: 'r' | 't' = 'r') => {
   const editor = useEditor.getState()
   const moving = getMovingNode()
   if (
@@ -195,7 +212,10 @@ export const isToolOwnedRotation = () => {
       // 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')
+      editor.tool === 'lean-to-extension' ||
+      // R toggles the wall tool between line and rectangle drawing; T stays
+      // the selection's.
+      (editor.tool === 'wall' && key === 'r'))
   )
 }
 
@@ -384,14 +404,9 @@ 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) {
-          exitToSelectAfterUnconsumedCancel()
-        }
+        cancelActiveTool()
       } else if (e.key === '1' && !e.metaKey && !e.ctrlKey) {
         e.preventDefault()
         useEditor.getState().setPhase('site')
@@ -617,7 +632,7 @@ export const useKeyboard = ({
       } else if (
         (e.key === 't' || e.key === 'T') &&
         !isVersionPreviewMode &&
-        !isToolOwnedRotation() &&
+        !isToolOwnedRotation('t') &&
         canRunGlobalRotationShortcut()
       ) {
         // Rotate selected node counter-clockwise