@pascal-app/editor 1.0.1 → 1.0.4

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

@@ -1,23 +1,78 @@
 import {
   type AnyNodeId,
   type AssetInput,
+  beginSceneHistoryDraft,
   ItemNode,
   resolveSupportSlabPatch,
+  runSceneHistoryDraftWrite,
+  type SurfaceRejectReason,
+  sceneHistoryDraftRevertUpdates,
   sceneRegistry,
   useScene,
+  withSceneHistoryDraftSuspended,
 } 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'
 
+function releaseHistoryDraft(end: { current: (() => void) | null }): void {
+  end.current?.()
+  end.current = null
+}
+
+/**
+ * A placement's own write: under a short pause, and the carried draft's fields it changes stay
+ * recorded as they were before the carry (core's `runSceneHistoryDraftWrite`).
+ */
+export const pausedDraftWrite = runSceneHistoryDraftWrite
+
+/**
+ * Puts back what the carry still holds on an adopted item (its own writes, core's
+ * `sceneHistoryDraftRevertUpdates`), as a carry write: a position, name or host a collaborator
+ * wrote meanwhile stays. A host deleted mid-carry is never a parent again (nor its face, roof
+ * or surface): the item stays on its live parent, else the level. Returns its parent after.
+ */
+function restoreOriginalState(
+  id: AnyNodeId,
+  original: OriginalState,
+  draftParentId: string | null | undefined,
+): string | null {
+  const nodes = useScene.getState().nodes
+  const exists = (parentId: string | null | undefined): parentId is string =>
+    Boolean(parentId && nodes[parentId as AnyNodeId])
+  const hostGone = original.parentId != null && !exists(original.parentId)
+  const updates = sceneHistoryDraftRevertUpdates([id])
+  const own = updates.find((update) => update.id === id)
+  if (hostGone && own) {
+    for (const key of ['roofSegmentId', 'roofFace', 'blockFaceId']) delete own.data[key]
+  }
+  const liveParentId = nodes[id]?.parentId
+  if (!exists(liveParentId)) {
+    const fallback = [draftParentId, useViewer.getState().selection.levelId].find(exists)
+    if (fallback) {
+      if (own) own.data.parentId = fallback
+      else updates.push({ id, data: { parentId: fallback } })
+    }
+  }
+  if (updates.length > 0) {
+    pausedDraftWrite(() => useScene.getState().updateNodes(updates as never))
+  }
+  return useScene.getState().nodes[id]?.parentId ?? null
+}
+
 interface OriginalState {
   surfaceId: string | null
   position: [number, number, number]
@@ -32,6 +87,9 @@ interface OriginalState {
   metadata: ItemNode['metadata']
 }
 
+/** What a duplicate keeps from the item it copies. */
+export type ItemCopy = Pick<ItemNode, 'slots' | 'collectionIds'>
+
 export interface DraftNodeHandle {
   updateSurface: (data: Partial<ItemNode>, surfaceId: string | null) => void
   /** Current draft item, or null */
@@ -39,17 +97,19 @@ export interface DraftNodeHandle {
   /** Whether the current draft was adopted (move mode) vs created (create mode) */
   readonly isAdopted: boolean
   /** Create a new draft item at the given position. Returns the created node or null.
-   *  `slots` seeds painted slot overrides so duplicates keep their materials. */
+   *  `copied` is the item a duplicate copies: it keeps its painted slots and collections. */
   create: (
     gridPosition: Vector3,
     asset: AssetInput,
     rotation?: [number, number, number],
     scale?: [number, number, number],
-    slots?: ItemNode['slots'],
+    copied?: ItemCopy,
   ) => 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.
+   *  The final write is the one undo step, recorded only while no owner pauses history:
+   *  a caller holding a pause lifts it around this call (`SceneHistoryPauseSession.commitStep`).
    *  `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. */
@@ -58,6 +118,7 @@ export interface DraftNodeHandle {
     options?: {
       supportElevationCap?: number | null
       preferredSupportSlabId?: string | null
+      onReject?: (reason: SurfaceRejectReason) => void
       pinSupport?: boolean
     },
   ) => string | null
@@ -67,7 +128,11 @@ export interface DraftNodeHandle {
 
 /**
  * Hook that manages the lifecycle of a transient (draft) item node.
- * Handles temporal pause/resume for undo/redo isolation.
+ * The draft is registered with core's history drafts from create/adopt until
+ * commit/destroy, so history records it as absent (created) or as it was
+ * (adopted) and no draft write becomes an undo step; the draft's own writes
+ * also run under a short balanced pause. An adopted `commit` suspends the registration for
+ * its tracked write and ends it only after success, so a rejected drop can still be retried.
  *
  * Supports two modes:
  * - Create mode (via `create()`): draft is a new transient node. Commit = delete+recreate (undo removes node).
@@ -76,7 +141,9 @@ 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 endHistoryDraftRef = useRef<(() => void) | null>(null)
 
   const create = useCallback(
     (
@@ -84,7 +151,7 @@ export function useDraftNode(): DraftNodeHandle {
       asset: AssetInput,
       rotation?: [number, number, number],
       scale?: [number, number, number],
-      slots?: ItemNode['slots'],
+      copied?: ItemCopy,
     ): ItemNode | null => {
       const currentLevelId = useViewer.getState().selection.levelId
       if (!currentLevelId) return null
@@ -97,15 +164,30 @@ export function useDraftNode(): DraftNodeHandle {
         asset,
         parentId: currentLevelId,
         metadata: { isTransient: true },
-        ...(slots ? { slots } : {}),
+        ...(copied?.slots ? { slots: copied.slots } : {}),
+        ...(copied?.collectionIds ? { collectionIds: copied.collectionIds } : {}),
       })
 
-      useScene.getState().createNode(node, currentLevelId)
+      releaseHistoryDraft(endHistoryDraftRef)
+      endHistoryDraftRef.current = beginSceneHistoryDraft(node.id, null)
+      try {
+        pausedDraftWrite(() => useScene.getState().createNode(node, currentLevelId))
+      } catch (error) {
+        try {
+          if (useScene.getState().nodes[node.id]) {
+            pausedDraftWrite(() => useScene.getState().deleteNode(node.id))
+          }
+        } finally {
+          releaseHistoryDraft(endHistoryDraftRef)
+        }
+        throw error
+      }
       usePlacementPreview
         .getState()
         .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 +195,13 @@ export function useDraftNode(): DraftNodeHandle {
   )
 
   const adopt = useCallback((node: ItemNode): void => {
+    releaseHistoryDraft(endHistoryDraftRef)
+    endHistoryDraftRef.current = beginSceneHistoryDraft(
+      node.id,
+      isFreshPlacementMetadata(node.metadata) ? null : node,
+    )
+    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)
@@ -138,9 +227,11 @@ export function useDraftNode(): DraftNodeHandle {
     adoptedRef.current = true
 
     // Mark as transient so it renders as a draft
-    useScene.getState().updateNode(node.id, {
-      metadata: { ...meta, isTransient: true },
-    })
+    pausedDraftWrite(() =>
+      useScene.getState().updateNode(node.id, {
+        metadata: { ...meta, isTransient: true },
+      }),
+    )
     usePlacementPreview
       .getState()
       .set(
@@ -155,11 +246,16 @@ export function useDraftNode(): DraftNodeHandle {
       options?: {
         supportElevationCap?: number | null
         preferredSupportSlabId?: string | null
+        onReject?: (reason: SurfaceRejectReason) => void
         pinSupport?: boolean
       },
     ): string | null => {
       const draft = draftRef.current
       if (!draft) return null
+      if (finalUpdate.parentId && !useScene.getState().nodes[finalUpdate.parentId as AnyNodeId]) {
+        options?.onReject?.('no-surface')
+        return null
+      }
 
       const surfaceId = surfaceAttachmentId(useScene.getState().nodes[draft.id] ?? draft)
       const stored = surfaceFramePose(
@@ -169,34 +265,46 @@ export function useDraftNode(): DraftNodeHandle {
         true,
       )
       finalUpdate = { ...finalUpdate, ...stored }
-      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
-        updateSurfaceNode(
+      // The drop ends the carry on the item's live metadata: placement strategies hand in the
+      // adoption-time snapshot, which would drop anything an agent wrote meanwhile.
+      const liveDraft = useScene.getState().nodes[draft.id]
+      if (liveDraft) finalUpdate.metadata = stripTransient(liveDraft.metadata)
+      if (isFreshPlacementMetadata(originalStateRef.current?.metadata)) {
+        const effectiveNode = ItemNode.parse({ ...draft, ...finalUpdate })
+        const id = commitFreshPlacementSubtree(
           draft.id,
           {
-            position: original.position,
-            rotation: original.rotation,
-            side: original.side,
-            parentId: original.parentId,
-            roofSegmentId: original.roofSegmentId,
-            roofFace: original.roofFace,
-            blockFaceId: original.blockFaceId,
-            metadata: original.metadata,
+            ...finalUpdate,
+            ...resolveSupportSlabPatch(effectiveNode, useScene.getState().nodes, {
+              maxElevation: options?.supportElevationCap,
+              preferredSlabId: options?.preferredSupportSlabId,
+              pinSupport: options?.pinSupport,
+            }),
           },
-          original.surfaceId,
+          options?.onReject,
         )
+        if (!id) return null
+        releaseHistoryDraft(endHistoryDraftRef)
+        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
+        const original = originalStateRef.current!
+        const nodesNow = useScene.getState().nodes
+        const restoredParentId = restoreOriginalState(draft.id, original, draft.parentId)
+        const parentId =
+          [newParentId, restoredParentId].find((id) => id && nodesNow[id as AnyNodeId]) ??
+          restoredParentId
 
-        // Resume → tracked update (undo reverts to original)
-        useScene.temporal.getState().resume()
-
+        // The original is restored above (a carry write), so the one tracked write below has
+        // the true baseline as its undo state.
         const effectiveNode = ItemNode.parse({
           ...draft,
           ...updateProps,
@@ -204,34 +312,35 @@ export function useDraftNode(): DraftNodeHandle {
           metadata: updateProps.metadata ?? stripTransient(draft.metadata),
         })
 
-        updateSurfaceNode(
-          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,
-            blockFaceId: updateProps.blockFaceId,
-            // 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,
-              preferredSlabId: options?.preferredSupportSlabId,
-              pinSupport: options?.pinSupport,
-            }),
-          },
-          surfaceId,
-        )
-
-        useScene.temporal.getState().pause()
+        withSceneHistoryDraftSuspended(draft.id, () => {
+          updateSurfaceNode(
+            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,
+              blockFaceId: updateProps.blockFaceId,
+              // 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,
+                preferredSlabId: options?.preferredSupportSlabId,
+                pinSupport: options?.pinSupport,
+              }),
+            },
+            surfaceId,
+          )
+        })
+        releaseHistoryDraft(endHistoryDraftRef)
 
         const id = draft.id
         if (usePlacementPreview.getState().node?.id === id) {
@@ -243,20 +352,19 @@ export function useDraftNode(): DraftNodeHandle {
         return id
       }
 
-      // Create mode: delete draft (paused), resume, create fresh node (tracked), re-pause
+      // Create mode: delete the draft (paused), then create the fresh node (the tracked write)
       const { parentId: newParentId, ...updateProps } = finalUpdate
       const parentId = (newParentId ?? useViewer.getState().selection.levelId) as AnyNodeId
       if (!parentId) return null
 
       beginPerfAction('place:item', draft.id)
-      // Delete draft while paused (invisible to undo)
-      updateSurfaceNode(draft.id, {}, null)
-      useScene.getState().deleteNode(draft.id)
+      pausedDraftWrite(() => {
+        updateSurfaceNode(draft.id, {}, null)
+        useScene.getState().deleteNode(draft.id)
+      })
+      releaseHistoryDraft(endHistoryDraftRef)
       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,
@@ -264,8 +372,9 @@ export function useDraftNode(): DraftNodeHandle {
         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.
+        // A duplicated item keeps its painted slots and its collections.
         ...(draft.slots ? { slots: draft.slots } : {}),
+        ...(draft.collectionIds ? { collectionIds: draft.collectionIds } : {}),
         // Roof host — see the move-mode commit above for why this must be
         // forwarded explicitly.
         roofSegmentId: updateProps.roofSegmentId,
@@ -296,9 +405,6 @@ export function useDraftNode(): DraftNodeHandle {
         usePlacementPreview.getState().clear()
       }
 
-      // Re-pause for next draft cycle
-      useScene.temporal.getState().pause()
-
       adoptedRef.current = false
       originalStateRef.current = null
       commitPerfAction()
@@ -311,15 +417,21 @@ export function useDraftNode(): DraftNodeHandle {
     if (!draftRef.current) return
 
     const draftId = draftRef.current.id
-
-    if (adoptedRef.current && originalStateRef.current) {
+    if (ownsSubtreeRef.current) {
+      releaseHistoryDraft(endHistoryDraftRef)
+      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
       // `useScene.updateNodes` before unmounting the legacy mover, and
       // an unconditional restore here would wipe that commit. By
       // comparing the live state to the snapshot we took in `adopt()`,
-      // we let an external committer's write stick.
+      // we let an external committer's write stick. A preview after a rejected drop may
+      // lack the transient marker, but its still-owned position must be restored on cancel.
       const original = originalStateRef.current
       const id = draftRef.current.id
       const live = useScene.getState().nodes[id as AnyNodeId] as ItemNode | undefined
@@ -327,10 +439,14 @@ export function useDraftNode(): DraftNodeHandle {
       const externallyMoved =
         !live?.metadata?.isTransient &&
         !!livePosition &&
+        !sceneHistoryDraftRevertUpdates([id]).some(
+          (update) => update.id === id && 'position' in update.data,
+        ) &&
         (livePosition[0] !== original.position[0] ||
           livePosition[1] !== original.position[1] ||
           livePosition[2] !== original.position[2])
       if (externallyMoved) {
+        releaseHistoryDraft(endHistoryDraftRef)
         draftRef.current = null
         adoptedRef.current = false
         originalStateRef.current = null
@@ -340,36 +456,28 @@ export function useDraftNode(): DraftNodeHandle {
         return
       }
 
-      updateSurfaceNode(
-        id,
-        {
-          position: original.position,
-          rotation: original.rotation,
-          side: original.side,
-          parentId: original.parentId,
-          roofSegmentId: original.roofSegmentId,
-          roofFace: original.roofFace,
-          blockFaceId: original.blockFaceId,
-          metadata: original.metadata,
-        },
-        original.surfaceId,
-      )
+      restoreOriginalState(id, original, draftRef.current.parentId)
 
       // Also reset the Three.js mesh directly — the store update triggers a React
       // re-render but the mesh position was mutated by useFrame and may not reset
       // until the next render cycle, leaving a visual glitch.
       const mesh = sceneRegistry.nodes.get(id as AnyNodeId)
-      if (mesh) {
-        mesh.position.set(original.position[0], original.position[1], original.position[2])
-        mesh.rotation.y = original.rotation[1] ?? 0
+      const restored = useScene.getState().nodes[id as AnyNodeId] as ItemNode | undefined
+      if (mesh && restored) {
+        mesh.position.set(restored.position[0], restored.position[1], restored.position[2])
+        mesh.rotation.y = restored.rotation[1] ?? 0
         mesh.visible = true
       }
     } else {
       // Create mode: delete the transient node
-      updateSurfaceNode(draftRef.current.id, {}, null)
-      useScene.getState().deleteNode(draftRef.current.id)
+      const id = draftRef.current.id
+      pausedDraftWrite(() => {
+        updateSurfaceNode(id, {}, null)
+        useScene.getState().deleteNode(id)
+      })
     }
 
+    releaseHistoryDraft(endHistoryDraftRef)
     draftRef.current = null
     adoptedRef.current = false
     originalStateRef.current = null
@@ -382,10 +490,12 @@ export function useDraftNode(): DraftNodeHandle {
     const draft = draftRef.current
     if (!draft) return
     const pose = { ...draft, ...data }
-    updateSurfaceNode(
-      draft.id,
-      { ...data, ...surfaceFramePose(pose.parentId, surfaceId, pose, true) },
-      surfaceId,
+    pausedDraftWrite(() =>
+      updateSurfaceNode(
+        draft.id,
+        { ...data, ...surfaceFramePose(pose.parentId, surfaceId, pose, true) },
+        surfaceId,
+      ),
     )
   }, [])