@pascal-app/editor 1.0.0-beta.5 → 1.0.1

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

@@ -4,8 +4,8 @@ import type {
   CeilingEvent,
   CeilingNode,
   GridEvent,
-  ItemEvent,
   ItemNode,
+  NodeEvent,
   RoofEvent,
   RoofNode,
   RoofSegmentNode,
@@ -16,19 +16,20 @@ import type {
   WallNode,
 } from '@pascal-app/core'
 import {
-  canHostOnTop,
   clampRectToRoofWallFace,
+  createSceneApi,
   getRoofSegmentWallFace,
   getScaledDimensions,
-  isLowProfileItemSurface,
   nodeRegistry,
+  resolveSurfacePlacement,
   roofFacePointToSegment,
   sceneRegistry,
   useScene,
 } from '@pascal-app/core'
-import { Euler, Matrix3, Quaternion, Vector3 } from 'three'
+import { Euler, Quaternion, Vector3 } from 'three'
 import { hasRoofFaceChildOverlap, resolveRoofWallHit } from '../../../lib/roof-wall-hit'
 import { snapWorldXZForActiveBuilding } from '../../../lib/world-grid-snap'
+import { itemEventToSurfaceHit, surfaceWorldNormalY } from '../shared/surface-hit'
 import {
   calculateItemRotation,
   getGridAlignedDimensions,
@@ -48,42 +49,14 @@ import type {
 } from './placement-types'
 
 const DEFAULT_DIMENSIONS: [number, number, number] = [1, 1, 1]
-const UPWARD_SURFACE_NORMAL_MIN_Y = 0.75
-
-function getWorldNormalY(event: ItemEvent): number | null {
-  if (!event.normal) return null
-
-  const normal = new Vector3(event.normal[0], event.normal[1], event.normal[2])
-  normal.applyNormalMatrix(new Matrix3().getNormalMatrix(event.object.matrixWorld)).normalize()
-  return normal.y
-}
-
-function isUpwardItemSurfaceHit(event: ItemEvent): boolean {
-  const normalY = getWorldNormalY(event)
-  return normalY !== null && normalY >= UPWARD_SURFACE_NORMAL_MIN_Y
-}
-
-function getSurfacePlacementHeight(surfaceItem: ItemNode, event: ItemEvent, localPos: Vector3) {
-  if (!canHostOnTop(surfaceItem)) return null
-  if (isLowProfileItemSurface(surfaceItem)) return null
-  if (!isUpwardItemSurfaceHit(event)) return null
-
-  if (surfaceItem.asset.surface) {
-    return surfaceItem.asset.surface.height * surfaceItem.scale[1]
-  }
-
-  if (!Number.isFinite(localPos.y)) return null
-  return localPos.y
-}
-
 function isDescendantOfItem(
-  candidate: ItemNode,
-  ancestor: ItemNode,
+  candidate: AnyNode,
+  ancestorId: string,
   nodes: Record<string, AnyNode>,
 ): boolean {
   let parentId = candidate.parentId
   while (parentId) {
-    if (parentId === ancestor.id) return true
+    if (parentId === ancestorId) return true
     const parent = nodes[parentId as AnyNodeId]
     parentId = parent?.parentId ?? null
   }
@@ -268,13 +241,18 @@ export const wallStrategy = {
     const pose = resolveWallPlacementPose(event, x, adjustedY, attachTo, side, itemRotation)
 
     return {
-      stateUpdate: { surface: 'wall', wallId: event.node.id, roofSegmentId: null },
+      stateUpdate: {
+        surface: 'wall',
+        wallId: event.node.id,
+        roofSegmentId: null,
+      },
       nodeUpdate: {
         position: pose.position,
         parentId: event.node.id,
         // The draft may arrive from a roof-segment wall face.
         roofSegmentId: undefined,
         roofFace: undefined,
+        blockFaceId: undefined,
         side,
         rotation: [0, itemRotation, 0],
       },
@@ -367,6 +345,7 @@ export const wallStrategy = {
         parentId: event.node.id,
         roofSegmentId: undefined,
         roofFace: undefined,
+        blockFaceId: undefined,
         side: ctx.draftItem.side,
         rotation: ctx.draftItem.rotation,
         metadata: stripTransient(ctx.draftItem.metadata),
@@ -520,12 +499,17 @@ export const roofWallStrategy = {
     if (!target) return null
 
     return {
-      stateUpdate: { surface: 'roof-wall', roofSegmentId: target.segment.id, wallId: null },
+      stateUpdate: {
+        surface: 'roof-wall',
+        roofSegmentId: target.segment.id,
+        wallId: null,
+      },
       nodeUpdate: {
         position: target.position,
         parentId: target.segment.id,
         roofSegmentId: target.segment.id,
         roofFace: target.faceId,
+        blockFaceId: undefined,
         wallId: undefined,
         side: 'front',
         rotation: [0, 0, 0],
@@ -583,6 +567,7 @@ export const roofWallStrategy = {
         parentId: ctx.state.roofSegmentId,
         roofSegmentId: ctx.state.roofSegmentId,
         roofFace: ctx.draftItem.roofFace,
+        blockFaceId: undefined,
         wallId: undefined,
         side: 'front',
         rotation: [0, 0, 0],
@@ -615,6 +600,114 @@ export const roofWallStrategy = {
   },
 }
 
+// ============================================================================
+// FACE HOST STRATEGY
+// ============================================================================
+
+function resolveFaceHostTarget(ctx: PlacementContext, event: NodeEvent) {
+  const faceHost = nodeRegistry.get(event.node.type)?.capabilities.faceHost
+  if (!faceHost) return null
+  const rawDimensions = ctx.draftItem
+    ? getScaledDimensions(ctx.draftItem)
+    : (ctx.asset.dimensions ?? DEFAULT_DIMENSIONS)
+  return faceHost.resolvePlacement({
+    host: event.node,
+    asset: ctx.asset,
+    draftItem: ctx.draftItem,
+    localPosition: event.localPosition,
+    faceIndex: event.faceIndex,
+    object: event.object,
+    currentFaceId: faceHost.currentFaceId(ctx.draftItem),
+    rawDimensions,
+    dimensions: getGridAlignedDimensions(rawDimensions, ctx.asset.attachTo),
+    snapScalar: snapToHalf,
+  })
+}
+
+function clearFaceHostItemFields(ctx: PlacementContext): Partial<ItemNode> {
+  const host = ctx.state.blockId ? useScene.getState().nodes[ctx.state.blockId] : undefined
+  const clearFields = host
+    ? nodeRegistry.get(host.type)?.capabilities.faceHost?.clearItemFields
+    : undefined
+  const patch: Partial<ItemNode> = {}
+  for (const field of clearFields ?? []) {
+    ;(patch as Record<string, unknown>)[field] = undefined
+  }
+  return patch
+}
+
+export const faceHostStrategy = {
+  enter(ctx: PlacementContext, event: NodeEvent): TransitionResult | null {
+    const target = resolveFaceHostTarget(ctx, event)
+    if (!target) return null
+    return {
+      stateUpdate: {
+        surface: 'block-face',
+        blockId: event.node.id,
+        wallId: null,
+        roofSegmentId: null,
+      },
+      nodeUpdate: {
+        ...target.nodeUpdate,
+      },
+      gridPosition: target.position,
+      cursorPosition: target.cursorPosition,
+      cursorRotationY: target.cursorRotation[1],
+      cursorRotation: target.cursorRotation,
+      stopPropagation: true,
+      hostFaceId: target.faceId,
+    }
+  },
+
+  move(ctx: PlacementContext, event: NodeEvent): PlacementResult | null {
+    if (ctx.state.surface !== 'block-face' || !ctx.draftItem) return null
+    const target = resolveFaceHostTarget(ctx, event)
+    if (!target || event.node.id !== ctx.state.blockId) return null
+    return {
+      gridPosition: target.position,
+      cursorPosition: target.cursorPosition,
+      cursorRotationY: target.cursorRotation[1],
+      cursorRotation: target.cursorRotation,
+      nodeUpdate: target.nodeUpdate,
+      stopPropagation: true,
+      dirtyNodeId: null,
+      hostFaceId: target.faceId,
+    }
+  },
+
+  click(ctx: PlacementContext, event: NodeEvent): CommitResult | null {
+    if (ctx.state.surface !== 'block-face' || !ctx.draftItem) return null
+    const target = resolveFaceHostTarget(ctx, event)
+    if (!target || event.node.id !== ctx.state.blockId) return null
+    return {
+      nodeUpdate: {
+        ...target.nodeUpdate,
+        metadata: stripTransient(ctx.draftItem.metadata),
+      },
+      stopPropagation: true,
+      dirtyNodeId: null,
+    }
+  },
+
+  leave(ctx: PlacementContext): TransitionResult | null {
+    if (ctx.state.surface !== 'block-face') return null
+    const floorPosition: [number, number, number] = [ctx.gridPosition.x, 0, ctx.gridPosition.z]
+    return {
+      stateUpdate: { surface: 'floor', blockId: null },
+      nodeUpdate: {
+        ...clearFaceHostItemFields(ctx),
+        position: floorPosition,
+        parentId: ctx.levelId,
+        rotation: [0, ctx.currentCursorRotationY, 0],
+      },
+      cursorRotationY: ctx.currentCursorRotationY,
+      gridPosition: floorPosition,
+      cursorPosition: floorPosition,
+      stopPropagation: true,
+    }
+  },
+}
+
 // ============================================================================
 // CEILING STRATEGY
 // ============================================================================
@@ -760,65 +853,114 @@ export const ceilingStrategy = {
 // ITEM SURFACE STRATEGY
 // ============================================================================
 
+function resolveCatalogItemSurfacePlacement(
+  host: AnyNode,
+  event: NodeEvent<AnyNode>,
+  dimensions: [number, number, number],
+  worldYaw: number,
+  onReject?: PlacementContext['onSurfaceReject'],
+  rawEvent = event,
+) {
+  const mesh = sceneRegistry.nodes.get(host.id)
+  if (!mesh) return null
+  const hit = itemEventToSurfaceHit(host, event)
+  if (!hit) return null
+  const quaternion = mesh.getWorldQuaternion(new Quaternion())
+  const hostYaw = new Euler().setFromQuaternion(quaternion, 'YXZ').y
+  const placement = resolveSurfacePlacement({
+    host,
+    childKind: 'item',
+    childFootprint: { size: dimensions, rotationY: worldYaw - hostYaw },
+    hit: host.type === 'procedural-item' ? (itemEventToSurfaceHit(host, rawEvent) ?? hit) : hit,
+    origin: host.type === 'procedural-item' ? hit.point : undefined,
+    scene: createSceneApi(useScene),
+    snapScalar: snapToGrid,
+    checkFootprint: true,
+    onReject,
+  })
+  if (!placement) return null
+  return {
+    position: [...placement.position] as [number, number, number],
+    rotationY: placement.rotationY,
+    surfaceId: placement.surfaceId,
+    worldPosition: mesh.localToWorld(new Vector3(...placement.position)).toArray(),
+  }
+}
+
+export function validCatalogCounterPose(ctx: PlacementContext): boolean {
+  const hostId = ctx.state.surface === 'shelf-surface' ? ctx.state.shelfId : ctx.state.surfaceItemId
+  const host = hostId ? useScene.getState().nodes[hostId as AnyNodeId] : undefined
+  if (
+    host?.type !== 'cabinet' &&
+    host?.type !== 'shelf' &&
+    host?.type !== 'item' &&
+    host?.type !== 'procedural-item'
+  )
+    return true
+  if (!ctx.draftItem) return false
+  const placement = resolveSurfacePlacement({
+    host,
+    childKind: 'item',
+    childFootprint: {
+      size: getScaledDimensions(ctx.draftItem),
+      rotationY: ctx.draftItem.rotation[1],
+      rotation: ctx.draftItem.rotation,
+    },
+    hit: { point: ctx.gridPosition.toArray(), normalWorldY: 1 },
+    scene: createSceneApi(useScene),
+    onReject: ctx.onSurfaceReject,
+  })
+  return (
+    !!placement &&
+    (host.type !== 'cabinet' || Math.abs(placement.position[1] - ctx.gridPosition.y) < 1e-5)
+  )
+}
+
 export const itemSurfaceStrategy = {
   /**
    * Handle item:enter — transition from floor to an item surface.
    * Returns null if: item has no surface, our item doesn't fit, or it's the draft itself.
    */
-  enter(ctx: PlacementContext, event: ItemEvent): TransitionResult | null {
+  enter(ctx: PlacementContext, event: NodeEvent<AnyNode>): TransitionResult | null {
     // Only floor items can be placed on surfaces
     if (ctx.asset.attachTo) return null
 
-    const surfaceItem = event.node as ItemNode
+    const surfaceItem = event.node
     // Don't surface-place on the draft itself
     if (surfaceItem.id === ctx.draftItem?.id) return null
     if (ctx.state.surface === 'item-surface' && ctx.state.surfaceItemId === surfaceItem.id) {
       return null
     }
-    const nodes = useScene.getState().nodes
-    if (ctx.draftItem && isDescendantOfItem(surfaceItem, ctx.draftItem, nodes)) return null
-
-    // Size check: our footprint must fit on surface item's footprint
     const ourDims = ctx.draftItem
       ? getScaledDimensions(ctx.draftItem)
       : (ctx.asset.dimensions ?? DEFAULT_DIMENSIONS)
-    const surfDims = getScaledDimensions(surfaceItem)
-    if (ourDims[0] > surfDims[0] || ourDims[2] > surfDims[2]) return null
-
-    const surfaceMesh = sceneRegistry.nodes.get(surfaceItem.id)
-    if (!surfaceMesh) return null
-
-    const worldPos = new Vector3(event.position[0], event.position[1], event.position[2])
-    const localPos = surfaceMesh.worldToLocal(worldPos)
-    const surfaceHeight = getSurfacePlacementHeight(surfaceItem, event, localPos)
-    if (surfaceHeight === null) return null
-
-    const x = snapToGrid(localPos.x, ourDims[0])
-    const z = snapToGrid(localPos.z, ourDims[2])
-    const y = surfaceHeight
-
-    const worldSnapped = surfaceMesh.localToWorld(new Vector3(x, y, z))
-
-    // Counter-rotate so the draft's world Y rotation stays continuous when
-    // the user drags onto a rotated surface item. The cursor wireframe
-    // already shows the user's intended world rotation; we just need to
-    // store the right local value relative to the new parent.
-    const surfaceQuat = new Quaternion()
-    surfaceMesh.getWorldQuaternion(surfaceQuat)
-    const surfaceWorldY = new Euler().setFromQuaternion(surfaceQuat, 'YXZ').y
-    const localRotationY = ctx.currentCursorRotationY - surfaceWorldY
+    if (
+      ctx.draftItem &&
+      isDescendantOfItem(surfaceItem, ctx.draftItem.id, useScene.getState().nodes)
+    )
+      return null
+    const pose = resolveCatalogItemSurfacePlacement(
+      surfaceItem,
+      event,
+      ourDims,
+      ctx.currentCursorRotationY,
+      ctx.onSurfaceReject,
+    )
+    if (!pose) return null
     const draftRotation = ctx.draftItem?.rotation ?? [0, 0, 0]
 
     return {
+      surfaceId: pose.surfaceId,
       stateUpdate: { surface: 'item-surface', surfaceItemId: surfaceItem.id },
       nodeUpdate: {
-        position: [x, y, z],
+        position: pose.position,
         parentId: surfaceItem.id,
-        rotation: [draftRotation[0], localRotationY, draftRotation[2]],
+        supportSlabId: undefined,
+        rotation: [draftRotation[0], pose.rotationY, draftRotation[2]],
       },
       cursorRotationY: ctx.currentCursorRotationY,
-      gridPosition: [x, y, z],
-      cursorPosition: [worldSnapped.x, worldSnapped.y, worldSnapped.z],
+      gridPosition: pose.position,
+      cursorPosition: pose.worldPosition,
       stopPropagation: true,
     }
   },
@@ -826,35 +968,31 @@ export const itemSurfaceStrategy = {
   /**
    * Handle item:move — update position while on an item surface.
    */
-  move(ctx: PlacementContext, event: ItemEvent): PlacementResult | null {
+  move(ctx: PlacementContext, event: NodeEvent<AnyNode>, rawEvent = event): PlacementResult | null {
     if (ctx.state.surface !== 'item-surface') return null
     if (!(ctx.state.surfaceItemId && ctx.draftItem)) return null
     if (event.node.id !== ctx.state.surfaceItemId) return null
 
     const nodes = useScene.getState().nodes
-    const surfaceItem = nodes[ctx.state.surfaceItemId as AnyNodeId] as ItemNode | undefined
+    const surfaceItem = nodes[ctx.state.surfaceItemId as AnyNodeId]
     if (!surfaceItem) return null
 
-    const surfaceMesh = sceneRegistry.nodes.get(ctx.state.surfaceItemId)
-    if (!surfaceMesh) return null
-
-    const ourDims = getScaledDimensions(ctx.draftItem)
-    const worldPos = new Vector3(event.position[0], event.position[1], event.position[2])
-    const localPos = surfaceMesh.worldToLocal(worldPos)
-    const surfaceHeight = getSurfacePlacementHeight(surfaceItem, event, localPos)
-    if (surfaceHeight === null) return null
-
-    const x = snapToGrid(localPos.x, ourDims[0])
-    const z = snapToGrid(localPos.z, ourDims[2])
-    const y = surfaceHeight
-
-    const worldSnapped = surfaceMesh.localToWorld(new Vector3(x, y, z))
+    const pose = resolveCatalogItemSurfacePlacement(
+      surfaceItem,
+      event,
+      getScaledDimensions(ctx.draftItem),
+      ctx.currentCursorRotationY,
+      ctx.onSurfaceReject,
+      rawEvent,
+    )
+    if (!pose) return null
 
     return {
-      gridPosition: [x, y, z],
-      cursorPosition: [worldSnapped.x, worldSnapped.y, worldSnapped.z],
+      surfaceId: pose.surfaceId,
+      gridPosition: pose.position,
+      cursorPosition: pose.worldPosition,
       cursorRotationY: ctx.currentCursorRotationY,
-      nodeUpdate: { position: [x, y, z] },
+      nodeUpdate: { position: pose.position },
       stopPropagation: true,
       dirtyNodeId: null,
     }
@@ -863,10 +1001,11 @@ export const itemSurfaceStrategy = {
   /**
    * Handle item:click — commit placement on item surface.
    */
-  click(ctx: PlacementContext, _event: ItemEvent): CommitResult | null {
+  click(ctx: PlacementContext, _event: NodeEvent<AnyNode>): CommitResult | null {
     if (ctx.state.surface !== 'item-surface') return null
     if (!(ctx.draftItem && ctx.state.surfaceItemId)) return null
     if (_event.node.id !== ctx.state.surfaceItemId) return null
+    if (!validCatalogCounterPose(ctx)) return null
 
     return {
       nodeUpdate: {
@@ -884,32 +1023,40 @@ export const itemSurfaceStrategy = {
 // SHELF SURFACE STRATEGY
 // ============================================================================
 
-/**
- * Resolve the row Y closest to the cursor's local Y. Reads candidate row
- * positions from the kind's `capabilities.surfaces.custom` — the shelf
- * declaration emits one `SurfacePoint` per board's top surface. The
- * strategy stays kind-agnostic at this level: any future "multi-board"
- * kind that declares `surfaces.custom` with upward normals gets the
- * same hit behaviour for free.
- */
-function getShelfRowSurfaceY(shelfNode: ShelfNode, localY: number): number | null {
-  const def = nodeRegistry.get('shelf')
-  const custom = def?.capabilities?.surfaces?.custom
-  if (!custom) return null
-  const candidates = custom(shelfNode as AnyNode)
-  if (candidates.length === 0) return null
-  let best = candidates[0]
-  let bestDist = Math.abs(best!.position[1] - localY)
-  for (let i = 1; i < candidates.length; i++) {
-    const c = candidates[i]
-    if (!c) continue
-    const dist = Math.abs(c.position[1] - localY)
-    if (dist < bestDist) {
-      best = c
-      bestDist = dist
-    }
+function resolveShelfSurfacePlacement(
+  host: ShelfNode,
+  event: ShelfEvent,
+  dimensions: [number, number, number],
+  worldYaw: number,
+  entering: boolean,
+  onReject?: PlacementContext['onSurfaceReject'],
+) {
+  const mesh = sceneRegistry.nodes.get(host.id)
+  if (!mesh) return null
+  const local = mesh.worldToLocal(new Vector3(...event.position))
+  const quaternion = mesh.getWorldQuaternion(new Quaternion())
+  const hostYaw = new Euler().setFromQuaternion(quaternion, 'YXZ').y
+  const placement = resolveSurfacePlacement({
+    host,
+    childKind: 'item',
+    childFootprint: { size: dimensions, rotationY: worldYaw - hostYaw },
+    hit: {
+      point: local.toArray(),
+      // Existing shelf movement elects rows even over side faces or board gaps;
+      // only entering requires an upward hit.
+      normalWorldY: entering ? surfaceWorldNormalY(event.normal, event.object.matrixWorld) : 1,
+    },
+    scene: createSceneApi(useScene),
+    snapScalar: snapToGrid,
+    onReject,
+    checkFootprint: true,
+  })
+  if (!placement) return null
+  return {
+    position: [...placement.position] as [number, number, number],
+    rotationY: placement.rotationY,
+    worldPosition: mesh.localToWorld(new Vector3(...placement.position)).toArray(),
   }
-  return best?.position[1] ?? null
 }
 
 export const shelfSurfaceStrategy = {
@@ -928,43 +1075,30 @@ export const shelfSurfaceStrategy = {
     if (ctx.state.surface === 'shelf-surface' && ctx.state.shelfId === shelfNode.id) {
       return null
     }
-    if (!isUpwardShelfSurfaceHit(event)) return null
-
-    // Size check: draft footprint must fit on the shelf board (width × depth).
     const ourDims = ctx.draftItem
       ? getScaledDimensions(ctx.draftItem)
       : (ctx.asset.dimensions ?? DEFAULT_DIMENSIONS)
-    if (ourDims[0] > shelfNode.width || ourDims[2] > shelfNode.depth) return null
-
-    const shelfMesh = sceneRegistry.nodes.get(shelfNode.id)
-    if (!shelfMesh) return null
-
-    const worldPos = new Vector3(event.position[0], event.position[1], event.position[2])
-    const localPos = shelfMesh.worldToLocal(worldPos)
-    const rowY = getShelfRowSurfaceY(shelfNode, localPos.y)
-    if (rowY === null) return null
-
-    const x = snapToGrid(localPos.x, ourDims[0])
-    const z = snapToGrid(localPos.z, ourDims[2])
-
-    const worldSnapped = shelfMesh.localToWorld(new Vector3(x, rowY, z))
-
-    const surfaceQuat = new Quaternion()
-    shelfMesh.getWorldQuaternion(surfaceQuat)
-    const surfaceWorldY = new Euler().setFromQuaternion(surfaceQuat, 'YXZ').y
-    const localRotationY = ctx.currentCursorRotationY - surfaceWorldY
+    const pose = resolveShelfSurfacePlacement(
+      shelfNode,
+      event,
+      ourDims,
+      ctx.currentCursorRotationY,
+      true,
+      ctx.onSurfaceReject,
+    )
+    if (!pose) return null
     const draftRotation = ctx.draftItem?.rotation ?? [0, 0, 0]
 
     return {
       stateUpdate: { surface: 'shelf-surface', shelfId: shelfNode.id },
       nodeUpdate: {
-        position: [x, rowY, z],
+        position: pose.position,
         parentId: shelfNode.id,
-        rotation: [draftRotation[0], localRotationY, draftRotation[2]],
+        rotation: [draftRotation[0], pose.rotationY, draftRotation[2]],
       },
       cursorRotationY: ctx.currentCursorRotationY,
-      gridPosition: [x, rowY, z],
-      cursorPosition: [worldSnapped.x, worldSnapped.y, worldSnapped.z],
+      gridPosition: pose.position,
+      cursorPosition: pose.worldPosition,
       stopPropagation: true,
     }
   },
@@ -978,25 +1112,21 @@ export const shelfSurfaceStrategy = {
     if (!(ctx.state.shelfId && ctx.draftItem)) return null
     if (event.node.id !== ctx.state.shelfId) return null
 
-    const shelfNode = event.node as ShelfNode
-    const shelfMesh = sceneRegistry.nodes.get(shelfNode.id)
-    if (!shelfMesh) return null
-
-    const ourDims = getScaledDimensions(ctx.draftItem)
-    const worldPos = new Vector3(event.position[0], event.position[1], event.position[2])
-    const localPos = shelfMesh.worldToLocal(worldPos)
-    const rowY = getShelfRowSurfaceY(shelfNode, localPos.y)
-    if (rowY === null) return null
-
-    const x = snapToGrid(localPos.x, ourDims[0])
-    const z = snapToGrid(localPos.z, ourDims[2])
-    const worldSnapped = shelfMesh.localToWorld(new Vector3(x, rowY, z))
+    const pose = resolveShelfSurfacePlacement(
+      event.node as ShelfNode,
+      event,
+      getScaledDimensions(ctx.draftItem),
+      ctx.currentCursorRotationY,
+      false,
+      ctx.onSurfaceReject,
+    )
+    if (!pose) return null
 
     return {
-      gridPosition: [x, rowY, z],
-      cursorPosition: [worldSnapped.x, worldSnapped.y, worldSnapped.z],
+      gridPosition: pose.position,
+      cursorPosition: pose.worldPosition,
       cursorRotationY: ctx.currentCursorRotationY,
-      nodeUpdate: { position: [x, rowY, z] },
+      nodeUpdate: { position: pose.position },
       stopPropagation: true,
       dirtyNodeId: null,
     }
@@ -1009,6 +1139,7 @@ export const shelfSurfaceStrategy = {
     if (ctx.state.surface !== 'shelf-surface') return null
     if (!(ctx.draftItem && ctx.state.shelfId)) return null
     if (event.node.id !== ctx.state.shelfId) return null
+    if (!validCatalogCounterPose(ctx)) return null
 
     return {
       nodeUpdate: {
@@ -1022,14 +1153,6 @@ export const shelfSurfaceStrategy = {
   },
 }
 
-/** Same upward-normal heuristic as `isUpwardItemSurfaceHit`, but typed
- *  for `ShelfEvent`. Re-uses the matrix-driven world normal calculation
- *  via a tiny `ItemEvent`-shaped adapter — the function only reads
- *  `event.normal` + `event.object`. */
-function isUpwardShelfSurfaceHit(event: ShelfEvent): boolean {
-  return isUpwardItemSurfaceHit(event as unknown as ItemEvent)
-}
-
 // ============================================================================
 // VALIDATION
 // ============================================================================
@@ -1041,20 +1164,30 @@ function isUpwardShelfSurfaceHit(event: ShelfEvent): boolean {
 export function checkCanPlace(ctx: PlacementContext, validators: SpatialValidators): boolean {
   if (!(ctx.levelId && ctx.draftItem)) return false
 
-  // Item surface: valid if we entered (size check was in enter)
   if (ctx.state.surface === 'item-surface') {
-    return ctx.state.surfaceItemId !== null
+    return ctx.state.surfaceItemId !== null && validCatalogCounterPose(ctx)
   }
 
-  // Shelf surface: same — size check already happened on enter
   if (ctx.state.surface === 'shelf-surface') {
-    return ctx.state.shelfId !== null
+    return ctx.state.shelfId !== null && validCatalogCounterPose(ctx)
   }
 
   const attachTo = ctx.draftItem.asset.attachTo
 
   const alignedDims = getGridAlignedDimensions(getScaledDimensions(ctx.draftItem), attachTo)
 
+  if (ctx.state.surface === 'block-face') {
+    const hostId = ctx.state.blockId
+    const host = hostId ? useScene.getState().nodes[hostId as AnyNodeId] : undefined
+    const faceHost = host ? nodeRegistry.get(host.type)?.capabilities.faceHost : undefined
+    if (!(host && faceHost)) return false
+    return faceHost.isStoredPlacementValid({
+      host,
+      item: ctx.draftItem,
+      asset: ctx.draftItem.asset,
+    })
+  }
+
   if (attachTo === 'ceiling') {
     if (ctx.state.surface !== 'ceiling' || !ctx.state.ceilingId) return false
     return validators.canPlaceOnCeiling(