@pascal-app/editor 1.0.1 → 1.0.3

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

@@ -4,7 +4,6 @@ import type {
   CeilingEvent,
   CeilingNode,
   GridEvent,
-  ItemNode,
   NodeEvent,
   RoofEvent,
   RoofNode,
@@ -17,6 +16,7 @@ import type {
 } from '@pascal-app/core'
 import {
   clampRectToRoofWallFace,
+  clearFaceHostItemFields,
   createSceneApi,
   getRoofSegmentWallFace,
   getScaledDimensions,
@@ -24,11 +24,13 @@ 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 { snapWorldXZForActiveBuilding } from '../../../lib/world-grid-snap'
+import { getActiveBuildingPose } from '../../../lib/world-grid-snap'
 import { itemEventToSurfaceHit, surfaceWorldNormalY } from '../shared/surface-hit'
 import {
   calculateItemRotation,
@@ -49,20 +51,6 @@ import type {
 } from './placement-types'
 
 const DEFAULT_DIMENSIONS: [number, number, number] = [1, 1, 1]
-function isDescendantOfItem(
-  candidate: AnyNode,
-  ancestorId: string,
-  nodes: Record<string, AnyNode>,
-): boolean {
-  let parentId = candidate.parentId
-  while (parentId) {
-    if (parentId === ancestorId) return true
-    const parent = nodes[parentId as AnyNodeId]
-    parentId = parent?.parentId ?? null
-  }
-  return false
-}
-
 // ============================================================================
 // FLOOR STRATEGY
 // ============================================================================
@@ -89,11 +77,12 @@ export const floorStrategy = {
     // the world grid.
     // 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 [x, z] = snapWorldXZForActiveBuilding(
-      snapToGrid(event.position[0], swapDims ? dimZ : dimX),
-      snapToGrid(event.position[2], swapDims ? dimX : dimZ),
-      0,
-    ).local
+    const dimensions = [swapDims ? dimZ : dimX, swapDims ? dimX : dimZ] as const
+    const [x, z] = snapLocalXZInWorld(
+      [event.localPosition[0], event.localPosition[2]],
+      getActiveBuildingPose(),
+      (value, axis) => snapToGrid(value, dimensions[axis]),
+    )
     const y = ctx.gridPosition.y
 
     return {
@@ -212,6 +201,12 @@ export const wallStrategy = {
     if (attachTo !== 'wall' && attachTo !== 'wall-side') return null
     if (!isValidWallSideFace(event.normal)) return null
 
+    if (
+      ctx.draftItem &&
+      wouldCreateHostingCycle(ctx.draftItem.id, event.node, createSceneApi(useScene))
+    )
+      return null
+
     // Level guard
     const wallLevelId = resolveLevelId(event.node, nodes)
     if (ctx.levelId !== wallLevelId) return null
@@ -416,6 +411,11 @@ function resolveRoofWallTarget(
 
   const hit = resolveRoofWallHit(event.node as RoofNode, event.position, event.normal, event.object)
   if (!hit) return null
+  if (
+    ctx.draftItem &&
+    wouldCreateHostingCycle(ctx.draftItem.id, hit.segment, createSceneApi(useScene))
+  )
+    return null
 
   const rawDims = ctx.draftItem
     ? getScaledDimensions(ctx.draftItem)
@@ -605,6 +605,11 @@ export const roofWallStrategy = {
 // ============================================================================
 
 function resolveFaceHostTarget(ctx: PlacementContext, event: NodeEvent) {
+  if (
+    ctx.draftItem &&
+    wouldCreateHostingCycle(ctx.draftItem.id, event.node, createSceneApi(useScene))
+  )
+    return null
   const faceHost = nodeRegistry.get(event.node.type)?.capabilities.faceHost
   if (!faceHost) return null
   const rawDimensions = ctx.draftItem
@@ -624,18 +629,6 @@ function resolveFaceHostTarget(ctx: PlacementContext, event: NodeEvent) {
   })
 }
 
-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)
@@ -695,7 +688,9 @@ export const faceHostStrategy = {
     return {
       stateUpdate: { surface: 'floor', blockId: null },
       nodeUpdate: {
-        ...clearFaceHostItemFields(ctx),
+        ...clearFaceHostItemFields(
+          ctx.state.blockId ? useScene.getState().nodes[ctx.state.blockId] : undefined,
+        ),
         position: floorPosition,
         parentId: ctx.levelId,
         rotation: [0, ctx.currentCursorRotationY, 0],
@@ -725,6 +720,12 @@ export const ceilingStrategy = {
   ): TransitionResult | null {
     if (ctx.asset.attachTo !== 'ceiling') return null
 
+    if (
+      ctx.draftItem &&
+      wouldCreateHostingCycle(ctx.draftItem.id, event.node, createSceneApi(useScene))
+    )
+      return null
+
     // Level guard
     const ceilingLevelId = resolveLevelId(event.node, nodes)
     if (ctx.levelId !== ceilingLevelId) return null
@@ -860,6 +861,8 @@ function resolveCatalogItemSurfacePlacement(
   worldYaw: number,
   onReject?: PlacementContext['onSurfaceReject'],
   rawEvent = event,
+  childId?: string,
+  childRotation?: [number, number, number],
 ) {
   const mesh = sceneRegistry.nodes.get(host.id)
   if (!mesh) return null
@@ -870,7 +873,12 @@ function resolveCatalogItemSurfacePlacement(
   const placement = resolveSurfacePlacement({
     host,
     childKind: 'item',
-    childFootprint: { size: dimensions, rotationY: worldYaw - hostYaw },
+    childId,
+    childFootprint: {
+      size: dimensions,
+      rotationY: worldYaw - hostYaw,
+      rotation: [childRotation?.[0] ?? 0, worldYaw - hostYaw, childRotation?.[2] ?? 0],
+    },
     hit: host.type === 'procedural-item' ? (itemEventToSurfaceHit(host, rawEvent) ?? hit) : hit,
     origin: host.type === 'procedural-item' ? hit.point : undefined,
     scene: createSceneApi(useScene),
@@ -890,17 +898,12 @@ function resolveCatalogItemSurfacePlacement(
 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 (!host) return true
   if (!ctx.draftItem) return false
   const placement = resolveSurfacePlacement({
     host,
     childKind: 'item',
+    childId: ctx.draftItem.id,
     childFootprint: {
       size: getScaledDimensions(ctx.draftItem),
       rotationY: ctx.draftItem.rotation[1],
@@ -936,7 +939,7 @@ export const itemSurfaceStrategy = {
       : (ctx.asset.dimensions ?? DEFAULT_DIMENSIONS)
     if (
       ctx.draftItem &&
-      isDescendantOfItem(surfaceItem, ctx.draftItem.id, useScene.getState().nodes)
+      wouldCreateHostingCycle(ctx.draftItem.id, surfaceItem, createSceneApi(useScene))
     )
       return null
     const pose = resolveCatalogItemSurfacePlacement(
@@ -945,6 +948,9 @@ export const itemSurfaceStrategy = {
       ourDims,
       ctx.currentCursorRotationY,
       ctx.onSurfaceReject,
+      event,
+      ctx.draftItem?.id,
+      ctx.draftItem?.rotation,
     )
     if (!pose) return null
     const draftRotation = ctx.draftItem?.rotation ?? [0, 0, 0]
@@ -984,6 +990,8 @@ export const itemSurfaceStrategy = {
       ctx.currentCursorRotationY,
       ctx.onSurfaceReject,
       rawEvent,
+      ctx.draftItem.id,
+      ctx.draftItem.rotation,
     )
     if (!pose) return null
 
@@ -1030,6 +1038,7 @@ function resolveShelfSurfacePlacement(
   worldYaw: number,
   entering: boolean,
   onReject?: PlacementContext['onSurfaceReject'],
+  childId?: string,
 ) {
   const mesh = sceneRegistry.nodes.get(host.id)
   if (!mesh) return null
@@ -1039,6 +1048,7 @@ function resolveShelfSurfacePlacement(
   const placement = resolveSurfacePlacement({
     host,
     childKind: 'item',
+    childId,
     childFootprint: { size: dimensions, rotationY: worldYaw - hostYaw },
     hit: {
       point: local.toArray(),
@@ -1085,6 +1095,7 @@ export const shelfSurfaceStrategy = {
       ctx.currentCursorRotationY,
       true,
       ctx.onSurfaceReject,
+      ctx.draftItem?.id,
     )
     if (!pose) return null
     const draftRotation = ctx.draftItem?.rotation ?? [0, 0, 0]
@@ -1119,6 +1130,7 @@ export const shelfSurfaceStrategy = {
       ctx.currentCursorRotationY,
       false,
       ctx.onSurfaceReject,
+      ctx.draftItem.id,
     )
     if (!pose) return null
 

package/src/components/tools/item/shelf-surface-strategy-resolver.test.ts

@@ -3,7 +3,6 @@ import * as core from '@pascal-app/core'
 import {
   ItemNode,
   nodeRegistry,
-  registerNode,
   type ShelfEvent,
   ShelfNode,
   sceneRegistry,
@@ -12,6 +11,7 @@ import {
 import { Euler, Group, Quaternion, Vector3 } from 'three'
 import useEditor from '../../../store/use-editor'
 import useInteractionScope from '../../../store/use-interaction-scope'
+import { registerHostingTestNode } from '../__fixtures__/hosting'
 import { shelfSurfaceStrategy } from './placement-strategies'
 import type { PlacementContext } from './placement-types'
 
@@ -39,7 +39,7 @@ beforeEach(() => {
   restoreRegistry = nodeRegistry._snapshot()
   nodeRegistry._reset()
   rows = [0.5, 1.5]
-  registerNode({
+  registerHostingTestNode({
     kind: 'shelf',
     schemaVersion: 1,
     schema: ShelfNode,
@@ -51,7 +51,7 @@ beforeEach(() => {
       },
     },
   })
-  registerNode({
+  registerHostingTestNode({
     kind: 'item',
     schemaVersion: 1,
     schema: ItemNode,

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

@@ -3,18 +3,24 @@ import {
   type AssetInput,
   ItemNode,
   resolveSupportSlabPatch,
+  type SurfaceRejectReason,
   sceneRegistry,
   useScene,
 } from '@pascal-app/core'
 import { beginPerfAction, commitPerfAction, useViewer } from '@pascal-app/viewer'
 import { useCallback, useMemo, useRef } from 'react'
 import type { Vector3 } from 'three'
+import { commitFreshPlacementSubtree } from '../../../lib/fresh-planar-placement'
+import { isFreshPlacementMetadata } from '../../../lib/placement-metadata'
 import {
   surfaceAttachmentId,
   surfaceAttachmentUpdates,
   surfaceFramePose,
   updateSurfaceNode,
 } from '../../../lib/surface-attachment'
+import useInteractionScope, {
+  isInteractionSubtreeDraft,
+} from '../../../store/use-interaction-scope'
 import usePlacementPreview from '../../../store/use-placement-preview'
 import { stripTransient } from './placement-math'
 
@@ -58,6 +64,7 @@ export interface DraftNodeHandle {
     options?: {
       supportElevationCap?: number | null
       preferredSupportSlabId?: string | null
+      onReject?: (reason: SurfaceRejectReason) => void
       pinSupport?: boolean
     },
   ) => string | null
@@ -76,6 +83,7 @@ export interface DraftNodeHandle {
 export function useDraftNode(): DraftNodeHandle {
   const draftRef = useRef<ItemNode | null>(null)
   const adoptedRef = useRef(false)
+  const ownsSubtreeRef = useRef(false)
   const originalStateRef = useRef<OriginalState | null>(null)
 
   const create = useCallback(
@@ -106,6 +114,7 @@ export function useDraftNode(): DraftNodeHandle {
         .set(node, useScene.getState().nodes[currentLevelId as AnyNodeId] ?? null)
       draftRef.current = node
       adoptedRef.current = false
+      ownsSubtreeRef.current = false
       originalStateRef.current = null
       return node
     },
@@ -113,6 +122,8 @@ export function useDraftNode(): DraftNodeHandle {
   )
 
   const adopt = useCallback((node: ItemNode): void => {
+    ownsSubtreeRef.current =
+      useInteractionScope.getState().adoptSubtree(node.id) || isInteractionSubtreeDraft(node.id)
     // Save original state so destroy() can restore it
     const meta =
       typeof node.metadata === 'object' && node.metadata !== null && !Array.isArray(node.metadata)
@@ -155,6 +166,7 @@ export function useDraftNode(): DraftNodeHandle {
       options?: {
         supportElevationCap?: number | null
         preferredSupportSlabId?: string | null
+        onReject?: (reason: SurfaceRejectReason) => void
         pinSupport?: boolean
       },
     ): string | null => {
@@ -169,6 +181,29 @@ export function useDraftNode(): DraftNodeHandle {
         true,
       )
       finalUpdate = { ...finalUpdate, ...stored }
+      if (isFreshPlacementMetadata(originalStateRef.current?.metadata)) {
+        const effectiveNode = ItemNode.parse({ ...draft, ...finalUpdate })
+        const id = commitFreshPlacementSubtree(
+          draft.id,
+          {
+            ...finalUpdate,
+            ...resolveSupportSlabPatch(effectiveNode, useScene.getState().nodes, {
+              maxElevation: options?.supportElevationCap,
+              preferredSlabId: options?.preferredSupportSlabId,
+              pinSupport: options?.pinSupport,
+            }),
+          },
+          options?.onReject,
+        )
+        if (!id) return null
+        if (usePlacementPreview.getState().node?.id === draft.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)
         const { parentId: newParentId, ...updateProps } = finalUpdate
@@ -311,8 +346,12 @@ export function useDraftNode(): DraftNodeHandle {
     if (!draftRef.current) return
 
     const draftId = draftRef.current.id
-
-    if (adoptedRef.current && originalStateRef.current) {
+    if (ownsSubtreeRef.current) {
+      draftRef.current = null
+      adoptedRef.current = false
+      originalStateRef.current = null
+      return
+    } else 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
       // node. The 2D `FloorplanRegistryMoveOverlay` commits via