Function handleSuccess

worker/src/temporal/workflow-scheduler.ts:216–283

(
  ref: string,
  activePorts: string[] | undefined,
  readyQueue: ReadyItem[],
  pending: Set<string>,
  nodeStates: Map<string, NodeState>,
  successEdges: Map<string, WorkflowEdge[]>,
  onNodeSkipped?: (ref: string) => Promise<void>,
)

}

async function handleSuccess(
  ref: string,
  activePorts: string[] | undefined,
  readyQueue: ReadyItem[],
  pending: Set<string>,
  nodeStates: Map<string, NodeState>,
  successEdges: Map<string, WorkflowEdge[]>,
  onNodeSkipped?: (ref: string) => Promise<void>,
) {
  const edges = successEdges.get(ref) ?? [];

  const triggeredChildren = new Set<string>();
  const skippedChildren = new Set<string>();

  for (const edge of edges) {
    let isActive = true;
    if (activePorts) {
      const port = edge.sourceHandle ?? 'default';
      isActive = activePorts.includes(port);
    }

    if (isActive) {
      triggeredChildren.add(edge.targetRef);
    } else {
      skippedChildren.add(edge.targetRef);
    }
  }

  // Refine sets: if ANY edge to a child is active, the child is triggered.
  // Only if ALL edges to the child are inactive (from this parent) do we consider it skipped from this parent's perspective.
  // Actually, we process edges. If Ref A -> Ref B via "Default" (active) AND via "Error" (inactive),
  // Ref B is triggered.

  const finalTriggered = new Set(triggeredChildren);
  const finalSkipped = new Set<string>();

  for (const child of skippedChildren) {
    if (!finalTriggered.has(child)) {
      finalSkipped.add(child);
    }
  }

  for (const child of finalTriggered) {
    await processChild(
      child,
      ref,
      'fulfilled',
      readyQueue,
      pending,
      nodeStates,
      successEdges,
      onNodeSkipped,
    );
  }

  for (const child of finalSkipped) {
    await processChild(
      child,