improvement(executor): dot-free names keep reference ownership on legacy collisions

Name uniqueness is enforced at the normalized level on create and rename, so
new collisions cannot be created. For legacy workflows that already contain
names differing only by dots, the resolver now lets the dot-free name own the
reference key regardless of block order, so previously working references
never change targets.

Author: waleedlatif1

apps/sim/executor/variables/resolvers/block.test.ts

@@ -254,6 +254,23 @@ describe('BlockResolver', () => {
       expect(resolver.resolve('<hunterio1.score>', ctx)).toBe(92)
     })
 
+    it.concurrent('should keep dot-free names as the reference target on legacy collisions', () => {
+      const blocks = [
+        { id: 'block-dotted', name: 'Hunter.io 1' },
+        { id: 'block-plain', name: 'Hunterio 1' },
+      ]
+      const ctx = createTestContext('current', {
+        'block-dotted': { email: 'dotted@acme.com' },
+        'block-plain': { email: 'plain@acme.com' },
+      })
+
+      const resolver = new BlockResolver(createTestWorkflow(blocks))
+      expect(resolver.resolve('<hunterio1.email>', ctx)).toBe('plain@acme.com')
+
+      const reversedResolver = new BlockResolver(createTestWorkflow([...blocks].reverse()))
+      expect(reversedResolver.resolve('<hunterio1.email>', ctx)).toBe('plain@acme.com')
+    })
+
     it.concurrent('should resolve nested property path', () => {
       const workflow = createTestWorkflow([{ id: 'source' }])
       const resolver = new BlockResolver(workflow)

apps/sim/executor/variables/resolvers/block.ts

@@ -43,7 +43,18 @@ export class BlockResolver implements Resolver {
     for (const block of workflow.blocks) {
       this.blockById.set(block.id, block)
       if (block.metadata?.name) {
-        this.nameToBlockId.set(normalizeName(block.metadata.name), block.id)
+        // Name uniqueness is enforced at the normalized level on create/rename,
+        // but legacy workflows may contain names that collide only now that
+        // normalizeName strips dots. Dot-free names keep ownership of the key so
+        // previously working references never change targets.
+        const normalizedName = normalizeName(block.metadata.name)
+        const incumbentId = this.nameToBlockId.get(normalizedName)
+        const incumbentName = incumbentId
+          ? this.blockById.get(incumbentId)?.metadata?.name
+          : undefined
+        if (!incumbentId || incumbentName?.includes('.')) {
+          this.nameToBlockId.set(normalizedName, block.id)
+        }
       }
     }
     for (const loop of Object.values(workflow.loops ?? {})) {