diff --git a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/connection-block-selector/connection-block-selector.tsx b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/connection-block-selector/connection-block-selector.tsx
index 2295f32810c..39e8a4cee15 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/connection-block-selector/connection-block-selector.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/connection-block-selector/connection-block-selector.tsx
@@ -1,6 +1,14 @@
 'use client'
 
-import { useCallback, useDeferredValue, useEffect, useMemo, useRef, useState } from 'react'
+import {
+  startTransition,
+  useCallback,
+  useDeferredValue,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react'
 import { Button, cn } from '@sim/emcn'
 import { X } from '@sim/emcn/icons'
 import { WorkflowBlockBorder, type WorkflowBorderPort } from '@sim/workflow-renderer'
@@ -45,6 +53,8 @@ const SELECTOR_ACTION_MENU_RIGHT_INSET = 24
 const SELECTOR_ACTION_MENU_AMPLITUDE = 7
 const RECENT_SELECTION_LIMIT = 3
 const RECENT_SELECTION_STORAGE_PREFIX = 'sim:connection-block-selector:recent'
+const BROWSE_PREFETCH_MARGIN_PX = 640
+const BROWSE_PAGE_SIZE = 50
 const POPULAR_BLOCK_TYPES = [
   'agent',
   'function',
@@ -54,6 +64,11 @@ const POPULAR_BLOCK_TYPES = [
   'memory',
 ] as const
 
+/** Ordered prefix that reuses the source array once `count` covers all of it. */
+function takePrefix<T>(items: T[], count: number): T[] {
+  return count >= items.length ? items : items.slice(0, Math.max(0, count))
+}
+
 const SELECTOR_PORTS: WorkflowBorderPort[] = [
   {
     id: 'target',
@@ -136,9 +151,11 @@ export function ConnectionBlockSelector({ id, data }: NodeProps<ConnectionBlockS
   const posthog = usePostHog()
   const inputRef = useRef<HTMLInputElement>(null)
   const listRef = useRef<HTMLDivElement>(null)
+  const browseSentinelRef = useRef<HTMLDivElement>(null)
   const [search, setSearch] = useState('')
   const [selectedValue, setSelectedValue] = useState('')
   const [recentSelections, setRecentSelections] = useState<RecentSelection[]>([])
+  const [browseLimit, setBrowseLimit] = useState(BROWSE_PAGE_SIZE)
   const deferredSearch = useDeferredValue(search)
   const isSearching = deferredSearch.trim().length > 0
   const recentStorageKey = `${RECENT_SELECTION_STORAGE_PREFIX}:${workspaceId}`
@@ -260,6 +277,42 @@ export function ConnectionBlockSelector({ id, data }: NodeProps<ConnectionBlockS
     () => availableTools.filter((tool) => !recentSelectionKeys.has(`tool:${tool.id}`)),
     [availableTools, recentSelectionKeys]
   )
+  const visibleBrowseBlocks = useMemo(
+    () => takePrefix(browseBlocks, browseLimit),
+    [browseBlocks, browseLimit]
+  )
+  const visibleBrowseTools = useMemo(
+    () => takePrefix(browseTools, browseLimit - browseBlocks.length),
+    [browseBlocks.length, browseLimit, browseTools]
+  )
+  const hasMoreBrowseResults = browseLimit < browseBlocks.length + browseTools.length
+
+  /**
+   * Mounting every cmdk item up front caused the frame spike; a manual "show
+   * more" control would leak that constraint into the UI. Prefetching near the
+   * viewport keeps scrolling continuous and cmdk's keyboard navigation intact.
+   */
+  useEffect(() => {
+    const list = listRef.current
+    const sentinel = browseSentinelRef.current
+    if (isSearching || !hasMoreBrowseResults || !list || !sentinel) return
+
+    const observer = new IntersectionObserver(
+      ([entry]) => {
+        if (!entry.isIntersecting) return
+        startTransition(() => {
+          setBrowseLimit((current) => current + BROWSE_PAGE_SIZE)
+        })
+      },
+      {
+        root: list,
+        rootMargin: `0px 0px ${BROWSE_PREFETCH_MARGIN_PX}px 0px`,
+      }
+    )
+
+    observer.observe(sentinel)
+    return () => observer.disconnect()
+  }, [hasMoreBrowseResults, isSearching])
 
   const dispatchSelection = useCallback(
     (type: string, resultType: 'block' | 'tool' | 'tool_operation', presetOperation?: string) => {
@@ -480,11 +533,14 @@ export function ConnectionBlockSelector({ id, data }: NodeProps<ConnectionBlockS
                 )}
                 <BlocksGroup items={popularBlocks} onSelect={handleBlockSelect} heading='Popular' />
                 <BlocksGroup
-                  items={browseBlocks}
+                  items={visibleBrowseBlocks}
                   onSelect={handleBlockSelect}
                   heading='All blocks'
                 />
-                <ToolsGroup items={browseTools} onSelect={handleToolSelect} />
+                <ToolsGroup items={visibleBrowseTools} onSelect={handleToolSelect} />
+                {hasMoreBrowseResults && (
+                  <div ref={browseSentinelRef} aria-hidden='true' className='h-px' />
+                )}
               </>
             )}
           </CommandFadedList>
diff --git a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/tool-input.tsx b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/tool-input.tsx
index 55920dce208..6807d20e44b 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/tool-input.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tool-input/tool-input.tsx
@@ -464,6 +464,9 @@ function UnsupportedToolBadge({ message }: { message: string }) {
   )
 }
 
+const EMPTY_COMBOBOX_GROUPS: ComboboxOptionGroup[] = []
+const EMPTY_COMBOBOX_OPTIONS: ComboboxOption[] = []
+
 export const ToolInput = memo(function ToolInput({
   blockId,
   subBlockId,
@@ -1403,6 +1406,7 @@ export const ToolInput = memo(function ToolInput({
    * @returns Array of option groups for the combobox component
    */
   const toolGroups = useMemo((): ComboboxOptionGroup[] => {
+    if (!open) return EMPTY_COMBOBOX_GROUPS
     const groups: ComboboxOptionGroup[] = []
 
     // MCP Server drill-down: when navigated into a server, show only its tools
@@ -1681,6 +1685,7 @@ export const ToolInput = memo(function ToolInput({
 
     return groups
   }, [
+    open,
     mcpServerDrilldown,
     customTools,
     availableMcpTools,
@@ -1705,7 +1710,7 @@ export const ToolInput = memo(function ToolInput({
   return (
     <div className='w-full space-y-2'>
       <Combobox
-        options={[]}
+        options={EMPTY_COMBOBOX_OPTIONS}
         groups={toolGroups}
         placeholder='Add tool...'
         /* Every list this picker offers — blocks, operations, MCP and custom
diff --git a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/search-replace/workflow-search-replace.tsx b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/search-replace/workflow-search-replace.tsx
index 90d773f7933..e85add48337 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/search-replace/workflow-search-replace.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/search-replace/workflow-search-replace.tsx
@@ -1,6 +1,6 @@
 'use client'
 
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { type RefObject, useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { Button, cn, Input, toast } from '@sim/emcn'
 import { ChevronDown, ChevronRight, ChevronUp, X } from '@sim/emcn/icons'
 import { useParams } from 'next/navigation'
@@ -110,6 +110,30 @@ function createActiveSearchTarget(
 }
 
 export function WorkflowSearchReplace() {
+  const { isOpen, open } = useWorkflowSearchReplaceStore(
+    useShallow((state) => ({ isOpen: state.isOpen, open: state.open }))
+  )
+  const focusSearchInputRef = useRef<(() => void) | null>(null)
+
+  useRegisterGlobalCommands([
+    createCommand({
+      id: 'open-workflow-search-replace',
+      handler: () => {
+        open()
+        focusSearchInputRef.current?.()
+      },
+    }),
+  ])
+
+  return isOpen ? <WorkflowSearchReplacePanel focusRef={focusSearchInputRef} /> : null
+}
+
+interface WorkflowSearchReplacePanelProps {
+  /** Lets the shortcut re-select the query while the panel is already open. */
+  focusRef: RefObject<(() => void) | null>
+}
+
+function WorkflowSearchReplacePanel({ focusRef }: WorkflowSearchReplacePanelProps) {
   const params = useParams()
   const workspaceId = params.workspaceId as string | undefined
   const routeWorkflowId = params.workflowId as string | undefined
@@ -143,38 +167,33 @@ export function WorkflowSearchReplace() {
   >({})
 
   const {
-    isOpen,
     query,
     replacement: textReplacement,
     activeMatchId,
     position,
     close,
-    open,
     setPosition,
     setQuery,
     setReplacement,
     setActiveMatchId,
   } = useWorkflowSearchReplaceStore(
     useShallow((state) => ({
-      isOpen: state.isOpen,
       query: state.query,
       replacement: state.replacement,
       activeMatchId: state.activeMatchId,
       position: state.position,
       close: state.close,
-      open: state.open,
       setPosition: state.setPosition,
       setQuery: state.setQuery,
       setReplacement: state.setReplacement,
       setActiveMatchId: state.setActiveMatchId,
     }))
   )
-  const prevQueryRef = useRef(query)
-  const prevIsOpenRef = useRef(false)
+  const prevQueryRef = useRef<string | null>(null)
   const afterReplaceIndexRef = useRef<number | null>(null)
-  const { data: workspaceCredentials } = useWorkspaceCredentials({ workspaceId, enabled: isOpen })
-  const { data: customTools = [] } = useCustomTools(isOpen && workspaceId ? workspaceId : '')
-  const { mcpTools } = useMcpTools(isOpen && workspaceId ? workspaceId : '')
+  const { data: workspaceCredentials } = useWorkspaceCredentials({ workspaceId })
+  const { data: customTools = [] } = useCustomTools(workspaceId ?? '')
+  const { mcpTools } = useMcpTools(workspaceId ?? '')
   const mcpToolNamesById = useMemo(() => {
     const names = new Map<string, string>()
     for (const t of mcpTools) {
@@ -183,19 +202,6 @@ export function WorkflowSearchReplace() {
     return names
   }, [mcpTools])
 
-  useRegisterGlobalCommands([
-    createCommand({
-      id: 'open-workflow-search-replace',
-      handler: () => {
-        open()
-        requestAnimationFrame(() => {
-          searchInputRef.current?.focus()
-          searchInputRef.current?.select()
-        })
-      },
-    }),
-  ])
-
   const searchBlocks = useMemo(
     () =>
       getWorkflowSearchBlocks({
@@ -267,10 +273,17 @@ export function WorkflowSearchReplace() {
   )
 
   useEffect(() => {
-    if (!isOpen) return
-    searchInputRef.current?.focus()
-    searchInputRef.current?.select()
-  }, [isOpen])
+    const focusSearchInput = () => {
+      searchInputRef.current?.focus()
+      searchInputRef.current?.select()
+    }
+    focusSearchInput()
+    focusRef.current = focusSearchInput
+    return () => {
+      focusRef.current = null
+      usePanelEditorSearchStore.getState().setActiveSearchTarget(null)
+    }
+  }, [focusRef])
 
   const panelHeight = isReplaceExpanded
     ? SEARCH_PANEL_EXPANDED_HEIGHT
@@ -288,7 +301,7 @@ export function WorkflowSearchReplace() {
   })
 
   useFloatBoundarySync({
-    isOpen,
+    isOpen: true,
     position: actualPosition,
     width: SEARCH_PANEL_WIDTH,
     height: panelHeight,
@@ -384,14 +397,6 @@ export function WorkflowSearchReplace() {
   }
 
   useEffect(() => {
-    if (!isOpen) {
-      prevIsOpenRef.current = false
-      usePanelEditorSearchStore.getState().setActiveSearchTarget(null)
-      return
-    }
-
-    const justOpened = !prevIsOpenRef.current
-    prevIsOpenRef.current = true
     const queryChanged = prevQueryRef.current !== query
     prevQueryRef.current = query
 
@@ -406,7 +411,7 @@ export function WorkflowSearchReplace() {
       const replaceIndex = afterReplaceIndexRef.current
       afterReplaceIndexRef.current = null
 
-      if (queryChanged || justOpened) {
+      if (queryChanged) {
         handleSelectMatch(hydratedMatches[0].id)
       } else if (replaceIndex !== null) {
         handleSelectMatch(hydratedMatches[Math.min(replaceIndex, hydratedMatches.length - 1)].id)
@@ -422,9 +427,7 @@ export function WorkflowSearchReplace() {
     usePanelEditorSearchStore
       .getState()
       .setActiveSearchTarget(createActiveSearchTarget(activeHydratedMatch, query))
-  }, [activeMatchId, handleSelectMatch, hydratedMatches, isOpen, query, setActiveMatchId])
-
-  if (!isOpen) return null
+  }, [activeMatchId, handleSelectMatch, hydratedMatches, query, setActiveMatchId])
 
   const handleMoveActiveMatch = (delta: number) => {
     if (hydratedMatches.length === 0) return
diff --git a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-canvas-helpers.test.ts b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-canvas-helpers.test.ts
index d432a2a9126..5c45ab5c1cb 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-canvas-helpers.test.ts
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-canvas-helpers.test.ts
@@ -3,10 +3,166 @@
  */
 import { describe, expect, it } from 'vitest'
 import {
+  getArrowNavigationDirection,
   isPositionalTriggerBlock,
+  reconcileCanvasEdges,
+  reconcileCanvasNodes,
   shouldHighlightContainerDropTarget,
 } from '@/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-canvas-helpers'
 
+describe('getArrowNavigationDirection', () => {
+  it('moves once for a fresh horizontal arrow press', () => {
+    expect(
+      getArrowNavigationDirection({
+        key: 'ArrowRight',
+        repeat: false,
+        metaKey: false,
+        ctrlKey: false,
+        altKey: false,
+        shiftKey: false,
+      })
+    ).toBe(1)
+    expect(
+      getArrowNavigationDirection({
+        key: 'ArrowLeft',
+        repeat: false,
+        metaKey: false,
+        ctrlKey: false,
+        altKey: false,
+        shiftKey: false,
+      })
+    ).toBe(-1)
+  })
+
+  it('ignores held-arrow repeat events instead of restarting canvas navigation', () => {
+    expect(
+      getArrowNavigationDirection({
+        key: 'ArrowRight',
+        repeat: true,
+        metaKey: false,
+        ctrlKey: false,
+        altKey: false,
+        shiftKey: false,
+      })
+    ).toBeNull()
+  })
+
+  it('ignores modified arrows and unrelated keys', () => {
+    expect(
+      getArrowNavigationDirection({
+        key: 'ArrowDown',
+        repeat: false,
+        metaKey: false,
+        ctrlKey: false,
+        altKey: false,
+        shiftKey: true,
+      })
+    ).toBeNull()
+    expect(
+      getArrowNavigationDirection({
+        key: 'Enter',
+        repeat: false,
+        metaKey: false,
+        ctrlKey: false,
+        altKey: false,
+        shiftKey: false,
+      })
+    ).toBeNull()
+  })
+})
+
+describe('canvas reference reconciliation', () => {
+  it('preserves unaffected node references when one block measurement changes', () => {
+    const currentNodes = [
+      {
+        id: 'block-1',
+        position: { x: 0, y: 0 },
+        data: { name: 'One' },
+        height: 100,
+        selected: true,
+      },
+      {
+        id: 'block-2',
+        position: { x: 200, y: 0 },
+        data: { name: 'Two' },
+        height: 100,
+        selected: false,
+      },
+    ]
+    const derivedNodes = [
+      {
+        id: 'block-1',
+        position: { x: 0, y: 0 },
+        data: { name: 'One' },
+        height: 120,
+      },
+      {
+        id: 'block-2',
+        position: { x: 200, y: 0 },
+        data: { name: 'Two' },
+        height: 100,
+      },
+    ]
+
+    const reconciled = reconcileCanvasNodes(currentNodes, derivedNodes)
+
+    expect(reconciled).not.toBe(currentNodes)
+    expect(reconciled[0]).not.toBe(currentNodes[0])
+    expect(reconciled[0].selected).toBe(true)
+    expect(reconciled[1]).toBe(currentNodes[1])
+  })
+
+  it('preserves edge references when a graph refresh changes no edge semantics', () => {
+    const onDelete = () => {}
+    const currentEdges = [
+      {
+        id: 'edge-1',
+        source: 'block-1',
+        target: 'block-2',
+        data: { onDelete, isSelected: false },
+      },
+    ]
+    const derivedEdges = [
+      {
+        id: 'edge-1',
+        source: 'block-1',
+        target: 'block-2',
+        data: { onDelete, isSelected: false },
+      },
+    ]
+
+    const reconciled = reconcileCanvasEdges(currentEdges, derivedEdges)
+
+    expect(reconciled).toBe(currentEdges)
+    expect(reconciled[0]).toBe(currentEdges[0])
+  })
+
+  it('applies derived graph order while retaining unchanged item references', () => {
+    const currentNodes = [
+      { id: 'block-1', position: { x: 0, y: 0 }, data: {}, selected: false },
+      { id: 'block-2', position: { x: 100, y: 0 }, data: {}, selected: false },
+    ]
+    const currentEdges = [
+      { id: 'edge-1', source: 'block-1', target: 'block-2' },
+      { id: 'edge-2', source: 'block-2', target: 'block-1' },
+    ]
+
+    const reconciledNodes = reconcileCanvasNodes(currentNodes, [
+      { id: 'block-2', position: { x: 100, y: 0 }, data: {} },
+      { id: 'block-1', position: { x: 0, y: 0 }, data: {} },
+    ])
+    const reconciledEdges = reconcileCanvasEdges(currentEdges, [
+      { ...currentEdges[1] },
+      { ...currentEdges[0] },
+    ])
+
+    expect(reconciledNodes).toEqual([currentNodes[1], currentNodes[0]])
+    expect(reconciledEdges).toEqual([currentEdges[1], currentEdges[0]])
+    expect(reconciledNodes[0]).toBe(currentNodes[1])
+    expect(reconciledEdges[0]).toBe(currentEdges[1])
+  })
+})
+
 describe('isPositionalTriggerBlock', () => {
   it('returns true for a top-level block with no incoming edges', () => {
     const block = { id: 'block-1' }
diff --git a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-canvas-helpers.ts b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-canvas-helpers.ts
index 4c2120940c0..f740c4baab3 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-canvas-helpers.ts
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-canvas-helpers.ts
@@ -1,4 +1,5 @@
 import { BLOCK_DIMENSIONS, CONTAINER_DIMENSIONS, getNoteBlockHeight } from '@sim/workflow-renderer'
+import { isEqual } from 'es-toolkit'
 import type { Edge, Node } from 'reactflow'
 import { TriggerUtils } from '@/lib/workflows/triggers/triggers'
 import { clampPositionToContainer } from '@/app/workspace/[workspaceId]/w/[workflowId]/utils/node-position-utils'
@@ -6,6 +7,76 @@ import type { BlockState } from '@/stores/workflows/workflow/types'
 
 export const SUBFLOW_DROP_TARGET_CLASS = 'subflow-node-drop-target'
 
+type ArrowNavigationEvent = Pick<
+  KeyboardEvent,
+  'key' | 'repeat' | 'metaKey' | 'ctrlKey' | 'altKey' | 'shiftKey'
+>
+
+export function getArrowNavigationDirection(event: ArrowNavigationEvent): -1 | 1 | null {
+  if (event.repeat || event.metaKey || event.ctrlKey || event.altKey || event.shiftKey) return null
+  if (event.key === 'ArrowRight' || event.key === 'ArrowDown') return 1
+  if (event.key === 'ArrowLeft' || event.key === 'ArrowUp') return -1
+  return null
+}
+
+/**
+ * A derivation that changed nothing must produce no new reference at any level,
+ * so React Flow can skip the subtree. Reuse is decided by identity after
+ * projection, which also catches a pure reorder: a reused item landing at a
+ * different index breaks the positional sweep.
+ */
+function reconcileById<T extends { id: string }>(
+  current: T[],
+  derived: T[],
+  project: (derivedItem: T, currentItem: T | undefined) => T,
+  isReusable: (currentItem: T, nextItem: T) => boolean
+): T[] {
+  const currentById = new Map<string, T>()
+  for (const item of current) currentById.set(item.id, item)
+
+  const next = derived.map((derivedItem) => {
+    const currentItem = currentById.get(derivedItem.id)
+    const nextItem = project(derivedItem, currentItem)
+    return currentItem && isReusable(currentItem, nextItem) ? currentItem : nextItem
+  })
+
+  const unchanged =
+    next.length === current.length && next.every((item, index) => item === current[index])
+  return unchanged ? current : next
+}
+
+/**
+ * Subset comparison, deliberately asymmetric: React Flow writes `width`,
+ * `height`, `positionAbsolute` and `dragging` onto the node objects it owns, so
+ * a symmetric `isEqual` against a freshly derived node would never match and no
+ * node would ever be reused. Only the keys the derivation itself produces are
+ * compared.
+ */
+function containsDerivedValues<T extends object>(current: T, derived: T): boolean {
+  for (const key of Object.keys(derived) as (keyof T)[]) {
+    if (!isEqual(current[key], derived[key])) return false
+  }
+  return true
+}
+
+/** Reuses unchanged React Flow node objects while carrying local selection forward. */
+export function reconcileCanvasNodes(currentNodes: Node[], derivedNodes: Node[]): Node[] {
+  return reconcileById(
+    currentNodes,
+    derivedNodes,
+    (derivedNode, currentNode) => ({ ...derivedNode, selected: currentNode?.selected ?? false }),
+    containsDerivedValues
+  )
+}
+
+/**
+ * Reuses unchanged React Flow edge objects after graph-level derivation reruns.
+ * Edges carry no React Flow-written fields, so a plain `isEqual` is symmetric-safe.
+ */
+export function reconcileCanvasEdges(currentEdges: Edge[], derivedEdges: Edge[]): Edge[] {
+  return reconcileById(currentEdges, derivedEdges, (derivedEdge) => derivedEdge, isEqual)
+}
+
 /**
  * Collects all descendant block IDs for container blocks (loop/parallel) in the given set.
  * Used to treat a nested subflow as one unit when computing boundary edges (e.g. remove-from-subflow).
diff --git a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/workflow.tsx b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/workflow.tsx
index 9e05aa2b40d..9264b107f1c 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/workflow.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/workflow.tsx
@@ -84,6 +84,7 @@ import {
   computeClampedPositionUpdates,
   estimateBlockDimensions,
   filterProtectedBlocks,
+  getArrowNavigationDirection,
   getClampedPositionForNode,
   getDescendantBlockIds,
   getEdgeSelectionContextId,
@@ -94,6 +95,8 @@ import {
   isEdgeProtected,
   isInEditableElement,
   isPositionalTriggerBlock,
+  reconcileCanvasEdges,
+  reconcileCanvasNodes,
   resolveSelectionConflicts,
   SUBFLOW_DROP_TARGET_CLASS,
   shouldHighlightContainerDropTarget,
@@ -3004,14 +3007,7 @@ const WorkflowContent = React.memo(
         return
       }
 
-      // Preserve existing selection state
-      setDisplayNodes((currentNodes) => {
-        const selectedIds = new Set(currentNodes.filter((n) => n.selected).map((n) => n.id))
-        return derivedNodes.map((node) => ({
-          ...node,
-          selected: selectedIds.has(node.id),
-        }))
-      })
+      setDisplayNodes((currentNodes) => reconcileCanvasNodes(currentNodes, derivedNodes))
     }, [derivedNodes, blocks, pendingSelection, clearPendingSelection])
 
     /** Pans viewport to pending blocks once they have valid dimensions. */
@@ -4561,10 +4557,8 @@ const WorkflowContent = React.memo(
       if (embedded) return
 
       const handleArrowNavigation = (event: KeyboardEvent) => {
-        if (event.metaKey || event.ctrlKey || event.altKey || event.shiftKey) return
-        const isNext = event.key === 'ArrowRight' || event.key === 'ArrowDown'
-        const isPrev = event.key === 'ArrowLeft' || event.key === 'ArrowUp'
-        if (!isNext && !isPrev) return
+        const direction = getArrowNavigationDirection(event)
+        if (direction === null) return
 
         const target = event.target as HTMLElement | null
         if (
@@ -4595,8 +4589,7 @@ const WorkflowContent = React.memo(
         event.preventDefault()
         event.stopPropagation()
 
-        const nextNode =
-          ordered[(currentIndex + (isNext ? 1 : -1) + ordered.length) % ordered.length]
+        const nextNode = ordered[(currentIndex + direction + ordered.length) % ordered.length]
 
         setDisplayNodes((currentNodes) =>
           resolveSelectionConflicts(
@@ -4645,12 +4638,16 @@ const WorkflowContent = React.memo(
       [blocks, getNodes]
     )
 
+    const latestEdgesRef = useRef(edges)
+    latestEdgesRef.current = edges
+    const latestBlocksRef = useRef(blocks)
+    latestBlocksRef.current = blocks
     /** Stable delete handler to avoid creating new function references per edge. */
     const handleEdgeDelete = useCallback(
       (edgeId: string) => {
         // Prevent removing edges targeting protected blocks
-        const edge = edges.find((e) => e.id === edgeId)
-        if (edge && isEdgeProtected(edge, blocks)) {
+        const edge = latestEdgesRef.current.find((candidate) => candidate.id === edgeId)
+        if (edge && isEdgeProtected(edge, latestBlocksRef.current)) {
           toast({ message: 'Cannot remove connections to locked blocks' })
           return
         }
@@ -4666,7 +4663,7 @@ const WorkflowContent = React.memo(
           return next
         })
       },
-      [removeEdge, edges, blocks]
+      [removeEdge]
     )
 
     /*
@@ -4723,13 +4720,14 @@ const WorkflowContent = React.memo(
     const editorOpenBlockId = usePanelEditorStore((state) => state.currentBlockId)
     const panelActiveTab = usePanelStore((state) => state.activeTab)
 
+    const previousEdgesWithSelectionRef = useRef<Edge[]>([])
     const edgesWithSelection = useMemo(() => {
       const nodeMap = new Map(displayNodes.map((n) => [n.id, n]))
       /* Indexed once: this memo re-runs on every drag frame, and scanning the
          selection array twice per edge is O(edges x selection) per frame. */
       const selectedNodeIdSet = new Set(selectedNodeIds)
 
-      return edgesForDisplay.map((edge) => {
+      const derivedEdges = edgesForDisplay.map((edge) => {
         const sourceNode = nodeMap.get(edge.source)
         const targetNode = nodeMap.get(edge.target)
         const parentLoopId = sourceNode?.parentId || targetNode?.parentId
@@ -4780,6 +4778,16 @@ const WorkflowContent = React.memo(
           },
         }
       })
+      /* Deliberately impure: referential stability across renders needs the
+         previous result, and no state-shaped alternative exists. Safe because
+         reconciliation is idempotent — re-running it on its own output returns
+         that output by reference, so a discarded render cannot corrupt it. */
+      const reconciledEdges = reconcileCanvasEdges(
+        previousEdgesWithSelectionRef.current,
+        derivedEdges
+      )
+      previousEdgesWithSelectionRef.current = reconciledEdges
+      return reconciledEdges
     }, [
       edgesForDisplay,
       displayNodes,
diff --git a/apps/sim/stores/workflows/workflow/store.test.ts b/apps/sim/stores/workflows/workflow/store.test.ts
index a4d086aa1af..8e9c17b2165 100644
--- a/apps/sim/stores/workflows/workflow/store.test.ts
+++ b/apps/sim/stores/workflows/workflow/store.test.ts
@@ -1666,6 +1666,44 @@ describe('workflow store', () => {
     })
   })
 
+  describe('updateBlockLayoutMetrics', () => {
+    it('updates only the measured block and skips identical measurements', () => {
+      addBlock('block-1', 'agent', 'Agent', { x: 0, y: 0 })
+      useWorkflowStore.setState({
+        edges: [{ id: 'edge-1', source: 'block-1', target: 'block-2' }],
+        loops: {},
+        parallels: {},
+        lastSaved: 123,
+      })
+
+      const before = useWorkflowStore.getState()
+      let notifications = 0
+      const unsubscribe = useWorkflowStore.subscribe(() => {
+        notifications += 1
+      })
+
+      before.updateBlockLayoutMetrics('block-1', { width: 320, height: 180 })
+
+      const afterFirstMeasurement = useWorkflowStore.getState()
+      expect(afterFirstMeasurement.blocks['block-1'].height).toBe(180)
+      expect(afterFirstMeasurement.blocks['block-1'].layout).toEqual({
+        measuredWidth: 320,
+        measuredHeight: 180,
+      })
+      expect(afterFirstMeasurement.edges).toBe(before.edges)
+      expect(afterFirstMeasurement.loops).toBe(before.loops)
+      expect(afterFirstMeasurement.parallels).toBe(before.parallels)
+      expect(afterFirstMeasurement.lastSaved).toBe(before.lastSaved)
+      expect(notifications).toBe(1)
+
+      afterFirstMeasurement.updateBlockLayoutMetrics('block-1', { width: 320, height: 180 })
+
+      expect(useWorkflowStore.getState()).toBe(afterFirstMeasurement)
+      expect(notifications).toBe(1)
+      unsubscribe()
+    })
+  })
+
   describe('updateBlockName', () => {
     beforeEach(() => {
       useWorkflowStore.setState({
diff --git a/apps/sim/stores/workflows/workflow/store.ts b/apps/sim/stores/workflows/workflow/store.ts
index 797c49eedac..8b918aabfe9 100644
--- a/apps/sim/stores/workflows/workflow/store.ts
+++ b/apps/sim/stores/workflows/workflow/store.ts
@@ -966,6 +966,13 @@ export const useWorkflowStore = create<WorkflowStore>()(
             logger.warn(`Cannot update layout metrics: Block ${id} not found in workflow store`)
             return state
           }
+          if (
+            block.height === dimensions.height &&
+            block.layout?.measuredWidth === dimensions.width &&
+            block.layout?.measuredHeight === dimensions.height
+          ) {
+            return state
+          }
 
           return {
             blocks: {
@@ -980,12 +987,8 @@ export const useWorkflowStore = create<WorkflowStore>()(
                 },
               },
             },
-            edges: [...state.edges],
-            loops: { ...state.loops },
           }
         })
-        get().updateLastSaved()
-        // No sync needed for layout changes, just visual
       },
 
       updateLoopCount: (loopId: string, count: number) =>