run from block ui disabling

Author: icecrasher321

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/action-bar/action-bar.tsx

@@ -5,9 +5,12 @@ import { useShallow } from 'zustand/react/shallow'
 import { isInputDefinitionTrigger } from '@/lib/workflows/triggers/input-definition-triggers'
 import { useUserPermissionsContext } from '@/app/workspace/[workspaceId]/providers/workspace-permissions-provider'
 import { useWorkflowExecution } from '@/app/workspace/[workspaceId]/w/[workflowId]/hooks'
-import { validateTriggerPaste } from '@/app/workspace/[workspaceId]/w/[workflowId]/utils'
+import {
+  getRunFromBlockDependencyState,
+  validateTriggerPaste,
+} from '@/app/workspace/[workspaceId]/w/[workflowId]/utils'
 import { useCollaborativeWorkflow } from '@/hooks/use-collaborative-workflow'
-import { useExecutionStore, useIsCurrentWorkflowExecuting } from '@/stores/execution'
+import { useIsCurrentWorkflowExecuting, useLastExecutionSnapshot } from '@/stores/execution'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
 import { useWorkflowStore } from '@/stores/workflows/workflow/store'
 
@@ -105,7 +108,7 @@ export const ActionBar = memo(
 
     const { activeWorkflowId } = useWorkflowRegistry()
     const isExecuting = useIsCurrentWorkflowExecuting()
-    const getLastExecutionSnapshot = useExecutionStore((s) => s.getLastExecutionSnapshot)
+    const snapshot = useLastExecutionSnapshot(activeWorkflowId)
     const userPermissions = useUserPermissionsContext()
     const edges = useWorkflowStore((state) => state.edges)
 
@@ -115,21 +118,7 @@ export const ActionBar = memo(
     const isSubflowBlock = blockType === 'loop' || blockType === 'parallel'
     const isInsideSubflow = parentId && (parentType === 'loop' || parentType === 'parallel')
 
-    const snapshot = activeWorkflowId ? getLastExecutionSnapshot(activeWorkflowId) : null
-    const incomingEdges = edges.filter((edge) => edge.target === blockId)
-    const isTriggerBlock = incomingEdges.length === 0
-
-    // Check if each source block is either executed OR is a trigger block (triggers don't need prior execution)
-    const isSourceSatisfied = (sourceId: string) => {
-      if (snapshot?.executedBlocks.includes(sourceId)) return true
-      // Check if source is a trigger (has no incoming edges itself)
-      const sourceIncomingEdges = edges.filter((edge) => edge.target === sourceId)
-      return sourceIncomingEdges.length === 0
-    }
-
-    // Non-trigger blocks need a snapshot to exist (so upstream outputs are available)
-    const dependenciesSatisfied =
-      isTriggerBlock || (snapshot && incomingEdges.every((edge) => isSourceSatisfied(edge.source)))
+    const { dependenciesSatisfied } = getRunFromBlockDependencyState(blockId, edges, snapshot)
     const canRunFromBlock =
       dependenciesSatisfied && !isNoteBlock && !isInsideSubflow && !isExecuting
 

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-workflow-execution.test.tsx

@@ -680,7 +680,7 @@ describe('useWorkflowExecution attachment uploads', () => {
     unmount()
   })
 
-  it('uses fresh execution for trigger block runs instead of restoring an empty snapshot', async () => {
+  it('uses fresh execution for trigger block runs and stores their snapshot', async () => {
     const currentBlocks = {
       ...workflowBlocks,
       start: {
@@ -694,6 +694,18 @@ describe('useWorkflowExecution attachment uploads', () => {
       loops: {},
       parallels: {},
     })
+    mockExecute.mockImplementationOnce(async (options) => {
+      executionStoreState.getCurrentExecutionId.mockReturnValue('execution-1')
+      options.onExecutionId?.('execution-1')
+      await options.callbacks?.onExecutionCompleted?.({
+        success: true,
+        output: {},
+        duration: 10,
+        startTime: '2026-08-04T00:00:00.000Z',
+        endTime: '2026-08-04T00:00:00.010Z',
+        finalBlockLogs: [],
+      })
+    })
     const { result, unmount } = renderWorkflowExecutionHook()
 
     await act(async () => {
@@ -717,6 +729,13 @@ describe('useWorkflowExecution attachment uploads', () => {
     )
     expect(mockExecute.mock.calls[0]?.[0]).not.toHaveProperty('sourceSnapshot')
     expect(mockExecuteFromBlock).not.toHaveBeenCalled()
+    expect(executionStoreState.setLastExecutionSnapshot).toHaveBeenCalledWith(
+      'workflow-1',
+      expect.objectContaining({
+        sourceExecutionId: 'execution-1',
+        executedBlocks: ['start'],
+      })
+    )
 
     unmount()
   })

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-workflow-execution.ts

@@ -41,6 +41,7 @@ import {
   TriggerUtils,
 } from '@/lib/workflows/triggers/triggers'
 import { useCurrentWorkflow } from '@/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-current-workflow'
+import { getRunFromBlockDependencyState } from '@/app/workspace/[workspaceId]/w/[workflowId]/utils/run-from-block'
 import {
   type UploadedWorkflowAttachment,
   uploadWorkflowAttachments,
@@ -1921,26 +1922,14 @@ export function useWorkflowExecution() {
       const snapshot = getLastExecutionSnapshot(workflowId)
       const latestWorkflowState = useWorkflowStore.getState().getWorkflowState()
       const workflowEdges = latestWorkflowState.edges
-      const incomingEdges = workflowEdges.filter((edge) => edge.target === blockId)
-      const isTriggerBlock = incomingEdges.length === 0
-
-      // Check if each source block is either executed OR is a trigger block (triggers don't need prior execution)
-      const isSourceSatisfied = (sourceId: string) => {
-        if (snapshot?.executedBlocks.includes(sourceId)) return true
-        // Check if source is a trigger (has no incoming edges itself)
-        const sourceIncomingEdges = workflowEdges.filter((edge) => edge.target === sourceId)
-        return sourceIncomingEdges.length === 0
-      }
+      const { isEntryBlock: isTriggerBlock, dependenciesSatisfied } =
+        getRunFromBlockDependencyState(blockId, workflowEdges, snapshot ?? undefined)
 
-      // Non-trigger blocks need a snapshot to exist (so upstream outputs are available)
       if (!snapshot && !isTriggerBlock) {
         logger.error('No execution snapshot available for run-from-block', { workflowId, blockId })
         return
       }
 
-      const dependenciesSatisfied =
-        isTriggerBlock || incomingEdges.every((edge) => isSourceSatisfied(edge.source))
-
       if (!dependenciesSatisfied) {
         logger.error('Upstream dependencies not satisfied for run-from-block', {
           workflowId,

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/index.ts

@@ -3,5 +3,6 @@ export * from './block-protection-utils'
 export * from './block-ring-utils'
 export * from './node-derivation'
 export * from './node-position-utils'
+export * from './run-from-block'
 export * from './workflow-canvas-helpers'
 export * from './workflow-execution-utils'

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/run-from-block.test.ts

@@ -0,0 +1,57 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { getRunFromBlockDependencyState } from '@/app/workspace/[workspaceId]/w/[workflowId]/utils/run-from-block'
+
+describe('getRunFromBlockDependencyState', () => {
+  it('allows an entry block without a snapshot', () => {
+    expect(getRunFromBlockDependencyState('trigger', [], undefined)).toEqual({
+      isEntryBlock: true,
+      dependenciesSatisfied: true,
+    })
+  })
+
+  it('requires a snapshot before running a downstream block', () => {
+    const edges = [{ source: 'trigger', target: 'function' }]
+
+    expect(getRunFromBlockDependencyState('function', edges, undefined)).toEqual({
+      isEntryBlock: false,
+      dependenciesSatisfied: false,
+    })
+  })
+
+  it('allows a downstream block after its entry predecessor has run', () => {
+    const edges = [{ source: 'trigger', target: 'function' }]
+
+    expect(
+      getRunFromBlockDependencyState('function', edges, { executedBlocks: ['trigger'] })
+    ).toEqual({
+      isEntryBlock: false,
+      dependenciesSatisfied: true,
+    })
+  })
+
+  it('requires every non-entry predecessor to have cached output', () => {
+    const edges = [
+      { source: 'trigger', target: 'producer' },
+      { source: 'producer', target: 'consumer' },
+      { source: 'trigger', target: 'consumer' },
+    ]
+
+    expect(
+      getRunFromBlockDependencyState('consumer', edges, { executedBlocks: ['trigger'] })
+    ).toEqual({
+      isEntryBlock: false,
+      dependenciesSatisfied: false,
+    })
+    expect(
+      getRunFromBlockDependencyState('consumer', edges, {
+        executedBlocks: ['trigger', 'producer'],
+      })
+    ).toEqual({
+      isEntryBlock: false,
+      dependenciesSatisfied: true,
+    })
+  })
+})

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/run-from-block.ts

@@ -0,0 +1,35 @@
+import type { WorkflowEdgeEndpoints } from '@sim/workflow-types/workflow'
+import type { SerializableExecutionState } from '@/executor/execution/types'
+
+export interface RunFromBlockDependencyState {
+  isEntryBlock: boolean
+  dependenciesSatisfied: boolean
+}
+
+/**
+ * Evaluates whether a block has the cached upstream state required for run-from-block execution.
+ */
+export function getRunFromBlockDependencyState(
+  blockId: string,
+  edges: WorkflowEdgeEndpoints[],
+  snapshot?: Pick<SerializableExecutionState, 'executedBlocks'>
+): RunFromBlockDependencyState {
+  const incomingEdges = edges.filter((edge) => edge.target === blockId)
+  const isEntryBlock = incomingEdges.length === 0
+
+  if (isEntryBlock) {
+    return { isEntryBlock, dependenciesSatisfied: true }
+  }
+
+  if (!snapshot) {
+    return { isEntryBlock, dependenciesSatisfied: false }
+  }
+
+  const executedBlocks = new Set(snapshot.executedBlocks)
+  const blocksWithIncomingEdges = new Set(edges.map((edge) => edge.target))
+  const dependenciesSatisfied = incomingEdges.every(
+    (edge) => executedBlocks.has(edge.source) || !blocksWithIncomingEdges.has(edge.source)
+  )
+
+  return { isEntryBlock, dependenciesSatisfied }
+}

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

@@ -58,6 +58,7 @@ import {
   getDescendantBlockIds,
   getEdgeSelectionContextId,
   getNodeSelectionContextId,
+  getRunFromBlockDependencyState,
   getWorkflowLockToggleIds,
   isBlockProtected,
   isEdgeProtected,
@@ -93,7 +94,11 @@ import { useCollaborativeWorkflow } from '@/hooks/use-collaborative-workflow'
 import { useOAuthReturnForWorkflow } from '@/hooks/use-oauth-return'
 import { useCanvasModeStore } from '@/stores/canvas-mode'
 import { useChatStore } from '@/stores/chat/store'
-import { defaultWorkflowExecutionState, useExecutionStore } from '@/stores/execution'
+import {
+  defaultWorkflowExecutionState,
+  useExecutionStore,
+  useLastExecutionSnapshot,
+} from '@/stores/execution'
 import { useSearchModalStore } from '@/stores/modals/search/store'
 import type { PendingConnect } from '@/stores/modals/search/types'
 import { usePanelEditorStore } from '@/stores/panel'
@@ -839,7 +844,7 @@ const WorkflowContent = React.memo(
         }
       })
     )
-    const getLastExecutionSnapshot = useExecutionStore((s) => s.getLastExecutionSnapshot)
+    const lastExecutionSnapshot = useLastExecutionSnapshot(workflowIdParam)
 
     const [dragStartParentId, setDragStartParentId] = useState<string | null>(null)
 
@@ -1386,22 +1391,11 @@ const WorkflowContent = React.memo(
         return { canRun: false, reason: undefined }
       }
       const block = contextMenuBlocks[0]
-      const snapshot = getLastExecutionSnapshot(workflowIdParam)
-      const incomingEdges = edges.filter((edge) => edge.target === block.id)
-      const isTriggerBlock = incomingEdges.length === 0
-
-      // Check if each source block is either executed OR is a trigger block (triggers don't need prior execution)
-      const isSourceSatisfied = (sourceId: string) => {
-        if (snapshot?.executedBlocks.includes(sourceId)) return true
-        // Check if source is a trigger (has no incoming edges itself)
-        const sourceIncomingEdges = edges.filter((edge) => edge.target === sourceId)
-        return sourceIncomingEdges.length === 0
-      }
-
-      // Non-trigger blocks need a snapshot to exist (so upstream outputs are available)
-      const dependenciesSatisfied =
-        isTriggerBlock ||
-        (snapshot && incomingEdges.every((edge) => isSourceSatisfied(edge.source)))
+      const { dependenciesSatisfied } = getRunFromBlockDependencyState(
+        block.id,
+        edges,
+        lastExecutionSnapshot
+      )
       const isNoteBlock = block.type === 'note'
       const isInsideSubflow =
         block.parentId && (block.parentType === 'loop' || block.parentType === 'parallel')
@@ -1412,7 +1406,7 @@ const WorkflowContent = React.memo(
       if (isExecuting) return { canRun: false, reason: undefined }
 
       return { canRun: true, reason: undefined }
-    }, [contextMenuBlocks, edges, workflowIdParam, getLastExecutionSnapshot, isExecuting])
+    }, [contextMenuBlocks, edges, lastExecutionSnapshot, isExecuting])
 
     const handleContextAddBlock = useCallback(() => {
       useSearchModalStore.getState().open()

apps/sim/stores/execution/index.ts

@@ -2,6 +2,7 @@ export {
   useExecutionStore,
   useIsBlockActive,
   useIsCurrentWorkflowExecuting,
+  useLastExecutionSnapshot,
   useLastRunEdges,
   useLastRunPath,
 } from './store'

apps/sim/stores/execution/store-hooks.test.tsx

@@ -0,0 +1,56 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { act } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { SerializableExecutionState } from '@/executor/execution/types'
+
+vi.mock('@/stores/workflows/registry/store', () => ({
+  useWorkflowRegistry: Object.assign(
+    vi.fn(() => null),
+    {
+      getState: vi.fn(() => ({ activeWorkflowId: null })),
+    }
+  ),
+}))
+
+vi.unmock('@/stores/execution/store')
+vi.unmock('@/stores/execution/types')
+
+import { useExecutionStore, useLastExecutionSnapshot } from '@/stores/execution/store'
+
+describe('useLastExecutionSnapshot', () => {
+  beforeEach(() => {
+    useExecutionStore.getState().reset()
+  })
+
+  it('updates consumers when the workflow snapshot changes', () => {
+    ;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
+    const container = document.createElement('div')
+    const root: Root = createRoot(container)
+    let latest: SerializableExecutionState | undefined
+
+    function Probe() {
+      latest = useLastExecutionSnapshot('workflow-1')
+      return null
+    }
+
+    act(() => root.render(<Probe />))
+    expect(latest).toBeUndefined()
+
+    const snapshot: SerializableExecutionState = {
+      blockStates: {},
+      executedBlocks: ['trigger'],
+      blockLogs: [],
+      decisions: { router: {}, condition: {} },
+      completedLoops: [],
+      activeExecutionPath: ['trigger'],
+    }
+
+    act(() => useExecutionStore.getState().setLastExecutionSnapshot('workflow-1', snapshot))
+    expect(latest).toBe(snapshot)
+
+    act(() => root.unmount())
+  })
+})

apps/sim/stores/execution/store.ts

@@ -213,6 +213,15 @@ export function useIsCurrentWorkflowExecuting(): boolean {
   })
 }
 
+/**
+ * Returns the latest execution snapshot for a workflow and updates when that snapshot changes.
+ */
+export function useLastExecutionSnapshot(workflowId?: string | null) {
+  return useExecutionStore((state) =>
+    workflowId ? state.lastExecutionSnapshots.get(workflowId) : undefined
+  )
+}
+
 /**
  * Returns whether a specific block is currently active (executing) in the current workflow.
  * More granular than useCurrentWorkflowExecution — only re-renders when