@pascal-app/editor 1.0.3 → 1.0.5

package/src/components/tools/registry/move-registry-node-tool.test.ts

@@ -1,4 +1,12 @@
-import { expect, test } from 'bun:test'
+import { expect, jest, test } from 'bun:test'
+import type {
+  AnyNode,
+  AnyNodeDefinition,
+  AnyNodeId,
+  BuildingNode,
+  LevelNode,
+} from '@pascal-app/core'
+import type { Catalogue } from '@react-three/fiber'
 import { resolveMoveRotationStep } from './move-registry-node-tool'
 
 test('applies a free rotation step while the move is unattached', () => {
@@ -8,3 +16,262 @@ test('applies a free rotation step while the move is unattached', () => {
 test('rejects rotation steps while the move is wall-attached', () => {
   expect(resolveMoveRotationStep(0.5, 0.25, Math.PI / 2)).toBeNull()
 })
+
+// Contract-derived controller regression, not a helper replay: editable keys
+// leave a live move alone; outside R/T and Alt still affect the real controller.
+// R3F reconciles real Three objects with a rendererless context. No drawing,
+// native typing, canvas hit-testing or GPU evidence is claimed by this test.
+test('focus completion: mounted registry mover owns only outside R T and Alt', async () => {
+  const core = await import('@pascal-app/core')
+  const { useViewer } = await import('@pascal-app/viewer')
+  const { createRoot, extend } = await import('@react-three/fiber')
+  const { act, createElement } = await import('react')
+  const three = await import('three')
+  const { z } = await import('zod')
+  const { MoveRegistryNodeTool } = await import('./move-registry-node-tool')
+  const { default: useEditor } = await import('../../../store/use-editor')
+  const { default: useInteractionScope } = await import('../../../store/use-interaction-scope')
+  const { default: useAlignmentGuides } = await import('../../../store/use-alignment-guides')
+  const { default: useFacingPose } = await import('../../../store/use-facing-pose')
+  const { default: usePlacementPreview } = await import('../../../store/use-placement-preview')
+  const globals = [
+    'window',
+    'document',
+    'requestAnimationFrame',
+    'cancelAnimationFrame',
+    'IS_REACT_ACT_ENVIRONMENT',
+  ] as const
+  const descriptors = globals.map((key) => Object.getOwnPropertyDescriptor(globalThis, key))
+  const stores = [
+    core.useScene,
+    core.useScene.temporal,
+    useViewer,
+    useEditor,
+    useInteractionScope,
+    core.useLiveTransforms,
+    core.useLiveNodeOverrides,
+    useAlignmentGuides,
+    useFacingPose,
+    usePlacementPreview,
+  ]
+  const originalStates = stores.map((store) => store.getState())
+  const restoreRegistry = core.nodeRegistry._snapshot()
+  const sceneObjects = new Map(core.sceneRegistry.nodes)
+  const frames = new Map<number, FrameRequestCallback>()
+  let nextFrame = 0
+  let time = 0
+  const flushFrames = () => {
+    const pending = [...frames.values()]
+    frames.clear()
+    for (const callback of pending) {
+      time += 16
+      callback(time)
+    }
+  }
+  let root: ReturnType<typeof createRoot> | undefined
+  let mountedScene: import('three').Scene | undefined
+  const mesh = new three.Mesh(new three.BoxGeometry(1, 1, 1), new three.MeshBasicMaterial())
+  const id = 'completion_registry' as AnyNodeId
+  const buildingId = 'building_completion_registry' as BuildingNode['id']
+  const levelId = 'level_completion_registry' as LevelNode['id']
+  const node = {
+    id,
+    type: 'completion:registry',
+    object: 'node',
+    parentId: levelId,
+    children: [],
+    metadata: {},
+    visible: true,
+    position: [2, 0, 3],
+    rotation: 0.25,
+  } as unknown as AnyNode
+  jest.useFakeTimers()
+  try {
+    const target = new EventTarget()
+    const documentFixture = { body: { style: { cursor: '' } }, querySelector: () => null }
+    Object.defineProperties(globalThis, {
+      window: {
+        configurable: true,
+        value: Object.assign(target, {
+          matchMedia: () => Object.assign(new EventTarget(), { matches: false }),
+        }),
+      },
+      document: { configurable: true, value: documentFixture },
+      requestAnimationFrame: {
+        configurable: true,
+        value: (callback: FrameRequestCallback) => {
+          frames.set(++nextFrame, callback)
+          return nextFrame
+        },
+      },
+      cancelAnimationFrame: { configurable: true, value: (key: number) => frames.delete(key) },
+      IS_REACT_ACT_ENVIRONMENT: { configurable: true, value: true },
+    })
+    core.registerNode({
+      kind: node.type,
+      schemaVersion: 1,
+      category: 'utility',
+      schema: z.object({ type: z.literal(node.type) }).passthrough(),
+      defaults: () => ({}),
+      capabilities: {
+        movable: { isValidPosition: () => false },
+        floorPlaced: {
+          collides: true,
+          footprint: (candidate: AnyNode) => ({
+            dimensions: [1, 1, 1],
+            rotation: [0, (candidate as unknown as { rotation: number }).rotation, 0],
+          }),
+        },
+      },
+    } as unknown as AnyNodeDefinition)
+    core.useScene.temporal.getState().pause()
+    // Placement validity is level-scoped. Without a real selected level the
+    // mover deliberately treats placement as valid before consulting the kind.
+    core.useScene.setState({
+      nodes: {
+        [buildingId]: {
+          id: buildingId,
+          type: 'building',
+          parentId: null,
+          children: [levelId],
+          position: [0, 0, 0],
+          rotation: 0,
+        } as unknown as AnyNode,
+        [levelId]: {
+          id: levelId,
+          type: 'level',
+          parentId: buildingId,
+          children: [id],
+          elevation: 0,
+          height: 3,
+        } as unknown as AnyNode,
+        [id]: node,
+      },
+      rootNodeIds: [buildingId],
+    })
+    core.useScene.temporal.getState().resume()
+    core.clearSceneHistory()
+    core.useScene.getState().updateNode(id, { name: 'history sentinel' } as never)
+    flushFrames()
+    useViewer.getState().setSelection({ selectedIds: [id], levelId, buildingId, zoneId: null })
+    useEditor.setState({ mode: 'select', tool: null })
+    useEditor.getState().setMovingNode(core.useScene.getState().nodes[id]!)
+    mesh.position.set(2, 0, 3)
+    mesh.rotation.y = 0.25
+    core.sceneRegistry.nodes.set(id, mesh)
+    extend(three as unknown as Catalogue)
+    // Supplying a renderer-shaped context prevents WebGLRenderer construction.
+    // Drawing is a hard failure, never a stub returning fake pixels.
+    const gl = {
+      render: () => {
+        throw new Error('CPU controller acceptance must not render')
+      },
+      setSize: () => {},
+      setPixelRatio: () => {},
+      domElement: {},
+    }
+    root = createRoot({} as HTMLCanvasElement)
+    await root.configure({
+      gl: gl as never,
+      frameloop: 'never',
+      size: { width: 300, height: 300, top: 0, left: 0 },
+      onCreated: (state) => {
+        mountedScene = state.scene
+      },
+    })
+    await act(async () => {
+      root!.render(
+        createElement(MoveRegistryNodeTool, { node: core.useScene.getState().nodes[id]! }),
+      )
+    })
+    const colours = () => {
+      const result: number[] = []
+      mountedScene!.traverse((object) => {
+        const material = (object as import('three').Mesh).material
+        for (const entry of Array.isArray(material) ? material : [material]) {
+          if (entry && 'color' in entry)
+            result.push((entry.color as import('three').Color).getHex())
+        }
+      })
+      return result.sort()
+    }
+    const snapshot = () =>
+      JSON.parse(
+        JSON.stringify({
+          nodes: core.useScene.getState().nodes,
+          live: [...core.useLiveTransforms.getState().transforms],
+          overrides: [...core.useLiveNodeOverrides.getState().overrides],
+          scope: useInteractionScope.getState().scope,
+          history: {
+            past: core.useScene.temporal.getState().pastStates,
+            future: core.useScene.temporal.getState().futureStates,
+            tracking: core.useScene.temporal.getState().isTracking,
+            pauseDepth: core.getSceneHistoryPauseDepth(),
+          },
+          pose: { position: mesh.position.toArray(), rotation: mesh.rotation.y },
+          colours: colours(),
+        }),
+      )
+    const key = async (value: string, editable: boolean, type = 'keydown') => {
+      const event = new Event(type, { cancelable: true })
+      Object.defineProperties(event, {
+        key: { value },
+        target: {
+          value: editable
+            ? { tagName: 'TEXTAREA', closest: () => ({ tagName: 'TEXTAREA' }) }
+            : target,
+        },
+        altKey: { value: value === 'Alt' },
+        ctrlKey: { value: false },
+        metaKey: { value: false },
+      })
+      await act(async () => {
+        target.dispatchEvent(event)
+        flushFrames()
+      })
+      return event
+    }
+    expect((await key('r', false)).defaultPrevented).toBe(true)
+    expect(mesh.rotation.y).toBeCloseTo(0.25 + Math.PI / 4)
+    expect(colours()).toContain(0xef4444)
+    const before = snapshot()
+    expect(before.live.length).toBeGreaterThan(0)
+    expect(before.history.past.length).toBeGreaterThan(0)
+    expect(before.history.tracking).toBe(false)
+    expect(before.scope.kind).toBe('moving')
+    for (const value of ['r', 't', 'Alt']) {
+      expect((await key(value, true)).defaultPrevented).toBe(false)
+      expect(snapshot()).toEqual(before)
+    }
+    // Key-up reset remains active even if focus moved into a field.
+    await key('Alt', false)
+    expect(colours()).toContain(0x22c55e)
+    await key('Alt', true, 'keyup')
+    expect(colours()).toContain(0xef4444)
+    expect((await key('t', false)).defaultPrevented).toBe(true)
+    expect(mesh.rotation.y).toBeCloseTo(0.25)
+    expect(core.useLiveTransforms.getState().transforms.get(id)?.rotation).toBeCloseTo(0.25)
+  } finally {
+    if (root)
+      await act(async () => {
+        root!.unmount()
+      })
+    // R3F's delayed disposal is advanced, not slept through, before globals go.
+    jest.runOnlyPendingTimers()
+    frames.clear()
+    restoreRegistry()
+    core.sceneRegistry.nodes.clear()
+    for (const [key, value] of sceneObjects) core.sceneRegistry.nodes.set(key, value)
+    stores.forEach((store, index) => {
+      ;(store.setState as (snapshot: unknown, replace: true) => void)(originalStates[index], true)
+    })
+    mesh.geometry.dispose()
+    mesh.material.dispose()
+    jest.useRealTimers()
+    globals.forEach((key, index) => {
+      const descriptor = descriptors[index]
+      if (descriptor) Object.defineProperty(globalThis, key, descriptor)
+      else Reflect.deleteProperty(globalThis, key)
+    })
+  }
+}, 15_000)

package/src/components/tools/registry/move-registry-node-tool.tsx

@@ -13,9 +13,11 @@ import {
   createSceneApi,
   emitter,
   findLevelAncestorId,
+  floorPlacedCollides,
   footprintAABBFrom,
   type GridEvent,
   type GroupMoveSnapResult,
+  getFloorPlacedElevation,
   getFloorPlacedFootprints,
   type MovableConfig,
   movingFootprintAnchors,
@@ -59,6 +61,7 @@ import {
   surfaceAttachmentUpdates,
   updateSurfaceNode,
 } from '../../../lib/surface-attachment'
+import { isTypingTarget } from '../../../lib/typing-target'
 import useAlignmentGuides from '../../../store/use-alignment-guides'
 import useEditor, {
   getActiveSnappingMode,
@@ -340,7 +343,8 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
   // position isn't in the level frame the spatial grid indexes. They may
   // still provide a parent-frame collision check and use the same bounds box.
   const collides =
-    !frameParent && nodeRegistry.get(node.type)?.capabilities?.floorPlaced?.collides === true
+    !frameParent &&
+    floorPlacedCollides(nodeRegistry.get(node.type)?.capabilities?.floorPlaced, node)
   // Snapshot the scene once at drag-start — bounds depend on `node` (locked
   // for the lifetime of this tool) and any sibling state the kind reads. If a
   // future kind needs live sibling state mid-drag, switch to a subscribed
@@ -414,6 +418,9 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
   const [cursorRotationY, setCursorRotationY] = useState(() => previewRotationY(originalRotationY))
   const { isFreshPlacement, previewVisible, revealFreshPlacement, useAbsoluteCursorPlacement } =
     useFreshPlacementVisibility({ node })
+  const preserveLevelAndElevation =
+    !isFreshPlacement &&
+    nodeRegistry.get(node.type)?.capabilities?.movable?.preserveLevelAndElevation === true
   // Kinds that declare `movable.cursorAttached` (duct fittings) pin to the
   // cursor instead of preserving the grab offset — small connector-like
   // nodes read an offset drag as "lagging behind the mouse".
@@ -477,7 +484,24 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
       return Array.isArray(rotation) ? [rotation[0] ?? 0, y, rotation[2] ?? 0] : y
     }
 
+    const keepStartingElevation = (position: [number, number, number], yaw: number) => {
+      if (!preserveLevelAndElevation) return position
+      const rotation = toCommitRotation(yaw)
+      const currentNodes = useScene.getState().nodes
+      const effectiveNode = { ...node, position, rotation } as AnyNode
+      const lift = getFloorPlacedElevation({
+        node: effectiveNode,
+        nodes: { ...currentNodes, [node.id]: effectiveNode },
+        position,
+        rotation,
+      })
+      return [position[0], originalPlanPosition[1] - lift, position[2]] as [number, number, number]
+    }
+
     const currentLevelId = () =>
+      (preserveLevelAndElevation
+        ? findLevelAncestorId(node.id, useScene.getState().nodes)
+        : null) ??
       useViewer.getState().selection.levelId ??
       (itemSurfaceMove ? findLevelAncestorId(node.id, useScene.getState().nodes) : node.parentId)
 
@@ -803,10 +827,14 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
       // test are plane-height independent, so the elected surface is a
       // single fixed point per pointer ray.
       const pointed = resolvePointerSupportSurface(cameraRef.current, event.position)
-      supportCapRef.current = pointed?.elevation ?? null
-      supportSurfaceRef.current = pointed
-      const rawX = pointed?.localPoint?.[0] ?? event.localPosition[0]
-      const rawZ = pointed?.localPoint?.[2] ?? event.localPosition[2]
+      supportCapRef.current = preserveLevelAndElevation ? null : (pointed?.elevation ?? null)
+      supportSurfaceRef.current = preserveLevelAndElevation ? null : pointed
+      const rawX = preserveLevelAndElevation
+        ? event.localPosition[0]
+        : (pointed?.localPoint?.[0] ?? event.localPosition[0])
+      const rawZ = preserveLevelAndElevation
+        ? event.localPosition[2]
+        : (pointed?.localPoint?.[2] ?? event.localPosition[2])
       revealFreshPlacement()
 
       const magnetic = isMagneticSnapActive()
@@ -980,7 +1008,7 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
           if (guides.length > 0) useAlignmentGuides.getState().set(guides)
         }
       }
-      if (!parentFrame && pointed?.sourceNodeId) {
+      if (!preserveLevelAndElevation && !parentFrame && pointed?.sourceNodeId) {
         const rotation = toCommitRotation(rotationRef.current)
         const effectiveNode = {
           ...((useScene.getState().nodes[node.id] ?? node) as Record<string, unknown>),
@@ -998,6 +1026,7 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
           },
         ).position
       }
+      position = keepStartingElevation(position, rotationRef.current)
       const visualPosition = getVisualPosition(position)
       hasMovedRef.current = true
       setCursorPosition(visualPosition)
@@ -1105,18 +1134,20 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
           // The pointer cap makes the persisted host reproduce the capped
           // election — a drop under a deck stores the aimed-at lower slab
           // (or the ground), not the deck hanging above.
-          ...resolveSupportSlabPatch(
-            effectiveNode,
-            {
-              ...useScene.getState().nodes,
-              [node.id]: effectiveNode,
-            },
-            {
-              maxElevation: supportCapRef.current,
-              preferredSlabId: supportSurfaceRef.current?.supportSlabId,
-              pinSupport: supportSurfaceRef.current?.sourceNodeId != null,
-            },
-          ),
+          ...(preserveLevelAndElevation
+            ? {}
+            : resolveSupportSlabPatch(
+                effectiveNode,
+                {
+                  ...useScene.getState().nodes,
+                  [node.id]: effectiveNode,
+                },
+                {
+                  maxElevation: supportCapRef.current,
+                  preferredSlabId: supportSurfaceRef.current?.supportSlabId,
+                  pinSupport: supportSurfaceRef.current?.sourceNodeId != null,
+                },
+              )),
           ...(isNew
             ? {
                 metadata: stripPlacementMetadataFlags(node.metadata),
@@ -1189,18 +1220,20 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
           const committedNode = def.schema.parse({
             ...reparsed,
             parentId: node.parentId,
-            ...resolveSupportSlabPatch(
-              { ...reparsed, parentId: node.parentId } as AnyNode,
-              {
-                ...useScene.getState().nodes,
-                [reparsed.id]: reparsed,
-              },
-              {
-                maxElevation: supportCapRef.current,
-                preferredSlabId: supportSurfaceRef.current?.supportSlabId,
-                pinSupport: supportSurfaceRef.current?.sourceNodeId != null,
-              },
-            ),
+            ...(preserveLevelAndElevation
+              ? {}
+              : resolveSupportSlabPatch(
+                  { ...reparsed, parentId: node.parentId } as AnyNode,
+                  {
+                    ...useScene.getState().nodes,
+                    [reparsed.id]: reparsed,
+                  },
+                  {
+                    maxElevation: supportCapRef.current,
+                    preferredSlabId: supportSurfaceRef.current?.supportSlabId,
+                    pinSupport: supportSurfaceRef.current?.sourceNodeId != null,
+                  },
+                )),
           }) as AnyNode
           useScene.temporal.getState().resume()
           useScene.getState().createNode(committedNode, node.parentId as AnyNodeId)
@@ -1245,6 +1278,7 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
     // item placement keys (and the "Rotate" hints the move HUD shows). Applied
     // imperatively + mirrored to the live transform; committed on drop.
     const onKeyDown = (e: KeyboardEvent) => {
+      if (isTypingTarget(e.target)) return
       // Hold Alt (free place) to force placement on an invalid (red) footprint,
       // matching the GLB item tool. Recolour the box to green while held.
       if (e.key === 'Alt') {
@@ -1285,6 +1319,7 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
         )
         position = canonicalPositionFromPlan(planOrigin[0], position[1], planOrigin[2])
       }
+      position = keepStartingElevation(position, hostedPose?.rotationY ?? nextFreeRotation)
       lastCursorRef.current = position
       freeRotationRef.current = hostedPose?.rotationY ?? nextFreeRotation
       rotationRef.current = freeRotationRef.current
@@ -1421,6 +1456,7 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
     originalPosition,
     originalPlanPosition,
     originalRotationY,
+    preserveLevelAndElevation,
     previewRotationY,
     revealFreshPlacement,
     useAbsoluteCursorPlacement,

package/src/components/tools/select/box-select-tool.tsx

@@ -1,4 +1,4 @@
-import { sceneRegistry, useScene, type ZoneNode } from '@pascal-app/core'
+import { sceneRegistry, useScene } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { useThree } from '@react-three/fiber'
 import { useCallback, useEffect, useRef } from 'react'
@@ -248,18 +248,8 @@ function collectNodeIdsInScreenRect(
 
 function commitBoxSelection(ids: string[], event: PointerEvent) {
   const shouldAppend = event.metaKey || event.ctrlKey || event.shiftKey
-  const { phase, structureLayer } = useEditor.getState()
   const viewer = useViewer.getState()
 
-  if (phase === 'structure' && structureLayer === 'zones') {
-    if (ids.length > 0) {
-      viewer.setSelection({ zoneId: ids[0] as ZoneNode['id'] })
-    } else if (!shouldAppend) {
-      viewer.setSelection({ zoneId: null })
-    }
-    return
-  }
-
   if (shouldAppend) {
     viewer.setSelection({
       selectedIds: Array.from(new Set([...viewer.selection.selectedIds, ...ids])),
@@ -274,7 +264,7 @@ export const BoxSelectTool: React.FC = () => {
   const phase = useEditor((s) => s.phase)
   const mode = useEditor((s) => s.mode)
   const selectionTool = useEditor((s) => s.floorplanSelectionTool)
-  const isActive = mode === 'select' && (phase === 'structure' || phase === 'furnish')
+  const isActive = mode === 'select' && phase === 'building'
 
   if (!isActive) return null
 

package/src/components/tools/select/plane-box-select-tool.test.tsx

@@ -0,0 +1,79 @@
+import { expect, test } from 'bun:test'
+import { emitter, type GridEvent } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { act } from '@react-three/fiber'
+import { cancelActiveTool } from '../../../hooks/use-keyboard'
+import { selectionEnabled } from '../../../lib/interaction/scope'
+import useEditor from '../../../store/use-editor'
+import useInteractionScope from '../../../store/use-interaction-scope'
+import { withSelectionHarness } from '../../../test-utils/selection-harness'
+import { PlaneBoxSelectTool } from './plane-box-select-tool'
+
+for (const exit of ['Escape', 'unmount', 'pointercancel'] as const) {
+  test(`plane marquee resets its drag and scope on ${exit}`, async () => {
+    await withSelectionHarness(async ({ render, canvas }) => {
+      useEditor.setState({
+        phase: 'building',
+        mode: 'select',
+        floorplanSelectionTool: 'marquee',
+        isFloorplanHovered: true,
+      })
+      useViewer.setState({ inputDragging: false, cameraDragging: false })
+      useInteractionScope.getState().end()
+      await render(<PlaneBoxSelectTool />)
+      await act(async () => {
+        canvas.dispatchEvent(
+          Object.assign(new Event('pointerdown'), { button: 0, clientX: 200, clientY: 200 }),
+        )
+        emitter.emit('grid:move', {
+          position: [4, 0, 4],
+          nativeEvent: { clientX: 800, clientY: 800 },
+        } as GridEvent)
+      })
+      expect(useInteractionScope.getState().scope.kind).toBe('box-select')
+      if (exit === 'unmount') await render(null)
+      else
+        await act(async () => {
+          if (exit === 'Escape') cancelActiveTool()
+          else window.dispatchEvent(new Event('pointercancel'))
+        })
+      expect(selectionEnabled(useInteractionScope.getState().scope)).toBe(true)
+      expect(useViewer.getState().previewSelectedIds).toEqual([])
+      if (exit === 'Escape') expect(useEditor.getState().floorplanSelectionTool).toBe('marquee')
+      await act(async () => {
+        emitter.emit('grid:move', {
+          position: [6, 0, 6],
+          nativeEvent: { clientX: 900, clientY: 900 },
+        } as GridEvent)
+        canvas.dispatchEvent(
+          Object.assign(new Event('pointerup'), { button: 0, clientX: 900, clientY: 900 }),
+        )
+      })
+      expect(useInteractionScope.getState().scope.kind).toBe('idle')
+    })
+  })
+}
+
+test('plane marquee cleanup cannot release a replacement box-select owner', async () => {
+  await withSelectionHarness(async ({ render, canvas }) => {
+    useEditor.setState({ isFloorplanHovered: true })
+    useViewer.setState({ inputDragging: false, cameraDragging: false })
+    await render(<PlaneBoxSelectTool />)
+    await act(async () => {
+      canvas.dispatchEvent(
+        Object.assign(new Event('pointerdown'), { button: 0, clientX: 200, clientY: 200 }),
+      )
+      emitter.emit('grid:move', {
+        position: [4, 0, 4],
+        nativeEvent: { clientX: 800, clientY: 800 },
+      } as GridEvent)
+    })
+    const ownGesture = useInteractionScope.getState().gesture
+    useInteractionScope.getState().begin({ kind: 'box-select' })
+    const replacement = useInteractionScope.getState().gesture
+    expect(replacement).not.toBe(ownGesture)
+    await render(null)
+    expect(useInteractionScope.getState().scope.kind).toBe('box-select')
+    expect(useInteractionScope.getState().gesture).toBe(replacement)
+  })
+})