fix(workflow): preserve parent and position when duplicating/pasting nested blocks

Three related fixes for blocks inside containers (loop/parallel):

1. regenerateBlockIds now preserves parentId when the parent exists in
   the current workflow, not just when it's in the copy set. This keeps
   duplicated blocks inside their container.

2. calculatePasteOffset now uses simple offset for nested blocks instead
   of viewport-center calculation. Since nested blocks use relative
   positioning, the viewport-center offset would place them incorrectly.

3. Use CONTAINER_DIMENSIONS constants instead of hardcoded magic numbers
   in orphan cleanup position calculation.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/workflow.tsx

@@ -120,19 +120,33 @@ function getViewportCenter(
 }
 
 /**
- * Calculates the offset to paste blocks at viewport center
+ * Calculates the offset to paste blocks at viewport center, or simple offset for nested blocks
  */
 function calculatePasteOffset(
   clipboard: {
-    blocks: Record<string, { position: { x: number; y: number }; type: string; height?: number }>
+    blocks: Record<
+      string,
+      {
+        position: { x: number; y: number }
+        type: string
+        height?: number
+        data?: { parentId?: string }
+      }
+    >
   } | null,
-  screenToFlowPosition: (pos: { x: number; y: number }) => { x: number; y: number }
+  screenToFlowPosition: (pos: { x: number; y: number }) => { x: number; y: number },
+  existingBlocks: Record<string, { id: string }> = {}
 ): { x: number; y: number } {
   if (!clipboard) return DEFAULT_PASTE_OFFSET
 
   const clipboardBlocks = Object.values(clipboard.blocks)
   if (clipboardBlocks.length === 0) return DEFAULT_PASTE_OFFSET
 
+  const allBlocksNested = clipboardBlocks.every(
+    (b) => b.data?.parentId && existingBlocks[b.data.parentId]
+  )
+  if (allBlocksNested) return DEFAULT_PASTE_OFFSET
+
   const minX = Math.min(...clipboardBlocks.map((b) => b.position.x))
   const maxX = Math.max(
     ...clipboardBlocks.map((b) => {
@@ -921,8 +935,8 @@ const WorkflowContent = React.memo(() => {
 
   const handleContextPaste = useCallback(() => {
     if (!hasClipboard()) return
-    executePasteOperation('paste', calculatePasteOffset(clipboard, screenToFlowPosition))
-  }, [hasClipboard, executePasteOperation, clipboard, screenToFlowPosition])
+    executePasteOperation('paste', calculatePasteOffset(clipboard, screenToFlowPosition, blocks))
+  }, [hasClipboard, executePasteOperation, clipboard, screenToFlowPosition, blocks])
 
   const handleContextDuplicate = useCallback(() => {
     copyBlocks(contextMenuBlocks.map((b) => b.id))
@@ -1036,7 +1050,10 @@ const WorkflowContent = React.memo(() => {
       } else if ((event.ctrlKey || event.metaKey) && event.key === 'v') {
         if (effectivePermissions.canEdit && hasClipboard()) {
           event.preventDefault()
-          executePasteOperation('paste', calculatePasteOffset(clipboard, screenToFlowPosition))
+          executePasteOperation(
+            'paste',
+            calculatePasteOffset(clipboard, screenToFlowPosition, blocks)
+          )
         }
       }
     }
@@ -1058,6 +1075,7 @@ const WorkflowContent = React.memo(() => {
     clipboard,
     screenToFlowPosition,
     executePasteOperation,
+    blocks,
   ])
 
   /**

apps/sim/stores/workflows/utils.ts

@@ -574,13 +574,14 @@ export function regenerateBlockIds(
     const newNormalizedName = normalizeName(newName)
     nameMap.set(oldNormalizedName, newNormalizedName)
 
-    // Check if this block has a parent that's also being copied
-    // If so, it's a nested block and should keep its relative position (no offset)
-    // Only top-level blocks (no parent in the paste set) get the position offset
+    // Position handling depends on parent relationship:
+    // 1. Parent in paste set: both get copied, child keeps relative position (no offset - parent also moves)
+    // 2. Parent in workflow only: duplicate within same container, relative position + offset
+    // 3. No parent: absolute position + offset
     const hasParentInPasteSet = block.data?.parentId && blocks[block.data.parentId]
     const newPosition = hasParentInPasteSet
-      ? { x: block.position.x, y: block.position.y } // Keep relative position
-      : { x: block.position.x + positionOffset.x, y: block.position.y + positionOffset.y }
+      ? { x: block.position.x, y: block.position.y } // Keep relative position unchanged
+      : { x: block.position.x + positionOffset.x, y: block.position.y + positionOffset.y } // Add offset
 
     // Placeholder block - we'll update parentId in second pass
     const newBlock: BlockState = {
@@ -602,19 +603,29 @@ export function regenerateBlockIds(
   })
 
   // Second pass: update parentId references for nested blocks
-  // If a block's parent is also being pasted, map to new parentId; otherwise clear it
+  // Priority: 1) Parent in paste set -> use new ID, 2) Parent in workflow -> keep original, 3) Clear
   Object.entries(newBlocks).forEach(([, block]) => {
     if (block.data?.parentId) {
       const oldParentId = block.data.parentId
       const newParentId = blockIdMap.get(oldParentId)
 
       if (newParentId) {
+        // Parent is also being copied - use the new parent ID
         block.data = {
           ...block.data,
           parentId: newParentId,
           extent: 'parent',
         }
+      } else if (existingBlockNames[oldParentId]) {
+        // Parent exists in current workflow - keep original parentId
+        // (e.g., duplicating a block inside a container without copying the container)
+        block.data = {
+          ...block.data,
+          parentId: oldParentId,
+          extent: 'parent',
+        }
       } else {
+        // Parent doesn't exist anywhere - clear the relationship
         block.data = { ...block.data, parentId: undefined, extent: undefined }
       }
     }

apps/sim/stores/workflows/workflow/store.ts

@@ -2,6 +2,7 @@ import { createLogger } from '@sim/logger'
 import type { Edge } from 'reactflow'
 import { create } from 'zustand'
 import { devtools } from 'zustand/middleware'
+import { CONTAINER_DIMENSIONS } from '@/lib/workflows/blocks/block-dimensions'
 import { getBlockOutputs } from '@/lib/workflows/blocks/block-outputs'
 import { getBlock } from '@/blocks'
 import type { SubBlockConfig } from '@/blocks/types'
@@ -446,7 +447,10 @@ export const useWorkflowStore = create<WorkflowStore>()(
         // Clean up orphaned nodes - blocks whose parent was removed but weren't descendants
         // This can happen in edge cases (e.g., data inconsistency, external modifications)
         const remainingBlockIds = new Set(Object.keys(newBlocks))
-        const CONTAINER_OFFSET = { x: 16, y: 50 + 16 } // leftPadding, headerHeight + topPadding
+        const CONTAINER_OFFSET = {
+          x: CONTAINER_DIMENSIONS.LEFT_PADDING,
+          y: CONTAINER_DIMENSIONS.HEADER_HEIGHT + CONTAINER_DIMENSIONS.TOP_PADDING,
+        }
 
         Object.entries(newBlocks).forEach(([blockId, block]) => {
           const parentId = block.data?.parentId