@pascal-app/editor 0.9.2 → 1.0.0-beta.2

package/src/components/editor-2d/renderers/floorplan-stair-layer.tsx

@@ -95,6 +95,10 @@ function getFloorplanStairStepCount(stair: StairNode, minimum: number) {
   return Math.max(minimum, Math.round(stair.stepCount ?? 10))
 }
 
+function getFloorplanStairBreakStep(stepCount: number) {
+  return Math.max(1, Math.ceil(Math.max(1, Math.round(stepCount)) * 0.68))
+}
+
 function getFloorplanSpiralLandingSweep(stair: StairNode, sweepAngle: number) {
   if (stair.stairType !== 'spiral' || (stair.topLandingMode ?? 'none') !== 'integrated') {
     return 0
@@ -244,14 +248,15 @@ export const FloorplanStairLayer = memo(function FloorplanStairLayer({
                 const angle = sectorStartAngle + stepSweep * index
                 const innerPoint = getArcPlanPoint(stairCenter, innerRadius, angle)
                 const outerPoint = getArcPlanPoint(stairCenter, outerRadius, angle)
-                const dashedFromIndex = Math.floor(stepCount * 0.68)
+                if (index >= getFloorplanStairBreakStep(stepCount) && index !== stepCount) {
+                  return null
+                }
 
                 return (
                   <line
                     key={`${stair.id}:spiral-step:${index}`}
                     pointerEvents="none"
                     stroke={index === stepCount ? curvedAccent : curvedStroke}
-                    strokeDasharray={index >= dashedFromIndex ? '0.1 0.08' : undefined}
                     strokeWidth={index === stepCount ? '1.8' : '1.15'}
                     vectorEffect="non-scaling-stroke"
                     x1={toSvgX(innerPoint.x)}
@@ -330,6 +335,9 @@ export const FloorplanStairLayer = memo(function FloorplanStairLayer({
                 const angle = sectorStartAngle + stepSweep * index
                 const innerPoint = getArcPlanPoint(stairCenter, innerRadius, angle)
                 const outerPoint = getArcPlanPoint(stairCenter, outerRadius, angle)
+                if (index >= getFloorplanStairBreakStep(stepCount) && index !== stepCount) {
+                  return null
+                }
 
                 return (
                   <line
@@ -397,14 +405,16 @@ export const FloorplanStairLayer = memo(function FloorplanStairLayer({
                     strokeWidth={isSelectionActive ? '2' : '1.35'}
                     vectorEffect="non-scaling-stroke"
                   />
-                  {treadBars.map((treadBar, treadIndex) => (
-                    <polygon
-                      fill={straightTread}
-                      key={`${segment.id}:tread:${treadIndex}`}
-                      pointerEvents="none"
-                      points={segment.segmentType === 'landing' ? '' : treadBar.points}
-                    />
-                  ))}
+                  {treadBars
+                    .slice(0, Math.max(0, getFloorplanStairBreakStep(segment.stepCount) - 1))
+                    .map((treadBar, treadIndex) => (
+                      <polygon
+                        fill={straightTread}
+                        key={`${segment.id}:tread:${treadIndex}`}
+                        pointerEvents="none"
+                        points={segment.segmentType === 'landing' ? '' : treadBar.points}
+                      />
+                    ))}
                 </g>
               ))}
               {arrow?.polyline && arrow.polyline.length >= 2 ? (

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

@@ -3,6 +3,7 @@
 import {
   type CeilingNode,
   emitter,
+  resolveCeilingHeight,
   resolveLevelId,
   sceneRegistry,
   snapPointToGrid,
@@ -151,6 +152,9 @@ const CeilingSelectionAffordance = ({
     () => (liveOverride ? ({ ...ceiling, ...liveOverride } as CeilingNode) : ceiling),
     [ceiling, liveOverride],
   )
+  // Explicit height when stored, else the live level-top bound the ceiling
+  // follows (primitive selector — re-render-safe).
+  const resolvedHeight = useScene((s) => resolveCeilingHeight(effectiveCeiling, s.nodes))
   const [levelObject, setLevelObject] = useState<Object3D | null>(
     () => sceneRegistry.nodes.get(levelId) ?? null,
   )
@@ -221,7 +225,7 @@ const CeilingSelectionAffordance = ({
       )
       raycasterRef.current.setFromCamera(ndcRef.current, camera)
 
-      planePointRef.current.set(0, (effectiveCeiling.height ?? 2.5) + BRACKET_Y_OFFSET, 0)
+      planePointRef.current.set(0, resolvedHeight + BRACKET_Y_OFFSET, 0)
       levelObject.localToWorld(planePointRef.current)
 
       planeOriginRef.current.set(0, 0, 0)
@@ -238,7 +242,7 @@ const CeilingSelectionAffordance = ({
       levelObject.worldToLocal(localIntersectionRef.current)
       return [localIntersectionRef.current.x, localIntersectionRef.current.z]
     },
-    [camera, effectiveCeiling.height, gl.domElement, levelObject],
+    [camera, resolvedHeight, gl.domElement, levelObject],
   )
 
   const handleCornerPointerDown = useCallback(
@@ -438,10 +442,7 @@ const CeilingSelectionAffordance = ({
   if (!levelObject || corners.length === 0) return null
 
   return createPortal(
-    <group
-      position={[0, (effectiveCeiling.height ?? 2.5) + BRACKET_Y_OFFSET, 0]}
-      ref={bracketsRootRef}
-    >
+    <group position={[0, resolvedHeight + BRACKET_Y_OFFSET, 0]} ref={bracketsRootRef}>
       {corners.map((corner, index) => (
         <CornerBracket
           ceiling={effectiveCeiling}
@@ -507,7 +508,11 @@ const CornerBracket = ({
       node: ceiling,
       nativeEvent: e.nativeEvent,
       localPosition: [0, 0, 0],
-      position: [corner.corner[0], ceiling.height ?? 2.5, corner.corner[1]],
+      position: [
+        corner.corner[0],
+        resolveCeilingHeight(ceiling, useScene.getState().nodes),
+        corner.corner[1],
+      ],
       stopPropagation: () => e.stopPropagation(),
       viaHandle: true,
     })

package/src/components/tools/fence/fence-drafting.ts

@@ -5,6 +5,7 @@ import {
   getWallCurveFrameAt,
   getWallCurveLength,
   isCurvedWall,
+  resolveFenceSupportSlabPatch,
   snapPointAlongAngleRay,
   useScene,
   type WallNode,
@@ -187,9 +188,22 @@ export function snapFenceDraftPoint(args: {
   return fenceSnapTarget ?? findWallSnapTarget(basePoint, walls) ?? basePoint
 }
 
+export type FenceCommitOptions = {
+  /**
+   * Pointer-decided support cap (level-local Y) from
+   * `resolvePointerSupportSurface` — the 3D tool passes the elevation of
+   * the surface the commit click actually aimed at, so a fence drawn on a
+   * deck top persists the deck as its lift host while one drawn at the
+   * floor underneath stays grounded. Omitted by 2D floor-plan commits (no
+   * camera ray): those keep the uncapped max election.
+   */
+  supportCap?: number | null
+}
+
 export function createFenceOnCurrentLevel(
   start: FencePlanPoint,
   end: FencePlanPoint,
+  options?: FenceCommitOptions,
 ): FenceNode | null {
   const currentLevelId = useViewer.getState().selection.levelId
   const { createNode, nodes } = useScene.getState()
@@ -209,6 +223,13 @@ export function createFenceOnCurrentLevel(
     start,
     end,
   })
+  // Fences run no per-frame support election — the persisted host IS the
+  // lift (absent = level floor), so elect it at commit, pointer-capped.
+  fence.supportSlabId = resolveFenceSupportSlabPatch(
+    { ...fence, parentId: currentLevelId },
+    nodes,
+    { maxElevation: options?.supportCap ?? null },
+  ).supportSlabId
 
   createNode(fence, currentLevelId)
   sfxEmitter.emit('sfx:structure-build')
@@ -225,6 +246,7 @@ export function createFenceOnCurrentLevel(
 export function createSplineFenceOnCurrentLevel(
   path: FencePlanPoint[],
   tangents = getTwoPointFenceCurveTangents(path),
+  options?: FenceCommitOptions,
 ): FenceNode | null {
   const currentLevelId = useViewer.getState().selection.levelId
   const { createNode, nodes } = useScene.getState()
@@ -250,6 +272,11 @@ export function createSplineFenceOnCurrentLevel(
     path,
     tangents,
   })
+  fence.supportSlabId = resolveFenceSupportSlabPatch(
+    { ...fence, parentId: currentLevelId },
+    nodes,
+    { maxElevation: options?.supportCap ?? null },
+  ).supportSlabId
 
   createNode(fence, currentLevelId)
   sfxEmitter.emit('sfx:structure-build')

package/src/components/tools/item/use-draft-node.ts

@@ -2,12 +2,14 @@ import {
   type AnyNodeId,
   type AssetInput,
   ItemNode,
+  resolveSupportSlabPatch,
   sceneRegistry,
   useScene,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { useCallback, useMemo, useRef } from 'react'
 import type { Vector3 } from 'three'
+import usePlacementPreview from '../../../store/use-placement-preview'
 import { stripTransient } from './placement-math'
 
 interface OriginalState {
@@ -38,8 +40,14 @@ export interface DraftNodeHandle {
   ) => ItemNode | null
   /** Take ownership of an existing scene node as the draft (for move mode). */
   adopt: (node: ItemNode) => void
-  /** Commit the current draft. Create mode: delete+recreate. Move mode: update in place. */
-  commit: (finalUpdate: Partial<ItemNode>) => string | null
+  /** Commit the current draft. Create mode: delete+recreate. Move mode: update in place.
+   *  `supportElevationCap` (floor commits) is the pointer-decided surface
+   *  elevation — it caps the persisted `supportSlabId` election so the
+   *  commit lands on the surface the cursor pointed at. */
+  commit: (
+    finalUpdate: Partial<ItemNode>,
+    options?: { supportElevationCap?: number | null },
+  ) => string | null
   /** Destroy the current draft. Create mode: delete node. Move mode: restore original state. */
   destroy: () => void
 }
@@ -80,6 +88,9 @@ export function useDraftNode(): DraftNodeHandle {
       })
 
       useScene.getState().createNode(node, currentLevelId)
+      usePlacementPreview
+        .getState()
+        .set(node, useScene.getState().nodes[currentLevelId as AnyNodeId] ?? null)
       draftRef.current = node
       adoptedRef.current = false
       originalStateRef.current = null
@@ -112,100 +123,142 @@ export function useDraftNode(): DraftNodeHandle {
     useScene.getState().updateNode(node.id, {
       metadata: { ...meta, isTransient: true },
     })
+    usePlacementPreview
+      .getState()
+      .set(
+        node,
+        node.parentId ? (useScene.getState().nodes[node.parentId as AnyNodeId] ?? null) : null,
+      )
   }, [])
 
-  const commit = useCallback((finalUpdate: Partial<ItemNode>): string | null => {
-    const draft = draftRef.current
-    if (!draft) return null
+  const commit = useCallback(
+    (
+      finalUpdate: Partial<ItemNode>,
+      options?: { supportElevationCap?: number | null },
+    ): string | null => {
+      const draft = draftRef.current
+      if (!draft) return null
+
+      if (adoptedRef.current) {
+        // Move mode: update in place (single undoable action)
+        const { parentId: newParentId, ...updateProps } = finalUpdate
+        const parentId =
+          newParentId ??
+          originalStateRef.current?.parentId ??
+          useViewer.getState().selection.levelId
+        const original = originalStateRef.current!
+
+        // Restore original state while paused — so the undo baseline is clean
+        useScene.getState().updateNode(draft.id, {
+          position: original.position,
+          rotation: original.rotation,
+          side: original.side,
+          parentId: original.parentId,
+          roofSegmentId: original.roofSegmentId,
+          roofFace: original.roofFace,
+          metadata: original.metadata,
+        })
+
+        // Resume → tracked update (undo reverts to original)
+        useScene.temporal.getState().resume()
+
+        const effectiveNode = ItemNode.parse({
+          ...draft,
+          ...updateProps,
+          parentId,
+          metadata: updateProps.metadata ?? stripTransient(draft.metadata),
+        })
+
+        useScene.getState().updateNode(draft.id, {
+          position: updateProps.position ?? draft.position,
+          rotation: updateProps.rotation ?? draft.rotation,
+          side: updateProps.side ?? draft.side,
+          metadata: updateProps.metadata ?? stripTransient(draft.metadata),
+          parentId: parentId as string,
+          // Forward the roof host explicitly: strategies set it on every
+          // commit (segment id on a roof face, undefined elsewhere), and
+          // dropping it here strands the item in the roof frame without
+          // the segment transform.
+          roofSegmentId: updateProps.roofSegmentId,
+          roofFace: updateProps.roofFace,
+          // Only when the strategy decided about wallId (roof commits clear
+          // it) — floor/ceiling commits never managed the field.
+          ...('wallId' in updateProps ? { wallId: updateProps.wallId } : {}),
+          ...resolveSupportSlabPatch(effectiveNode, useScene.getState().nodes, {
+            maxElevation: options?.supportElevationCap,
+          }),
+        })
+
+        useScene.temporal.getState().pause()
+
+        const id = draft.id
+        if (usePlacementPreview.getState().node?.id === id) {
+          usePlacementPreview.getState().clear()
+        }
+        draftRef.current = null
+        adoptedRef.current = false
+        originalStateRef.current = null
+        return id
+      }
 
-    if (adoptedRef.current) {
-      // Move mode: update in place (single undoable action)
+      // Create mode: delete draft (paused), resume, create fresh node (tracked), re-pause
       const { parentId: newParentId, ...updateProps } = finalUpdate
-      const parentId =
-        newParentId ?? originalStateRef.current?.parentId ?? useViewer.getState().selection.levelId
-      const original = originalStateRef.current!
+      const parentId = (newParentId ?? useViewer.getState().selection.levelId) as AnyNodeId
+      if (!parentId) return null
 
-      // Restore original state while paused — so the undo baseline is clean
-      useScene.getState().updateNode(draft.id, {
-        position: original.position,
-        rotation: original.rotation,
-        side: original.side,
-        parentId: original.parentId,
-        roofSegmentId: original.roofSegmentId,
-        roofFace: original.roofFace,
-        metadata: original.metadata,
-      })
+      // Delete draft while paused (invisible to undo)
+      useScene.getState().deleteNode(draft.id)
+      draftRef.current = null
 
-      // Resume → tracked update (undo reverts to original)
+      // Briefly resume → create fresh node (the single undoable action)
       useScene.temporal.getState().resume()
 
-      useScene.getState().updateNode(draft.id, {
+      const finalNode = ItemNode.parse({
+        name: draft.name,
+        asset: draft.asset,
         position: updateProps.position ?? draft.position,
         rotation: updateProps.rotation ?? draft.rotation,
+        scale: updateProps.scale ?? draft.scale,
         side: updateProps.side ?? draft.side,
-        metadata: updateProps.metadata ?? stripTransient(draft.metadata),
-        parentId: parentId as string,
-        // Forward the roof host explicitly: strategies set it on every
-        // commit (segment id on a roof face, undefined elsewhere), and
-        // dropping it here strands the item in the roof frame without
-        // the segment transform.
+        // Carry painted slot overrides so a duplicated item keeps its materials.
+        ...(draft.slots ? { slots: draft.slots } : {}),
+        // Roof host — see the move-mode commit above for why this must be
+        // forwarded explicitly.
         roofSegmentId: updateProps.roofSegmentId,
         roofFace: updateProps.roofFace,
-        // Only when the strategy decided about wallId (roof commits clear
-        // it) — floor/ceiling commits never managed the field.
         ...('wallId' in updateProps ? { wallId: updateProps.wallId } : {}),
+        metadata: updateProps.metadata ?? stripTransient(draft.metadata),
+        parentId,
+      })
+      const nodes = useScene.getState().nodes
+      const committedNode = ItemNode.parse({
+        ...finalNode,
+        ...resolveSupportSlabPatch(
+          finalNode,
+          { ...nodes, [finalNode.id]: finalNode },
+          { maxElevation: options?.supportElevationCap },
+        ),
       })
+      useScene.getState().createNode(committedNode, parentId)
+      if (usePlacementPreview.getState().node?.id === draft.id) {
+        usePlacementPreview.getState().clear()
+      }
 
+      // Re-pause for next draft cycle
       useScene.temporal.getState().pause()
 
-      const id = draft.id
-      draftRef.current = null
       adoptedRef.current = false
       originalStateRef.current = null
-      return id
-    }
-
-    // Create mode: delete draft (paused), resume, create fresh node (tracked), re-pause
-    const { parentId: newParentId, ...updateProps } = finalUpdate
-    const parentId = (newParentId ?? useViewer.getState().selection.levelId) as AnyNodeId
-    if (!parentId) return null
-
-    // Delete draft while paused (invisible to undo)
-    useScene.getState().deleteNode(draft.id)
-    draftRef.current = null
-
-    // Briefly resume → create fresh node (the single undoable action)
-    useScene.temporal.getState().resume()
-
-    const finalNode = ItemNode.parse({
-      name: draft.name,
-      asset: draft.asset,
-      position: updateProps.position ?? draft.position,
-      rotation: updateProps.rotation ?? draft.rotation,
-      scale: updateProps.scale ?? draft.scale,
-      side: updateProps.side ?? draft.side,
-      // Carry painted slot overrides so a duplicated item keeps its materials.
-      ...(draft.slots ? { slots: draft.slots } : {}),
-      // Roof host — see the move-mode commit above for why this must be
-      // forwarded explicitly.
-      roofSegmentId: updateProps.roofSegmentId,
-      roofFace: updateProps.roofFace,
-      ...('wallId' in updateProps ? { wallId: updateProps.wallId } : {}),
-      metadata: updateProps.metadata ?? stripTransient(draft.metadata),
-    })
-    useScene.getState().createNode(finalNode, parentId)
-
-    // Re-pause for next draft cycle
-    useScene.temporal.getState().pause()
-
-    adoptedRef.current = false
-    originalStateRef.current = null
-    return finalNode.id
-  }, [])
+      return committedNode.id
+    },
+    [],
+  )
 
   const destroy = useCallback(() => {
     if (!draftRef.current) return
 
+    const draftId = draftRef.current.id
+
     if (adoptedRef.current && originalStateRef.current) {
       // Move mode: restore original state instead of deleting — but only
       // if no other system has already committed a new position for this
@@ -227,6 +280,9 @@ export function useDraftNode(): DraftNodeHandle {
         draftRef.current = null
         adoptedRef.current = false
         originalStateRef.current = null
+        if (usePlacementPreview.getState().node?.id === draftId) {
+          usePlacementPreview.getState().clear()
+        }
         return
       }
 
@@ -257,6 +313,9 @@ export function useDraftNode(): DraftNodeHandle {
     draftRef.current = null
     adoptedRef.current = false
     originalStateRef.current = null
+    if (usePlacementPreview.getState().node?.id === draftId) {
+      usePlacementPreview.getState().clear()
+    }
   }, [])
 
   return useMemo(

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

@@ -62,6 +62,10 @@ import {
   type PreviewBounds,
   updateLineGeometry,
 } from '../shared/placement-box-geometry'
+import {
+  resolvePointerSupportElevation,
+  resolvePointerSupportSurface,
+} from '../shared/pointer-support-cap'
 import {
   getDetachedAttachmentPreviewLift,
   getGridAlignedDimensions,
@@ -269,6 +273,13 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
   const raycastDisabledMeshRef = useRef<Object3D | null>(null)
   const restoreRaycastsRef = useRef<Array<() => void>>([])
   const raycastDisabledChildrenRef = useRef(new WeakSet<Object3D>())
+  // Level-local elevation of the surface the pointer ray actually points
+  // at (deck top, floor slab, or ground), refreshed on every grid move.
+  // Threaded into the floor-support election as its cap so the POINTER
+  // decides the target surface — without it the election lifts the ghost
+  // by the MAX overlapping slab and a deck above the aimed-at floor
+  // captures the item (and the grid-plane feedback makes it blink).
+  const pointerSupportCapRef = useRef<number | null>(null)
   const [dimensionBounds, setDimensionBounds] = useState<PreviewBounds | null>(null)
 
   // Live camera ref — the shelf-stickiness test reconstructs the cursor world
@@ -420,6 +431,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
         node: previewNode,
         position,
         rotation: previewNode.rotation,
+        maxElevation: pointerSupportCapRef.current,
       })
     },
     [asset?.attachTo, draftNode],
@@ -449,6 +461,9 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       surfaceItemId: null,
       shelfId: null,
     }
+    // No pointer surface known yet — fall back to the uncapped election
+    // (an adopted move draft keeps its persisted host until the first move).
+    pointerSupportCapRef.current = null
     if (!asset.attachTo && placementState.current.surface === 'floor') {
       gridPosition.current.y = 0
       if (cursorGroupRef.current) {
@@ -848,6 +863,22 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
 
       has3DPointerDrivenMoveRef.current = true
 
+      // The pointer decides the target surface AND the floor point: cap
+      // the floor-support election at the elevation of the surface the
+      // camera ray actually hits, and re-aim the event at the ray's
+      // crossing of that surface's plane. The grid event's own hit can't
+      // be used directly — its plane rides at the ghost's last height, so
+      // its Y is a feedback loop (the under-deck blink) and its XZ is
+      // perspective-skewed along the ray whenever the plane sits on a
+      // different storey than the pointed surface (the skew is what made
+      // a drag over a deck-above-a-floor hop between the two surfaces).
+      const pointed = resolvePointerSupportSurface(cameraRef.current, event.position)
+      pointerSupportCapRef.current = pointed?.elevation ?? null
+      const surfaceEvent: GridEvent =
+        pointed?.worldPoint && pointed.localPoint
+          ? { ...event, position: pointed.worldPoint, localPosition: pointed.localPoint }
+          : event
+
       // Shelf stickiness: while hosting on a shelf, ignore floor events while
       // the cursor ray still points at the shelf volume (the ray merely slipped
       // off a board / through a gap and hit the floor behind). Detach to the
@@ -855,10 +886,12 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       // item oscillates between the shelf row and the floor on every micro-move.
       if (placementState.current.surface === 'shelf-surface') {
         if (cursorRayIntersectsActiveShelf(event.position)) return
-        detachItemSurfaceToFloor(event as unknown as ItemEvent)
+        // Land at the pointed surface's plan point — the raw grid hit is
+        // still skewed by the plane riding at the shelf-surface height.
+        detachItemSurfaceToFloor(surfaceEvent as unknown as ItemEvent)
       }
 
-      const floorEvent = applyFloorGrabOffset(event)
+      const floorEvent = applyFloorGrabOffset(surfaceEvent)
 
       lastRawPos.current.set(
         floorEvent.localPosition[0],
@@ -941,11 +974,13 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
 
       if (draft) draft.position = gridPos
 
-      // Publish live transform for 2D floorplan
+      // Publish live transform for 2D floorplan (and the pointer surface
+      // cap, so FloorElevationSystem's per-frame Y agrees with the ghost).
       if (draft) {
         useLiveTransforms.getState().set(draft.id, {
           position: gridPos,
           rotation: cursorGroupRef.current.rotation.y,
+          supportElevationCap: pointerSupportCapRef.current ?? undefined,
         })
       }
 
@@ -973,7 +1008,12 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
 
       const committedId = draftNode.current?.id ?? null
       const wasAdopted = draftNode.isAdopted
-      const finalId = draftNode.commit(result.nodeUpdate)
+      // Carry the pointer surface cap into the commit so the persisted
+      // supportSlabId reproduces the capped election (elects the aimed-at
+      // lower slab — or the ground — instead of a deck hanging above).
+      const finalId = draftNode.commit(result.nodeUpdate, {
+        supportElevationCap: pointerSupportCapRef.current,
+      })
       finishCommittedPlacement(finalId ?? committedId, wasAdopted, () => {
         draftNode.create(
           gridPosition.current,
@@ -1392,6 +1432,14 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
 
     const detachItemSurfaceToFloor = (event: ItemEvent) => {
       hostSurfaceDragAnchor = null
+      // Landing back on the floor: refresh the pointer surface cap from
+      // this event's world hit so the first floor position already targets
+      // the aimed-at surface (not a deck above it).
+      pointerSupportCapRef.current = resolvePointerSupportElevation(cameraRef.current, [
+        event.position[0],
+        event.position[1],
+        event.position[2],
+      ])
       // Coming back from a host: forget the floor grab too, so the item
       // centers under the cursor instead of restoring the pre-drag offset —
       // and landing on the floor is "anchoring elsewhere", so a later return