Function executeWorkflow

worker/src/temporal/workflow-runner.ts:48–504

(
  definition: WorkflowDefinition,
  request: WorkflowRunRequest = {},
  options: ExecuteWorkflowOptions = {},
)

 * Services are injected as SDK interfaces (not concrete implementations)
 */
export async function executeWorkflow(
  definition: WorkflowDefinition,
  request: WorkflowRunRequest = {},
  options: ExecuteWorkflowOptions = {},
): Promise<WorkflowRunResult> {
  const runId = options.runId ?? randomUUID();
  console.log(`🏃 [WORKFLOW RUNNER] executeWorkflow called for runId: ${runId}`);
  console.log(`📋 [WORKFLOW RUNNER] Definition has ${definition.actions.length} actions`);
  console.log(`📋 [WORKFLOW RUNNER] Entrypoint ref: ${definition.entrypoint.ref}`);

  const results = new Map<string, unknown>();
  const actionsByRef = new Map<string, (typeof definition.actions)[number]>(
    definition.actions.map((action) => [action.ref, action]),
  );

  const forwardLog: ((entry: LogEventInput) => void) | undefined = options.logs
    ? (entry) => {
        const parsed = new Date(entry.timestamp);
        const timestamp = Number.isNaN(parsed.getTime()) ? new Date() : parsed;
        void options.logs
          ?.append({
            runId: entry.runId,
            nodeRef: entry.nodeRef,
            stream: entry.stream,
            level: entry.level,
            message: entry.message,
            timestamp,
          })
          .catch((error) => {
            console.error('[Logs] Failed to append log entry', error);
          });
      }
    : undefined;

  try {
    const runAction = async (
      actionRef: string,
      schedulerContext: WorkflowSchedulerRunContext,
    ): Promise<{ activePorts?: string[] | undefined } | null> => {
      console.log(
        `🎯 [WORKFLOW RUNNER] runAction called for: ${actionRef} (triggered by: ${schedulerContext.triggeredBy || 'root'})`,
      );

      const action = actionsByRef.get(actionRef);
      if (!action) {
        throw new NotFoundError(`Action not found: ${actionRef}`, {
          resourceType: 'action',
          resourceId: actionRef,
          details: { runId },
        });
      }

      const { triggeredBy, failure } = schedulerContext;

      const entry = componentRegistry.getMetadata(action.componentId);
      if (!entry) {
        throw new NotFoundError(`Component not registered: ${action.componentId}`, {
          resourceType: 'component',