@pascal-app/editor 1.0.5 → 1.0.7

package/src/components/systems/ceiling/ceiling-system.test.ts

@@ -0,0 +1,141 @@
+import { expect, test } from 'bun:test'
+import { BuildingNode, CeilingNode, LevelNode, useScene } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { act, createRoot } from '@react-three/fiber'
+import { createElement, Fragment } from 'react'
+import { OrthographicCamera, type WebGLRenderer } from 'three'
+import useEditor, { normalizePersistedEditorLayoutState } from '../../../store/use-editor'
+import useInteractionScope from '../../../store/use-interaction-scope'
+import { CeilingSystem, CeilingTopsSync } from './ceiling-system'
+
+test('ceilings start on for the roof level and off for the floor plans, each kept as set', () => {
+  const fresh = normalizePersistedEditorLayoutState(undefined)
+  expect(fresh.showRoofCeilings).toBe(true)
+  expect(fresh.showCeilings).toBe(false)
+  const turned = normalizePersistedEditorLayoutState({
+    showRoofCeilings: false,
+    showCeilings: true,
+  })
+  expect(turned.showRoofCeilings).toBe(false)
+  expect(turned.showCeilings).toBe(true)
+})
+
+test('the level’s ceilings setting draws the ceiling tops, stepping aside to place on a ceiling', async () => {
+  const previous = {
+    scene: useScene.getState(),
+    viewer: useViewer.getState(),
+    editor: useEditor.getState(),
+    scope: useInteractionScope.getState(),
+  }
+  const actGlobal = globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }
+  const previousAct = actGlobal.IS_REACT_ACT_ENVIRONMENT
+  actGlobal.IS_REACT_ACT_ENVIRONMENT = true
+  const makeCanvas = () =>
+    Object.assign(new EventTarget(), {
+      getBoundingClientRect: () => ({ left: 0, top: 0, width: 100, height: 100 }),
+    }) as unknown as HTMLCanvasElement
+  const canvas = makeCanvas()
+  const previewCanvas = makeCanvas()
+  const root = createRoot(canvas)
+  const previewRoot = createRoot(previewCanvas)
+  const building = BuildingNode.parse({})
+  const storey = LevelNode.parse({ parentId: building.id, level: 0, height: 3 })
+  const roof = LevelNode.parse({
+    parentId: building.id,
+    level: 1,
+    height: 3,
+    metadata: { role: 'roof' },
+  })
+  building.children = [storey.id, roof.id]
+  const ceiling = CeilingNode.parse({
+    parentId: storey.id,
+    height: 2.7,
+    polygon: [
+      [0, 0],
+      [4, 0],
+      [4, 4],
+      [0, 4],
+    ],
+  })
+  const select = (levelId: typeof storey.id) =>
+    act(async () =>
+      useViewer.setState({
+        selection: { buildingId: building.id, levelId, zoneId: null, selectedIds: [] },
+      }),
+    )
+  const tops = () => useViewer.getState().showCeilingTops
+  try {
+    useScene.setState({
+      nodes: {
+        [building.id]: building,
+        [storey.id]: storey,
+        [roof.id]: roof,
+        [ceiling.id]: ceiling,
+      },
+    })
+    useEditor.setState({
+      ...normalizePersistedEditorLayoutState(undefined),
+      tool: null,
+      selectedItem: null,
+      isPreviewMode: false,
+      isCaptureMode: false,
+    })
+    useInteractionScope.setState({ scope: { kind: 'idle' } })
+    useViewer.setState({ showCeilingTops: false, hoveredId: null })
+    await select(roof.id)
+    const configure = (target: typeof root, domElement: HTMLCanvasElement) =>
+      target.configure({
+        gl: {
+          domElement,
+          render() {},
+          setSize() {},
+          setPixelRatio() {},
+        } as unknown as WebGLRenderer,
+        camera: Object.assign(new OrthographicCamera(), { manual: true }),
+        frameloop: 'never',
+        dpr: 1,
+        size: { width: 100, height: 100, top: 0, left: 0 },
+      })
+    await configure(root, canvas)
+    await act(async () =>
+      root.render(
+        createElement(Fragment, null, createElement(CeilingTopsSync), createElement(CeilingSystem)),
+      ),
+    )
+    expect(tops()).toBe(true)
+
+    // A second viewer's ceiling system (the preview's) going away leaves the tops as set.
+    await configure(previewRoot, previewCanvas)
+    await act(async () => previewRoot.render(createElement(CeilingSystem)))
+    await act(async () => previewRoot.unmount())
+    expect(tops()).toBe(true)
+
+    await select(storey.id)
+    expect(tops()).toBe(false)
+    await act(async () => useEditor.getState().setShowCeilings(true))
+    expect(tops()).toBe(true)
+    await act(async () => useEditor.setState({ tool: 'ceiling' }))
+    expect(tops()).toBe(false)
+    await act(async () => useEditor.setState({ tool: null, isPreviewMode: true }))
+    expect(tops()).toBe(false)
+    await act(async () => useEditor.setState({ isPreviewMode: false }))
+    expect(tops()).toBe(true)
+
+    // The roof level keeps its own setting.
+    await select(roof.id)
+    await act(async () => useEditor.getState().setShowRoofCeilings(false))
+    expect(tops()).toBe(false)
+    expect(useEditor.getState().showCeilings).toBe(true)
+
+    await act(async () => useEditor.getState().setShowRoofCeilings(true))
+    expect(tops()).toBe(true)
+    await act(async () => root.unmount())
+    expect(tops()).toBe(false)
+  } finally {
+    useScene.setState(previous.scene, true)
+    useViewer.setState(previous.viewer, true)
+    useEditor.setState(previous.editor, true)
+    useInteractionScope.setState(previous.scope, true)
+    actGlobal.IS_REACT_ACT_ENVIRONMENT = previousAct
+  }
+})

package/src/components/systems/ceiling/ceiling-system.tsx

@@ -1,4 +1,4 @@
-import { type AnyNodeId, sceneRegistry, useScene } from '@pascal-app/core'
+import { type AnyNodeId, sceneRegistry, servesAsRoofLevel, useScene } from '@pascal-app/core'
 import { isProceduralItem } from '@pascal-app/core/procedural-items'
 import { useViewer } from '@pascal-app/viewer'
 import { useEffect } from 'react'
@@ -74,10 +74,59 @@ function setCeilingGridHighlighted(ceilingGrid: Mesh, highlighted: boolean) {
   delete userData[CEILING_GRID_HIGHLIGHT_MATERIAL_KEY]
 }
 
-export const CeilingSystem = () => {
+/**
+ * The "Ceilings" setting that applies on `levelId`: the roof level's, on until turned off; the
+ * floor plans', off until turned on. On, ceilings read as solid from above too.
+ */
+export function useCeilingsSetting(levelId: string | null | undefined): {
+  onRoofLevel: boolean
+  shown: boolean
+  setShown: (show: boolean) => void
+} {
+  const onRoofLevel = useScene((state) => {
+    const level = levelId ? state.nodes[levelId as AnyNodeId] : undefined
+    return level?.type === 'level' && servesAsRoofLevel(state.nodes, level)
+  })
+  const shown = useEditor((state) => (onRoofLevel ? state.showRoofCeilings : state.showCeilings))
+  const setRoof = useEditor((state) => state.setShowRoofCeilings)
+  const setFloor = useEditor((state) => state.setShowCeilings)
+  return { onRoofLevel, shown, setShown: onRoofLevel ? setRoof : setFloor }
+}
+
+function useIsCeilingToolActive(): boolean {
   const tool = useEditor((state) => state.tool)
   const selectedItem = useEditor((state) => state.selectedItem)
   const movingNode = useMovingNode()
+  return (
+    tool === 'ceiling' ||
+    selectedItem?.attachTo === 'ceiling' ||
+    (movingNode?.type === 'item' && movingNode?.asset?.attachTo === 'ceiling') ||
+    (isProceduralItem(movingNode) && movingNode.recipe.mounting?.attachTo === 'ceiling')
+  )
+}
+
+/**
+ * Whether the viewer draws ceiling tops (`showCeilingTops`), from the level's Ceilings setting.
+ * Mounted once by the editor, outside the canvases: the editor and preview viewers each mount a
+ * `CeilingSystem`, and two writers each turning the tops off on unmount raced.
+ */
+export const CeilingTopsSync = () => {
+  const activeLevelId = useViewer((state) => state.selection.levelId)
+  const ceilingsShown = useCeilingsSetting(activeLevelId).shown
+  const isPreviewMode = useEditor((state) => state.isPreviewMode)
+  const isCaptureMode = useEditor((state) => state.isCaptureMode)
+  const isCeilingToolActive = useIsCeilingToolActive()
+  // Placing on a ceiling looks through it from above, so the tops step aside; preview and
+  // captures keep the open look.
+  const showTops = ceilingsShown && !isCeilingToolActive && !isPreviewMode && !isCaptureMode
+  useEffect(() => {
+    useViewer.getState().setShowCeilingTops(showTops)
+    return () => useViewer.getState().setShowCeilingTops(false)
+  }, [showTops])
+  return null
+}
+
+export const CeilingSystem = () => {
   const selectedIds = useViewer((state) => state.selection.selectedIds)
   const activeLevelId = useViewer((state) => state.selection.levelId)
   const hoveredId = useViewer((state) => state.hoveredId)
@@ -87,6 +136,7 @@ export const CeilingSystem = () => {
   // reveal is gated here, on the consumer.
   const inputDragging = useViewer((state) => state.inputDragging)
   const scopeIdle = useInteractionScope((state) => state.scope.kind === 'idle')
+  const isCeilingToolActive = useIsCeilingToolActive()
 
   useEffect(() => {
     const nodes = useScene.getState().nodes
@@ -96,12 +146,6 @@ export const CeilingSystem = () => {
 
     const levelsToShowCeilings = new Set<string>()
 
-    const isCeilingToolActive =
-      tool === 'ceiling' ||
-      selectedItem?.attachTo === 'ceiling' ||
-      (movingNode?.type === 'item' && movingNode?.asset?.attachTo === 'ceiling') ||
-      (isProceduralItem(movingNode) && movingNode.recipe.mounting?.attachTo === 'ceiling')
-
     if (isCeilingToolActive && activeLevelId) {
       levelsToShowCeilings.add(activeLevelId)
     }
@@ -162,15 +206,6 @@ export const CeilingSystem = () => {
         }
       }
     })
-  }, [
-    tool,
-    selectedItem,
-    movingNode,
-    selectedIds,
-    activeLevelId,
-    hoveredId,
-    scopeIdle,
-    inputDragging,
-  ])
+  }, [isCeilingToolActive, selectedIds, activeLevelId, hoveredId, scopeIdle, inputDragging])
   return null
 }

package/src/components/tools/distribution/distribution-run-tool.tsx

@@ -1,6 +1,13 @@
 'use client'
 
-import { type AnyNodeId, emitter, type GridEvent, sceneRegistry, useScene } from '@pascal-app/core'
+import {
+  type AnyNodeId,
+  emitter,
+  type GridEvent,
+  sceneRegistry,
+  usePascalI18n,
+  useScene,
+} from '@pascal-app/core'
 import {
   CursorSphere,
   clearPlacementSurface,
@@ -17,11 +24,12 @@ import {
   useEditor,
   useInteractionScope,
 } from '@pascal-app/editor'
-import { Html } from '@react-three/drei'
 import { useThree } from '@react-three/fiber'
 import { type RefObject, useCallback, useEffect, useRef, useState } from 'react'
 import { createPortal } from 'react-dom'
 import { type Group, Vector3 } from 'three'
+import { messageWithSlot } from '../../../i18n/message-slot'
+import { Html } from '../../editor/localized-html'
 import type { RunSurfaceBounds, RunSurfaceTarget } from './distribution-run-contract'
 import { clearDrawAlignment } from './draw-alignment'
 import type { RunBodyHit, ScenePort } from './ports'
@@ -1197,6 +1205,7 @@ export function DistributionRunCursor({
   onLengthInputChange?: (value: string) => void
   onDirectionSelect?: (direction: RunPoint) => void
 }) {
+  const i18n = usePascalI18n()
   const lengthFieldRef = useRef<HTMLInputElement>(null)
   useEffect(() => {
     if (start) lengthFieldRef.current?.focus()
@@ -1284,30 +1293,45 @@ export function DistributionRunCursor({
             <DimensionPill parts={parts} primary={primary} unit={unit} />
             {start ? (
               <label className="rounded-full border border-border/60 bg-background/90 px-3 py-1 text-[11px] tabular-nums text-muted-foreground shadow-sm backdrop-blur">
-                Length:{' '}
-                <input
-                  className="w-20 bg-transparent text-center text-foreground outline-none"
-                  data-run-length-input
-                  inputMode="decimal"
-                  onKeyDown={(event) => {
-                    if (
-                      event.key === 'Backspace' ||
-                      event.key === 'Delete' ||
-                      event.key === 'ArrowLeft' ||
-                      event.key === 'ArrowRight'
-                    ) {
-                      event.stopPropagation()
-                    }
-                  }}
-                  onChange={(event) => onLengthInputChange?.(event.target.value)}
-                  onPointerDown={(event) => event.stopPropagation()}
-                  placeholder="type a length"
-                  ref={lengthFieldRef}
-                  style={{ pointerEvents: 'auto' }}
-                  type="text"
-                  value={lengthInput ?? ''}
-                />{' '}
-                m<span className="ml-2">Tab: direction</span>
+                {messageWithSlot(
+                  i18n,
+                  /* i18n */ {
+                    id: 'editor.tools.distribution.distributionRunTool.lengthField',
+                    message: 'Length: {field} m',
+                  },
+                  'field',
+                  <input
+                    className="w-20 bg-transparent text-center text-foreground outline-none"
+                    data-run-length-input
+                    inputMode="decimal"
+                    onKeyDown={(event) => {
+                      if (
+                        event.key === 'Backspace' ||
+                        event.key === 'Delete' ||
+                        event.key === 'ArrowLeft' ||
+                        event.key === 'ArrowRight'
+                      ) {
+                        event.stopPropagation()
+                      }
+                    }}
+                    onChange={(event) => onLengthInputChange?.(event.target.value)}
+                    onPointerDown={(event) => event.stopPropagation()}
+                    placeholder={i18n._({
+                      id: 'editor.tools.distribution.distributionRunTool.typeALength',
+                      message: 'type a length',
+                    })}
+                    ref={lengthFieldRef}
+                    style={{ pointerEvents: 'auto' }}
+                    type="text"
+                    value={lengthInput ?? ''}
+                  />,
+                )}
+                <span className="ml-2">
+                  {i18n._({
+                    id: 'editor.tools.distribution.distributionRunTool.tabDirection',
+                    message: 'Tab: direction',
+                  })}
+                </span>
               </label>
             ) : null}
             {validationMessage ? (

package/src/components/tools/item/placement-history.test.tsx

@@ -22,12 +22,12 @@ import {
   WallNode,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
-import { Html } from '@react-three/drei'
 import { act, create } from '@react-three/test-renderer'
 import { Children, Component, cloneElement, isValidElement, type ReactNode } from 'react'
 import { Group } from 'three'
 import useEditor from '../../../store/use-editor'
 import useInteractionScope from '../../../store/use-interaction-scope'
+import { Html } from '../../editor/localized-html'
 import { useDraftNode } from './use-draft-node'
 import { usePlacementCoordinator } from './use-placement-coordinator'
 

package/src/components/tools/item/placement-strategies.test.ts

@@ -1,6 +1,7 @@
-import { beforeEach, describe, expect, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
 import {
   BlockNode,
+  BuildingNode,
   type CeilingEvent,
   type CeilingNode,
   type GridEvent,
@@ -11,7 +12,11 @@ import {
   type WallEvent,
   type WallNode,
 } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
 import { BufferGeometry, Mesh, MeshBasicMaterial, type Object3D, Vector3 } from 'three'
+import { GROUP_MOVE_DRAG_LABEL } from '../../../lib/contextual-help'
+import useEditor from '../../../store/use-editor'
+import useInteractionScope from '../../../store/use-interaction-scope'
 import {
   ceilingStrategy,
   faceHostStrategy,
@@ -498,6 +503,64 @@ describe('floorStrategy.move', () => {
     expect(result.cursorPosition[1]).toBe(0)
     expect(result.nodeUpdate?.position?.[1]).toBe(0)
   })
+
+  describe('in grid mode', () => {
+    const originalSelection = useViewer.getState().selection
+
+    beforeEach(() => {
+      // The group-move scope resolves to the item snap context without the
+      // node registry; grid mode at a 0.5 m step.
+      useInteractionScope
+        .getState()
+        .begin({ kind: 'handle-drag', nodeId: 'item_test', handle: GROUP_MOVE_DRAG_LABEL })
+      useEditor.getState().setSnappingMode('item', 'grid')
+      useEditor.getState().setGridSnapStep(0.5)
+    })
+
+    afterEach(() => {
+      useInteractionScope.getState().end()
+      useEditor.getState().setSnappingMode('item', 'lines')
+      useViewer.setState({ selection: originalSelection } as never)
+    })
+
+    // A 0.5 m plant centres half a cell off the lattice, its edges on it.
+    test("inside a turned building it lands on the building's lattice, square to the house", () => {
+      const yaw = (17 * Math.PI) / 180
+      const building = BuildingNode.parse({ position: [12.37, 0, -8.91], rotation: [0, yaw, 0] })
+      useScene.setState((state) => ({
+        ...state,
+        nodes: { ...state.nodes, [building.id]: building },
+      }))
+      useViewer.setState({
+        selection: { buildingId: building.id, levelId: null, zoneId: null, selectedIds: [] },
+      } as never)
+      const local: [number, number] = [1.37, 2.61]
+      const cos = Math.cos(yaw)
+      const sin = Math.sin(yaw)
+      const event: GridEvent = {
+        position: [
+          12.37 + local[0] * cos + local[1] * sin,
+          0,
+          -8.91 - local[0] * sin + local[1] * cos,
+        ],
+        localPosition: [local[0], 0, local[1]],
+        nativeEvent: {} as GridEvent['nativeEvent'],
+      }
+
+      const result = floorStrategy.move(floorItemContext(), event)
+      expect(result?.nodeUpdate?.position?.[0]).toBeCloseTo(1.25, 9)
+      expect(result?.nodeUpdate?.position?.[2]).toBeCloseTo(2.75, 9)
+    })
+
+    test('outside any building it keeps the world grid', () => {
+      useViewer.setState({
+        selection: { buildingId: null, levelId: null, zoneId: null, selectedIds: [] },
+      } as never)
+      const result = floorStrategy.move(floorItemContext(), makeGridEvent(5.37, 0, -3.12))
+      expect(result?.nodeUpdate?.position?.[0]).toBeCloseTo(5.25, 9)
+      expect(result?.nodeUpdate?.position?.[2]).toBeCloseTo(-3.25, 9)
+    })
+  })
 })
 
 describe('ceilingStrategy.move', () => {

package/src/components/tools/item/placement-strategies.ts

@@ -27,13 +27,12 @@ import {
   resolveSurfacePlacement,
   roofFacePointToSegment,
   sceneRegistry,
-  snapLocalXZInWorld,
   useScene,
   wouldCreateHostingCycle,
 } from '@pascal-app/core'
 import { Euler, Quaternion, Vector3 } from 'three'
 import { hasRoofFaceChildOverlap, resolveRoofWallHit } from '../../../lib/roof-wall-hit'
-import { getActiveBuildingPose } from '../../../lib/world-grid-snap'
+import { snapPlanPointToActiveGrid } from '../../../lib/world-grid-snap'
 import { itemEventToSurfaceHit, surfaceWorldNormalY } from '../shared/surface-hit'
 import {
   calculateItemRotation,
@@ -73,17 +72,14 @@ export const floorStrategy = {
     const [dimX, , dimZ] = dims
     const rotY = ctx.draftItem?.rotation?.[1] ?? 0
     const swapDims = Math.abs(Math.sin(rotY)) > 0.9
-    // Snap on the world XZ grid (the grid the editor renders) so the
-    // item edges land on the visible grid even when the active building
-    // is rotated; then project the world point back into building-local
-    // for storage. Without this, a rotated building drags placement off
-    // the world grid.
+    // Snap on the lattice the grid is drawn on: a turned building's own
+    // lattice inside it (item edges square to the house), the world grid
+    // outside any building.
     // Snapping is governed by the active mode (snapToGrid returns raw in Off /
     // non-grid modes); Alt is force-place only and never bypasses snapping here.
     const dimensions = [swapDims ? dimZ : dimX, swapDims ? dimX : dimZ] as const
-    const [x, z] = snapLocalXZInWorld(
+    const [x, z] = snapPlanPointToActiveGrid(
       [event.localPosition[0], event.localPosition[2]],
-      getActiveBuildingPose(),
       (value, axis) => snapToGrid(value, dimensions[axis]),
     )
     const y = ctx.gridPosition.y

package/src/components/tools/item/use-placement-coordinator.tsx

@@ -30,7 +30,6 @@ import {
   type WallEvent,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
-import { Html } from '@react-three/drei'
 import { useFrame, useThree } from '@react-three/fiber'
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import {
@@ -74,6 +73,7 @@ import useEditor, {
 import useFacingPose from '../../../store/use-facing-pose'
 import { getMovingNode } from '../../../store/use-interaction-scope'
 import usePlacementPreview from '../../../store/use-placement-preview'
+import { Html } from '../../editor/localized-html'
 import {
   createItemSurfaceGridDispatch,
   createItemSurfacePointerArbitration,
@@ -1008,9 +1008,9 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
 
     // Floor grab-offset: the item tracks the grabbed point instead of snapping
     // its origin under the cursor. The offset is computed in building-local space
-    // (`event.localPosition`), but `floorStrategy.move` snaps on the WORLD grid
-    // (`event.position`), so the corrected local point is re-projected to a
-    // corrected world point and both frames carry the offset to stay consistent.
+    // (`event.localPosition`, which `floorStrategy.move` snaps), and the corrected
+    // local point is re-projected to a corrected world point so both frames carry
+    // the offset and stay consistent.
     const applyFloorGrabOffset = (event: GridEvent): GridEvent => {
       if (relativeFloorStart === null) return event
       const rawX = event.localPosition[0]
@@ -1871,6 +1871,11 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
           position: floorPos,
           rotation,
         })
+        // The surface moves published a building-space cursor (the host's top, level height
+        // included) as the live transform. Back on the floor the item renders level-local, so
+        // that stale height lifted it by its level's elevation (a bedside left on a 4th-floor bed
+        // floated ~10 m up) until the next floor move: publish the floor pose now.
+        useLiveTransforms.getState().set(draft.id, { position: floorPos, rotation: rotation[1] })
       }
 
       revalidate()
@@ -2717,13 +2722,31 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
 
     // ---- Subscribe ----
 
+    // With a level selected, surfaces on other floors don't capture the draft: past the building
+    // edge, through a window or over a stairwell the ray finds a lower floor's furniture, slab or
+    // wall, and adopting it re-parented the item to that floor mid-gesture (and paid a level
+    // change each time). The floor cursor keeps following the selected level instead.
+    const onActiveLevel = (node: AnyNode | undefined) => {
+      const levelId = useViewer.getState().selection.levelId
+      if (!levelId || !node) return true
+      return resolveLevelId(node, useScene.getState().nodes) === levelId
+    }
     const specializedKinds = new Set<string>()
-    const subscribeSpecialized = <E,>(key: string, handler: (event: E) => void) => {
+    const unsubscribeSpecialized: (() => void)[] = []
+    const subscribeSpecialized = <E extends { node?: AnyNode }>(
+      key: string,
+      handler: (event: E) => void,
+    ) => {
       specializedKinds.add(key.slice(0, key.lastIndexOf(':')))
-      emitter.on(key as never, handler as never)
+      const gated = (event: E) => {
+        if (onActiveLevel(event.node)) handler(event)
+      }
+      emitter.on(key as never, gated as never)
+      unsubscribeSpecialized.push(() => emitter.off(key as never, gated as never))
     }
     const genericRoute = (phase: 'enter' | 'move' | 'click' | 'leave') => (event: NodeEvent) => {
       if (specializedKinds.has(event.node.type)) return
+      if (!onActiveLevel(event.node)) return
       if (
         !surfaceOwnership.allows(event.node.id, event.nativeEvent.nativeEvent ?? event.nativeEvent)
       )
@@ -2820,38 +2843,11 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       gridDispatch.cancel()
       emitter.off('grid:move', gridDispatch.schedule)
       emitter.off('grid:click', onGridClick)
-      emitter.off('item:enter', onItemEnter)
-      emitter.off('item:move', onItemMove)
-      emitter.off('item:leave', onItemLeave)
-      emitter.off('item:click', onItemClick)
-      emitter.off('wall:enter', onWallEnter)
-      emitter.off('wall:move', onWallMove)
-      emitter.off('wall:click', onWallClick)
-      emitter.off('wall:leave', onWallLeave)
-      emitter.off('roof:enter', onRoofWallEnter)
-      emitter.off('roof:move', onRoofWallMove)
-      emitter.off('roof:click', onRoofWallClick)
-      emitter.off('roof:leave', onRoofWallLeave)
+      for (const unsubscribe of unsubscribeSpecialized) unsubscribe()
       emitter.off('node:enter', onNodeEnter)
       emitter.off('node:move', onNodeMove)
       emitter.off('node:click', onNodeClick)
       emitter.off('node:leave', onNodeLeave)
-      emitter.off('ceiling:enter', onCeilingEnter)
-      emitter.off('ceiling:move', onCeilingMove)
-      emitter.off('ceiling:click', onCeilingClick)
-      emitter.off('ceiling:leave', onCeilingLeave)
-      emitter.off('cabinet:enter', onItemEnter)
-      emitter.off('procedural-item:enter' as never, onItemEnter)
-      emitter.off('cabinet:move', onItemMove)
-      emitter.off('procedural-item:move' as never, onItemMove)
-      emitter.off('cabinet:click', onItemClick)
-      emitter.off('procedural-item:click' as never, onItemClick)
-      emitter.off('cabinet:leave', onItemLeave)
-      emitter.off('procedural-item:leave' as never, onItemLeave)
-      emitter.off('shelf:enter', onShelfEnter)
-      emitter.off('shelf:move', onShelfMove)
-      emitter.off('shelf:click', onShelfClick)
-      emitter.off('shelf:leave', onShelfLeave)
       emitter.off('node:click', commitFloorOnSurfaceClick as never)
       emitter.off('tool:cancel', onCancel)
       window.removeEventListener('keydown', onKeyDown)

package/src/components/tools/registry/item-surface-move.test.ts

@@ -22,6 +22,7 @@ import {
 } from '@pascal-app/core/procedural-items'
 import { Group, Vector3 } from 'three'
 import { commitFreshPlacementSubtree } from '../../../lib/fresh-planar-placement'
+import useEditor from '../../../store/use-editor'
 import { registerHostingTestNode } from '../__fixtures__/hosting'
 import {
   createItemSurfaceGridDispatch,
@@ -62,6 +63,7 @@ const host = ItemNode.parse({
 let restoreRegistry: () => void
 let oldNodes: ReturnType<typeof useScene.getState>['nodes']
 let oldRoots: AnyNodeId[]
+let oldSnapping: ReturnType<typeof useEditor.getState>['snappingModeByContext']
 
 beforeEach(() => {
   globalThis.requestAnimationFrame = (callback) => {
@@ -69,6 +71,14 @@ beforeEach(() => {
     return 0
   }
   globalThis.cancelAnimationFrame = () => {}
+  // Poses are asserted raw: whatever context a previous suite left active
+  // (a tool, a scope, its snapping mode) must not snap them to the grid.
+  oldSnapping = useEditor.getState().snappingModeByContext
+  useEditor.setState({
+    snappingModeByContext: Object.fromEntries(
+      Object.keys(oldSnapping).map((context) => [context, 'off']),
+    ) as typeof oldSnapping,
+  })
   restoreRegistry = nodeRegistry._snapshot()
   oldNodes = useScene.getState().nodes
   oldRoots = useScene.getState().rootNodeIds
@@ -119,6 +129,7 @@ afterEach(() => {
   globalThis.requestAnimationFrame = originalRaf
   globalThis.cancelAnimationFrame = originalCancelRaf
   restoreRegistry()
+  useEditor.setState({ snappingModeByContext: oldSnapping })
   useLiveTransforms.getState().clear(original.id)
   for (const id of ['level_surface-move', host.id, 'item_second-host'])
     sceneRegistry.nodes.delete(id)