@pascal-app/editor 1.0.3 → 1.0.5

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

@@ -0,0 +1,512 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNodeId,
+  type AssetInput,
+  acquireSceneHistoryPause,
+  beginSceneHistoryPauseSession,
+  clearSceneHistory,
+  emitter,
+  getSceneHistoryPauseDepth,
+  ItemNode,
+  initSpaceDetectionSync,
+  LevelNode,
+  pauseSceneHistory,
+  resumeSceneHistory,
+  type SceneCommit,
+  sceneRegistry,
+  spatialGridManager,
+  subscribeSceneCommits,
+  useLiveNodeOverrides,
+  useLiveTransforms,
+  useScene,
+  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 { useDraftNode } from './use-draft-node'
+import { usePlacementCoordinator } from './use-placement-coordinator'
+
+// The item move / placement history contract, driven through the real placement coordinator
+// with core's space-detection sync attached. The carry pauses no history: the draft is kept out
+// of history snapshots, so the drop is one ordinary tracked step, a write someone else makes
+// mid-carry is its own step (in commit order, reconciled by space detection), and undoing that
+// step mid-carry leaves the draft alone. Every exit path releases only its own pauses.
+
+const level = LevelNode.parse({ id: 'level_placement_history', level: 0 })
+const wallA = WallNode.parse({
+  id: 'wall_placement_history_a',
+  parentId: level.id,
+  start: [-6, -6],
+  end: [6, -6],
+})
+const wallB = WallNode.parse({
+  id: 'wall_placement_history_b',
+  parentId: level.id,
+  start: [6, -6],
+  end: [6, 6],
+})
+const wallC = WallNode.parse({
+  id: 'wall_placement_history_c',
+  parentId: level.id,
+  start: [6, 6],
+  end: [-6, 6],
+})
+const closingWall = WallNode.parse({
+  id: 'wall_placement_history_closing',
+  parentId: level.id,
+  start: [-6, 6],
+  end: [-6, -6],
+})
+const bathtub: AssetInput = {
+  id: 'bathtub',
+  name: 'Bathtub',
+  category: 'bathroom',
+  thumbnail: '',
+  src: '/bathtub.glb',
+  dimensions: [1.7, 0.6, 0.8],
+}
+const item = ItemNode.parse({
+  id: 'item_placement_history_bathtub',
+  parentId: level.id,
+  asset: bathtub,
+  position: [0, 0, 0],
+  rotation: [0, 0, 0],
+})
+
+let savedScene: ReturnType<typeof useScene.getState>
+let savedEditor: ReturnType<typeof useEditor.getState>
+let savedViewer: ReturnType<typeof useViewer.getState>
+let savedScope: ReturnType<typeof useInteractionScope.getState>
+let restoreGlobals: () => void
+let stopSpaceDetection: () => void
+
+beforeEach(() => {
+  savedScene = useScene.getState()
+  savedEditor = useEditor.getState()
+  savedViewer = useViewer.getState()
+  savedScope = useInteractionScope.getState()
+  const names = ['window', 'document', 'requestAnimationFrame', 'cancelAnimationFrame'] as const
+  const descriptors = names.map((name) => Object.getOwnPropertyDescriptor(globalThis, name))
+  restoreGlobals = () =>
+    names.forEach((name, i) => {
+      const descriptor = descriptors[i]
+      if (descriptor) Object.defineProperty(globalThis, name, descriptor)
+      else Reflect.deleteProperty(globalThis, name)
+    })
+  globalThis.window = new EventTarget() as Window & typeof globalThis
+  globalThis.document = { body: { style: { cursor: '' } } } as Document
+  globalThis.requestAnimationFrame = () => 0
+  globalThis.cancelAnimationFrame = () => {}
+
+  useScene.setState({
+    nodes: {
+      [level.id]: { ...level, children: [wallA.id, wallB.id, wallC.id, item.id] },
+      [wallA.id]: structuredClone(wallA),
+      [wallB.id]: structuredClone(wallB),
+      [wallC.id]: structuredClone(wallC),
+      [item.id]: structuredClone(item),
+    },
+    rootNodeIds: [level.id],
+    collections: {},
+    materials: {},
+    dirtyNodes: new Set(),
+    readOnly: false,
+  } as never)
+  clearSceneHistory()
+  spatialGridManager.clear()
+  useLiveNodeOverrides.getState().clearAll()
+  useLiveTransforms.getState().clearAll()
+  useInteractionScope.getState().end()
+  useEditor.setState({
+    mode: 'build',
+    tool: 'item',
+    movingNodeOrigin: '3d',
+    placementDragMode: false,
+  })
+  useEditor.getState().setSnappingMode('item', 'grid')
+  useEditor.setState({ gridSnapStep: 0.1 })
+  useViewer.setState({
+    selection: { buildingId: null, levelId: level.id, zoneId: null, selectedIds: [] },
+  })
+  sceneRegistry.nodes.set(level.id, new Group())
+  stopSpaceDetection = initSpaceDetectionSync(useScene, {
+    getState: () => ({ spaces: {}, setSpaces: () => {} }),
+  })
+})
+
+afterEach(() => {
+  stopSpaceDetection()
+  sceneRegistry.nodes.clear()
+  spatialGridManager.clear()
+  useLiveNodeOverrides.getState().clearAll()
+  useLiveTransforms.getState().clearAll()
+  clearSceneHistory()
+  useScene.setState(savedScene)
+  useEditor.setState(savedEditor)
+  useViewer.setState(savedViewer)
+  useInteractionScope.setState(savedScope)
+  restoreGlobals()
+})
+
+// The DOM-only measurement labels need a canvas; the cursor refs they sit beside do not.
+function withoutLabels(element: ReactNode): ReactNode {
+  if (!isValidElement<{ children?: ReactNode }>(element)) return element
+  if (element.type === Html) return null
+  return cloneElement(element, {}, Children.map(element.props.children, withoutLabels))
+}
+
+function Placement({
+  source,
+  repeat = false,
+  failSetup = false,
+}: {
+  source?: ItemNode
+  repeat?: boolean
+  failSetup?: boolean
+}) {
+  const draftNode = useDraftNode()
+  return withoutLabels(
+    usePlacementCoordinator({
+      asset: source?.asset ?? bathtub,
+      draftNode,
+      initDraft: (position) => {
+        if (failSetup) throw new Error('injected setup failure')
+        if (source) {
+          draftNode.adopt(source)
+          position.set(...draftNode.current!.position)
+        } else draftNode.create(position, bathtub)
+      },
+      onCommitted: () => repeat,
+      onCancel: () => draftNode.destroy(),
+    }),
+  )
+}
+
+class SetupBoundary extends Component<{ children: ReactNode }, { failed: boolean }> {
+  state = { failed: false }
+  static getDerivedStateFromError() {
+    return { failed: true }
+  }
+  render() {
+    return this.state.failed ? null : this.props.children
+  }
+}
+
+const history = () => {
+  const temporal = useScene.temporal.getState()
+  return {
+    past: temporal.pastStates.length,
+    tracking: temporal.isTracking,
+    depth: getSceneHistoryPauseDepth(),
+  }
+}
+const liveItem = () => useScene.getState().nodes[item.id as AnyNodeId] as ItemNode
+const levelItems = () =>
+  Object.values(useScene.getState().nodes).filter(
+    (node) => node.type === 'item' && !node.metadata?.isTransient,
+  )
+
+async function grid(kind: 'move' | 'click', x: number, z = 0) {
+  await act(async () => {
+    emitter.emit(`grid:${kind}`, {
+      position: [x, 0, z],
+      localPosition: [x, 0, z],
+      nativeEvent: {},
+      stopPropagation() {},
+    } as never)
+    await new Promise((resolve) => setTimeout(resolve, 5))
+  })
+}
+
+async function carry(from: number, to: number) {
+  for (let step = from; step <= to; step++) await grid('move', step * 0.1, 0.5)
+}
+
+/** Another refcounted owner's balanced pause/resume pair landing mid-carry. */
+function foreignPausePair() {
+  pauseSceneHistory(useScene)
+  resumeSceneHistory(useScene)
+}
+
+/** Someone else closes the room mid-carry; the space-detection sync owes it a slab and ceiling. */
+function closeRoom() {
+  useScene.getState().createNode(structuredClone(closingWall), level.id as AnyNodeId)
+}
+const autoRoomNodes = () =>
+  Object.values(useScene.getState().nodes).filter(
+    (node) => (node.type === 'slab' || node.type === 'ceiling') && 'autoFromWalls' in node,
+  )
+const hasNode = (id: string) => Boolean(useScene.getState().nodes[id as AnyNodeId])
+
+describe('item move history', () => {
+  test('a move adds one entry and one undo restores the item', async () => {
+    const before = history()
+    const renderer = await create(<Placement source={item} />)
+    try {
+      await carry(1, 6)
+      expect(history().past).toBe(before.past)
+      await grid('click', 0.6, 0.5)
+    } finally {
+      await renderer.unmount()
+    }
+    expect(liveItem().position.map((value) => Number(value.toFixed(6)))).toEqual([0.6, 0, 0.5])
+    expect(history()).toEqual({ past: before.past + 1, tracking: true, depth: 0 })
+    useScene.temporal.getState().undo()
+    expect(liveItem()).toEqual(item)
+  })
+
+  test('a foreign pause owner mid-carry leaves the drop one entry', async () => {
+    const before = history()
+    const renderer = await create(<Placement source={item} />)
+    try {
+      await carry(1, 3)
+      foreignPausePair()
+      await carry(4, 6)
+      expect(history().past).toBe(before.past)
+      await grid('click', 0.6, 0.5)
+    } finally {
+      await renderer.unmount()
+    }
+    expect(history()).toEqual({ past: before.past + 1, tracking: true, depth: 0 })
+    useScene.temporal.getState().undo()
+    expect(liveItem()).toEqual(item)
+  })
+
+  test('a room closed mid-carry is its own step, in commit order, before the drop', async () => {
+    const before = history()
+    const commits: SceneCommit[] = []
+    const stop = subscribeSceneCommits((commit) => commits.push(commit))
+    const renderer = await create(<Placement source={item} />)
+    try {
+      await carry(1, 3)
+      closeRoom()
+      expect(history().past).toBe(before.past + 1)
+      await carry(4, 6)
+      await grid('click', 0.6, 0.5)
+    } finally {
+      await renderer.unmount()
+      stop()
+    }
+    expect(history()).toEqual({ past: before.past + 2, tracking: true, depth: 0 })
+    expect(
+      autoRoomNodes()
+        .map((node) => node.type)
+        .sort(),
+    ).toEqual(['ceiling', 'slab'])
+    const local = commits.filter((commit) => commit.origin === 'local')
+    expect(
+      local.map(
+        (commit) =>
+          Boolean(commit.current.nodes[closingWall.id as AnyNodeId]) &&
+          !commit.before.nodes[closingWall.id as AnyNodeId],
+      ),
+    ).toEqual([true, false])
+    const dropped = local[1]!.current.nodes[item.id as AnyNodeId] as ItemNode
+    expect(dropped.position.map((value) => Number(value.toFixed(6)))).toEqual([0.6, 0, 0.5])
+    // The draft never reaches history: every recorded snapshot has the item as it was.
+    expect(local[0]!.current.nodes[item.id as AnyNodeId]).toEqual(item)
+
+    useScene.temporal.getState().undo()
+    expect(liveItem()).toEqual(item)
+    expect(hasNode(closingWall.id)).toBe(true)
+    expect(autoRoomNodes()).toHaveLength(2)
+
+    useScene.temporal.getState().undo()
+    expect(liveItem()).toEqual(item)
+    expect(hasNode(closingWall.id)).toBe(false)
+    expect(autoRoomNodes()).toHaveLength(0)
+    expect(history().past).toBe(before.past)
+  })
+
+  test('undoing the foreign step mid-carry leaves the draft where it is', async () => {
+    const before = history()
+    const renderer = await create(<Placement source={item} />)
+    try {
+      await carry(1, 3)
+      closeRoom()
+      const carried = liveItem()
+      useScene.temporal.getState().undo()
+      expect(hasNode(closingWall.id)).toBe(false)
+      expect(liveItem()).toEqual(carried)
+      await carry(4, 6)
+      await grid('click', 0.6, 0.5)
+    } finally {
+      await renderer.unmount()
+    }
+    expect(history()).toEqual({ past: before.past + 1, tracking: true, depth: 0 })
+    expect(liveItem().position.map((value) => Number(value.toFixed(6)))).toEqual([0.6, 0, 0.5])
+    useScene.temporal.getState().undo()
+    expect(liveItem()).toEqual(item)
+  })
+
+  test('a room closed during a cancelled carry is its own step and the item is unchanged', async () => {
+    const before = history()
+    const renderer = await create(<Placement source={item} />)
+    try {
+      await carry(1, 3)
+      closeRoom()
+      await act(async () => {
+        emitter.emit('tool:cancel')
+      })
+    } finally {
+      await renderer.unmount()
+    }
+    expect(liveItem()).toEqual(item)
+    expect(history()).toEqual({ past: before.past + 1, tracking: true, depth: 0 })
+    useScene.temporal.getState().undo()
+    expect(hasNode(closingWall.id)).toBe(false)
+    expect(liveItem()).toEqual(item)
+  })
+
+  test('cancel and unmount add no entry and restore the item', async () => {
+    for (const exit of ['cancel', 'unmount'] as const) {
+      const before = history()
+      const renderer = await create(<Placement source={item} />)
+      await carry(1, 4)
+      if (exit === 'cancel') await act(async () => emitter.emit('tool:cancel'))
+      await renderer.unmount()
+      expect(liveItem()).toEqual(item)
+      expect(history()).toEqual({ past: before.past, tracking: true, depth: 0 })
+    }
+  })
+
+  test('with history at its 50-entry limit, the wall step and the drop still undo in order', async () => {
+    for (let index = 0; index < 60; index++) {
+      useScene.getState().updateNode(wallA.id as AnyNodeId, { thickness: 0.1 + index / 1000 })
+    }
+    expect(history().past).toBe(50)
+    const renderer = await create(<Placement source={item} />)
+    try {
+      await carry(1, 3)
+      closeRoom()
+      await grid('click', 0.3, 0.5)
+    } finally {
+      await renderer.unmount()
+    }
+    expect(history().past).toBe(50)
+    useScene.temporal.getState().undo()
+    expect(liveItem()).toEqual(item)
+    expect(hasNode(closingWall.id)).toBe(true)
+    useScene.temporal.getState().undo()
+    expect(hasNode(closingWall.id)).toBe(false)
+  })
+
+  test('in split view the 2D overlay co-owns the gesture, and the 3D drop is one step', async () => {
+    useEditor.getState().setMovingNode(item)
+    const overlay = beginSceneHistoryPauseSession(useScene, { gesture: item.id })
+    const before = history()
+    const renderer = await create(<Placement source={item} />)
+    try {
+      await carry(1, 6)
+      await grid('click', 0.6, 0.5)
+    } finally {
+      await renderer.unmount()
+      overlay.end()
+    }
+    expect(history()).toEqual({ past: before.past + 1, tracking: true, depth: 0 })
+    useScene.temporal.getState().undo()
+    expect(liveItem()).toEqual(item)
+  })
+
+  test("never releases another owner's pause on commit or unmount", async () => {
+    const releaseOuter = acquireSceneHistoryPause(useScene)
+    const before = history()
+    const renderer = await create(<Placement source={item} />)
+    try {
+      await carry(1, 6)
+      await grid('click', 0.6, 0.5)
+      expect(history().tracking).toBe(false)
+    } finally {
+      await renderer.unmount()
+    }
+    expect(history()).toEqual({ past: before.past, tracking: false, depth: 1 })
+    releaseOuter()
+    expect(history()).toEqual({ past: before.past, tracking: true, depth: 0 })
+  })
+
+  test('repeat placement adds one entry per drop', async () => {
+    const before = history()
+    const itemsBefore = levelItems().length
+    const renderer = await create(<Placement repeat />)
+    try {
+      await carry(10, 14)
+      await grid('click', 1.4, 0.5)
+      expect(history().past).toBe(before.past + 1)
+      await carry(20, 24)
+      foreignPausePair()
+      await grid('click', 2.4, 0.5)
+      expect(history().past).toBe(before.past + 2)
+      await carry(30, 32)
+    } finally {
+      await renderer.unmount()
+    }
+    expect(history()).toEqual({ past: before.past + 2, tracking: true, depth: 0 })
+    expect(levelItems()).toHaveLength(itemsBefore + 2)
+    useScene.temporal.getState().undo()
+    expect(levelItems()).toHaveLength(itemsBefore + 1)
+    expect(liveItem()).toEqual(item)
+  })
+
+  test('a setup failure cannot leave history paused', async () => {
+    const before = history()
+    const reportError = globalThis.reportError
+    const consoleError = console.error
+    globalThis.reportError = () => {}
+    console.error = () => {}
+    try {
+      const renderer = await create(
+        <SetupBoundary>
+          <Placement failSetup source={item} />
+        </SetupBoundary>,
+      )
+      await renderer.unmount()
+    } finally {
+      globalThis.reportError = reportError
+      console.error = consoleError
+    }
+    expect(history()).toEqual({ past: before.past, tracking: true, depth: 0 })
+  })
+})
+
+describe('item placement selection', () => {
+  // A surface `:click` is synthesized on pointer-up (use-node-events), and the browser fires its
+  // own click after it. By then the editor is back in select mode, where the grid takes that click
+  // for one on empty ground and drops the selection of the item just placed.
+  test('a drop on pointer-up selects the new item and eats the click that follows', async () => {
+    const renderer = await create(<Placement />)
+    try {
+      await carry(10, 14)
+      const dropOnRelease = () =>
+        emitter.emit('node:click', {
+          node: { id: 'site_placement_history', type: 'site' },
+          position: [1.4, 0, 0.5],
+          localPosition: [1.4, 0, 0.5],
+          nativeEvent: { nativeEvent: {} },
+          stopPropagation() {},
+        } as never)
+      window.addEventListener('pointerup', dropOnRelease)
+      await act(async () => {
+        window.dispatchEvent(new Event('pointerup'))
+      })
+      window.removeEventListener('pointerup', dropOnRelease)
+      const placed = levelItems().find((node) => node.id !== item.id)
+      expect(placed).toBeDefined()
+      expect(useViewer.getState().selection.selectedIds).toEqual([placed!.id])
+      const click = new Event('click', { cancelable: true })
+      window.dispatchEvent(click)
+      expect(click.defaultPrevented).toBe(true)
+      // Only that one click: once the swallow window closes, a click reaches the editor again.
+      await new Promise((resolve) => setTimeout(resolve, 350))
+      const next = new Event('click', { cancelable: true })
+      window.dispatchEvent(next)
+      expect(next.defaultPrevented).toBe(false)
+    } finally {
+      await renderer.unmount()
+    }
+  })
+})

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

@@ -1,6 +1,8 @@
 import { beforeEach, describe, expect, test } from 'bun:test'
 import {
   BlockNode,
+  type CeilingEvent,
+  type CeilingNode,
   type GridEvent,
   ItemNode,
   type LevelNode,
@@ -10,7 +12,12 @@ import {
   type WallNode,
 } from '@pascal-app/core'
 import { BufferGeometry, Mesh, MeshBasicMaterial, type Object3D, Vector3 } from 'three'
-import { faceHostStrategy, floorStrategy, wallStrategy } from './placement-strategies'
+import {
+  ceilingStrategy,
+  faceHostStrategy,
+  floorStrategy,
+  wallStrategy,
+} from './placement-strategies'
 import type { PlacementContext, SpatialValidators } from './placement-types'
 import { registerTestBlockFaceHost } from './test-face-host'
 
@@ -492,3 +499,41 @@ describe('floorStrategy.move', () => {
     expect(result.nodeUpdate?.position?.[1]).toBe(0)
   })
 })
+
+describe('ceilingStrategy.move', () => {
+  const ceiling = { id: 'ceiling_test', type: 'ceiling' } as unknown as CeilingNode
+  const ceilingEvent = (): CeilingEvent =>
+    ({
+      node: ceiling,
+      position: [1, 2.5, 1],
+      localPosition: [1, 0, 1],
+      object: new Mesh(),
+      stopPropagation: () => {},
+    }) as unknown as CeilingEvent
+  const onCeiling = (draftItem: ItemNode): PlacementContext => ({
+    ...ceilingContext(),
+    asset: draftItem.asset,
+    draftItem,
+    state: { ...ceilingContext().state, surface: 'ceiling', ceilingId: ceiling.id },
+  })
+  const hanging = (source?: unknown) =>
+    ({
+      ...makeDraft(),
+      asset: { ...makeDraft().asset, attachTo: 'ceiling', dimensions: [0.9, 1, 0.6] },
+      ...(source ? { source } : {}),
+    }) as unknown as ItemNode
+
+  test('hangs a catalog model its full height below the ceiling', () => {
+    const result = ceilingStrategy.move(onCeiling(hanging()), ceilingEvent())
+    expect(result?.gridPosition[1]).toBeCloseTo(-1, 6)
+  })
+
+  test('hangs a scripted object from its top, where the compiler put its origin', () => {
+    const source = {
+      kind: 'script',
+      manifest: { bounds: { min: [-0.45, -1, -0.3], max: [0.45, 0, 0.3] } },
+    }
+    const result = ceilingStrategy.move(onCeiling(hanging(source)), ceilingEvent())
+    expect(result?.gridPosition[1]).toBeCloseTo(0, 6)
+  })
+})

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

@@ -15,11 +15,14 @@ import type {
   WallNode,
 } from '@pascal-app/core'
 import {
+  ceilingSeatY,
   clampRectToRoofWallFace,
   clearFaceHostItemFields,
   createSceneApi,
   getRoofSegmentWallFace,
   getScaledDimensions,
+  getWallBodyCenterOffset,
+  getWallLocalFaceZ,
   nodeRegistry,
   resolveSurfacePlacement,
   roofFacePointToSegment,
@@ -168,7 +171,9 @@ function resolveWallPlacementPose(
   cursorRotationY: number
 } {
   const localZ =
-    attachTo === 'wall-side' ? ((event.node.thickness ?? 0.1) / 2) * (side === 'front' ? 1 : -1) : 0
+    attachTo === 'wall-side'
+      ? getWallLocalFaceZ(event.node, side === 'front' ? 'a' : 'b')
+      : getWallBodyCenterOffset(event.node)
   event.object.updateWorldMatrix(true, false)
   const world = event.object.localToWorld(new Vector3(localX, localY, localZ))
   const wallYaw = -Math.atan2(
@@ -176,7 +181,7 @@ function resolveWallPlacementPose(
     event.node.end[0] - event.node.start[0],
   )
   return {
-    position: [localX, localY, localZ],
+    position: [localX, localY, attachTo === 'wall' ? 0 : localZ],
     cursorPosition: [world.x, world.y, world.z],
     // Same composition the 2D floorplan resolves a wall child with
     // (`resolveItemTransform`): the cursor frame IS the item frame.
@@ -428,7 +433,7 @@ function resolveRoofWallTarget(
   const u = snapToHalf(hit.u)
   const centerV = snapToHalf(hit.v) + height / 2
   const fitted = freePlace ? null : clampRectToRoofWallFace(hit.face, u, centerV, width, height)
-  if (!fitted && !freePlace) return null
+  if (!(fitted || freePlace)) return null
   const finalU = fitted?.u ?? u
   const finalV = fitted?.v ?? centerV
 
@@ -559,7 +564,7 @@ export const roofWallStrategy = {
     if (!(ctx.draftItem && ctx.state.roofSegmentId)) return null
     // Alt mirrors the wall flow's stubbed validators: skip profile-fit
     // and overlap checks entirely.
-    if (!freePlace && !canPlaceOnRoofWall(ctx)) return null
+    if (!(freePlace || canPlaceOnRoofWall(ctx))) return null
 
     return {
       nodeUpdate: {
@@ -743,9 +748,7 @@ export const ceilingStrategy = {
     // use the ceiling hit's local position rather than world position.
     const x = snapToGrid(event.localPosition[0], swapDims ? dimZ : dimX)
     const z = snapToGrid(event.localPosition[2], swapDims ? dimX : dimZ)
-    // Recessed fixtures seat flush with the ceiling plane (body rising into the
-    // void above); everything else hangs its full height below the ceiling.
-    const seatY = ctx.asset.recessed ? 0 : -itemHeight
+    const seatY = ceilingSeatY(ctx.draftItem ?? { asset: ctx.asset }, itemHeight)
     const worldSnapped = event.object.localToWorld(new Vector3(x, seatY, z))
 
     return {
@@ -777,9 +780,7 @@ export const ceilingStrategy = {
 
     const x = snapToGrid(event.localPosition[0], swapDims ? dimZ : dimX)
     const z = snapToGrid(event.localPosition[2], swapDims ? dimX : dimZ)
-    // Recessed fixtures seat flush with the ceiling plane (body rising into the
-    // void above); everything else hangs its full height below the ceiling.
-    const seatY = ctx.draftItem.asset.recessed ? 0 : -itemHeight
+    const seatY = ceilingSeatY(ctx.draftItem, itemHeight)
     const worldSnapped = event.object.localToWorld(new Vector3(x, seatY, z))
 
     return {