fix duplicate var remap bug

Author: icecrasher321

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/variables-input/variables-input.tsx

@@ -22,6 +22,7 @@ import { useSubBlockValue } from '@/app/workspace/[workspaceId]/w/[workflowId]/c
 import { useAccessibleReferencePrefixes } from '@/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-accessible-reference-prefixes'
 import { useVariablesStore } from '@/stores/variables/store'
 import type { Variable } from '@/stores/variables/types'
+import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
 
 interface VariableAssignment {
   id: string
@@ -89,6 +90,17 @@ export function VariablesInput({
   const workflowVariables = useVariablesStore((s) => s.variables)
   const accessiblePrefixes = useAccessibleReferencePrefixes(blockId)
 
+  /**
+   * Gate destructive cleanup on the active workflow being fully hydrated. Without this gate,
+   * a brief render frame where the variables store has not yet hydrated for the current
+   * workflow would treat all assignments as orphaned and persist an empty array — destroying
+   * legitimate references. Only trust `currentWorkflowVariables` once hydration says it owns
+   * this workflow's data.
+   */
+  const isHydratedForWorkflow = useWorkflowRegistry(
+    (s) => s.hydration.phase === 'ready' && s.hydration.workflowId === workflowId
+  )
+
   const [showTags, setShowTags] = useState(false)
   const [cursorPosition, setCursorPosition] = useState(0)
   const [activeFieldId, setActiveFieldId] = useState<string | null>(null)
@@ -133,6 +145,11 @@ export function VariablesInput({
 
   useEffect(() => {
     if (isReadOnly || assignments.length === 0) return
+    // Only purge stale `variableId` references after the variables store is authoritative
+    // for this workflow. Otherwise a transient empty store on mount would wipe valid
+    // assignments — see the duplicate-of-duplicate regression where this destroyed
+    // remapped variable references on the second copy.
+    if (!isHydratedForWorkflow) return
 
     const currentVariableIds = new Set(currentWorkflowVariables.map((v) => v.id))
     const validAssignments = assignments.filter((assignment) => {
@@ -145,7 +162,7 @@ export function VariablesInput({
     } else if (validAssignments.length !== assignments.length) {
       setStoreValue(validAssignments.length > 0 ? validAssignments : [])
     }
-  }, [currentWorkflowVariables, assignments, isReadOnly, setStoreValue])
+  }, [currentWorkflowVariables, assignments, isReadOnly, isHydratedForWorkflow, setStoreValue])
 
   const addAssignment = () => {
     if (isReadOnly || allVariablesAssigned) return

apps/sim/lib/workflows/persistence/duplicate.test.ts

@@ -277,4 +277,109 @@ describe('duplicateWorkflow ordering', () => {
     expect(copiedSubBlocks.variables.value[0].variableName).toBe('customerName')
     expect(insertedBlocks?.[0].locked).toBe(false)
   })
+
+  it('remaps variable assignments when duplicating an already-duplicated source (array value)', async () => {
+    let insertedBlocks: Array<Record<string, unknown>> | null = null
+    let insertedWorkflowValues: Record<string, unknown> | null = null
+    const tx = createMockTx(
+      [
+        [
+          {
+            id: 'first-copy-workflow-id',
+            workspaceId: 'workspace-123',
+            folderId: null,
+            description: 'first copy',
+            color: '#000000',
+            variables: {
+              'first-copy-var-id': {
+                id: 'first-copy-var-id',
+                workflowId: 'first-copy-workflow-id',
+                name: 'customerName',
+                type: 'string',
+                value: 'Ada',
+              },
+            },
+          },
+        ],
+        [],
+        [],
+        [
+          {
+            id: 'first-copy-block-id',
+            workflowId: 'first-copy-workflow-id',
+            type: 'agent',
+            name: 'Agent',
+            parentId: null,
+            extent: null,
+            data: {},
+            subBlocks: {
+              variables: {
+                id: 'variables',
+                type: 'variables-input',
+                value: [
+                  {
+                    id: 'assignment-1',
+                    variableId: 'first-copy-var-id',
+                    variableName: 'customerName',
+                    type: 'string',
+                    value: 'Grace',
+                    isExisting: true,
+                  },
+                ],
+              },
+            },
+            position: { x: 0, y: 0 },
+            enabled: true,
+            horizontalHandles: true,
+            isWide: false,
+            height: 0,
+            advancedMode: false,
+            triggerMode: false,
+            locked: false,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          },
+        ],
+        [],
+        [],
+      ],
+      (values) => {
+        if (!insertedWorkflowValues && !Array.isArray(values)) {
+          insertedWorkflowValues = values
+        }
+      },
+      (values) => {
+        if (Array.isArray(values)) {
+          insertedBlocks = values as Array<Record<string, unknown>>
+        }
+      }
+    )
+
+    mockDb.transaction.mockImplementation(async (callback: (txArg: unknown) => Promise<unknown>) =>
+      callback(tx)
+    )
+
+    await duplicateWorkflow({
+      sourceWorkflowId: 'first-copy-workflow-id',
+      userId: 'user-123',
+      name: 'Duplicated Again',
+      workspaceId: 'workspace-123',
+      folderId: null,
+      requestId: 'req-second-copy',
+    })
+
+    expect(insertedBlocks).toHaveLength(1)
+    const copiedSubBlocks = insertedBlocks?.[0].subBlocks as Record<string, any>
+    expect(Array.isArray(copiedSubBlocks.variables.value)).toBe(true)
+    expect(copiedSubBlocks.variables.value).toHaveLength(1)
+
+    const newVarIds = Object.keys(
+      (insertedWorkflowValues?.variables as Record<string, unknown>) || {}
+    )
+    expect(newVarIds).toHaveLength(1)
+    const remappedVarId = copiedSubBlocks.variables.value[0].variableId
+    expect(remappedVarId).not.toBe('first-copy-var-id')
+    expect(remappedVarId).toBe(newVarIds[0])
+    expect(copiedSubBlocks.variables.value[0].variableName).toBe('customerName')
+  })
 })