Method executeFromBlock

apps/sim/executor/execution/executor.ts:128–266

* Execute from a specific block using cached outputs for upstream blocks.

(
    workflowId: string,
    startBlockId: string,
    sourceSnapshot: SerializableExecutionState
  )

   * Execute from a specific block using cached outputs for upstream blocks.
   */
  async executeFromBlock(
    workflowId: string,
    startBlockId: string,
    sourceSnapshot: SerializableExecutionState
  ): Promise<ExecutionResult> {
    // Build full DAG with all blocks to compute upstream set for snapshot filtering
    // includeAllBlocks is needed because the startBlockId might be a trigger not reachable from the main trigger
    const dag = this.dagBuilder.build(this.workflow, { includeAllBlocks: true })

    const executedBlocks = new Set(sourceSnapshot.executedBlocks)
    const validation = validateRunFromBlock(startBlockId, dag, executedBlocks)
    if (!validation.valid) {
      throw new Error(validation.error)
    }

    const { dirtySet, upstreamSet, reachableUpstreamSet } = computeExecutionSets(dag, startBlockId)
    const effectiveStartBlockId = resolveContainerToSentinelStart(startBlockId, dag) ?? startBlockId

    // Extract container IDs from sentinel IDs in reachable upstream set
    // Use reachableUpstreamSet (not upstreamSet) to preserve sibling branch outputs
    // Example: A->C, B->C where C references A.result || B.result
    // When running from A, B's output should be preserved for C to reference
    const reachableContainerIds = new Set<string>()
    for (const nodeId of reachableUpstreamSet) {
      const loopId = extractLoopIdFromSentinel(nodeId)
      if (loopId) reachableContainerIds.add(loopId)
      const parallelId = extractParallelIdFromSentinel(nodeId)
      if (parallelId) reachableContainerIds.add(parallelId)
    }

    // Filter snapshot to include all blocks reachable from dirty blocks
    // This preserves sibling branch outputs that dirty blocks may reference
    const filteredBlockStates: Record<string, any> = {}
    for (const [blockId, state] of Object.entries(sourceSnapshot.blockStates)) {
      const aliasBaseId = stripOuterBranchSuffix(blockId)
      const isReachableOuterBranchAlias =
        aliasBaseId !== blockId &&
        Array.from(reachableUpstreamSet).some(
          (reachableId) => stripCloneSuffixes(reachableId) === aliasBaseId
        )
      if (
        reachableUpstreamSet.has(blockId) ||
        reachableContainerIds.has(blockId) ||
        isReachableOuterBranchAlias
      ) {
        filteredBlockStates[blockId] = state
      }
    }
    const filteredExecutedBlocks = sourceSnapshot.executedBlocks.filter((id) => {
      const aliasBaseId = stripOuterBranchSuffix(id)
      const isReachableOuterBranchAlias =
        aliasBaseId !== id &&
        Array.from(reachableUpstreamSet).some(
          (reachableId) => stripCloneSuffixes(reachableId) === aliasBaseId
        )
      return (
        reachableUpstreamSet.has(id) || reachableContainerIds.has(id) || isReachableOuterBranchAlias
      )