@pgflow/core 0.0.0-array-map-steps-302d00a8-20250925065142 → 0.0.0-array-map-steps-b956f8f9-20251006084236

package/dist/supabase/migrations/20250916203905_pgflow_temp_handle_arrays_in_start_tasks.sql

@@ -1,157 +0,0 @@
--- Modify "start_tasks" function
-CREATE OR REPLACE FUNCTION "pgflow"."start_tasks" ("flow_slug" text, "msg_ids" bigint[], "worker_id" uuid) RETURNS SETOF "pgflow"."step_task_record" LANGUAGE sql SET "search_path" = '' AS $$
-with tasks as (
-    select
-      task.flow_slug,
-      task.run_id,
-      task.step_slug,
-      task.task_index,
-      task.message_id
-    from pgflow.step_tasks as task
-    where task.flow_slug = start_tasks.flow_slug
-      and task.message_id = any(msg_ids)
-      and task.status = 'queued'
-  ),
-  start_tasks_update as (
-    update pgflow.step_tasks
-    set 
-      attempts_count = attempts_count + 1,
-      status = 'started',
-      started_at = now(),
-      last_worker_id = worker_id
-    from tasks
-    where step_tasks.message_id = tasks.message_id
-      and step_tasks.flow_slug = tasks.flow_slug
-      and step_tasks.status = 'queued'
-  ),
-  runs as (
-    select
-      r.run_id,
-      r.input
-    from pgflow.runs r
-    where r.run_id in (select run_id from tasks)
-  ),
-  deps as (
-    select
-      st.run_id,
-      st.step_slug,
-      dep.dep_slug,
-      dep_task.output as dep_output
-    from tasks st
-    join pgflow.deps dep on dep.flow_slug = st.flow_slug and dep.step_slug = st.step_slug
-    join pgflow.step_tasks dep_task on
-      dep_task.run_id = st.run_id and
-      dep_task.step_slug = dep.dep_slug and
-      dep_task.status = 'completed'
-  ),
-  deps_outputs as (
-    select
-      d.run_id,
-      d.step_slug,
-      jsonb_object_agg(d.dep_slug, d.dep_output) as deps_output,
-      count(*) as dep_count
-    from deps d
-    group by d.run_id, d.step_slug
-  ),
-  timeouts as (
-    select
-      task.message_id,
-      task.flow_slug,
-      coalesce(step.opt_timeout, flow.opt_timeout) + 2 as vt_delay
-    from tasks task
-    join pgflow.flows flow on flow.flow_slug = task.flow_slug
-    join pgflow.steps step on step.flow_slug = task.flow_slug and step.step_slug = task.step_slug
-  ),
-  -- Batch update visibility timeouts for all messages
-  set_vt_batch as (
-    select pgflow.set_vt_batch(
-      start_tasks.flow_slug,
-      array_agg(t.message_id order by t.message_id),
-      array_agg(t.vt_delay order by t.message_id)
-    )
-    from timeouts t
-  )
-  select
-    st.flow_slug,
-    st.run_id,
-    st.step_slug,
-    -- ==========================================
-    -- INPUT CONSTRUCTION LOGIC
-    -- ==========================================
-    -- This nested CASE statement determines how to construct the input
-    -- for each task based on the step type (map vs non-map).
-    --
-    -- The fundamental difference:
-    -- - Map steps: Receive RAW array elements (e.g., just 42 or "hello")
-    -- - Non-map steps: Receive structured objects with named keys
-    --                  (e.g., {"run": {...}, "dependency1": {...}})
-    -- ==========================================
-    CASE
-      -- -------------------- MAP STEPS --------------------
-      -- Map steps process arrays element-by-element.
-      -- Each task receives ONE element from the array at its task_index position.
-      WHEN step.step_type = 'map' THEN
-        -- Map steps get raw array elements without any wrapper object
-        CASE
-          -- ROOT MAP: Gets array from run input
-          -- Example: run input = [1, 2, 3]
-          --          task 0 gets: 1
-          --          task 1 gets: 2
-          --          task 2 gets: 3
-          WHEN step.deps_count = 0 THEN
-            -- Root map (deps_count = 0): no dependencies, reads from run input.
-            -- Extract the element at task_index from the run's input array.
-            -- Note: If run input is not an array, this will return NULL
-            -- and the flow will fail (validated in start_flow).
-            jsonb_array_element(r.input, st.task_index)
-
-          -- DEPENDENT MAP: Gets array from its single dependency
-          -- Example: dependency output = ["a", "b", "c"]
-          --          task 0 gets: "a"
-          --          task 1 gets: "b"
-          --          task 2 gets: "c"
-          ELSE
-            -- Has dependencies (should be exactly 1 for map steps).
-            -- Extract the element at task_index from the dependency's output array.
-            --
-            -- Why the subquery with jsonb_each?
-            -- - The dependency outputs a raw array: [1, 2, 3]
-            -- - deps_outputs aggregates it into: {"dep_name": [1, 2, 3]}
-            -- - We need to unwrap and get just the array value
-            -- - Map steps have exactly 1 dependency (enforced by add_step)
-            -- - So jsonb_each will return exactly 1 row
-            -- - We extract the 'value' which is the raw array [1, 2, 3]
-            -- - Then get the element at task_index from that array
-            (SELECT jsonb_array_element(value, st.task_index)
-            FROM jsonb_each(dep_out.deps_output)
-            LIMIT 1)
-        END
-
-      -- -------------------- NON-MAP STEPS --------------------
-      -- Regular (non-map) steps receive ALL inputs as a structured object.
-      -- This includes the original run input plus all dependency outputs.
-      ELSE
-        -- Non-map steps get structured input with named keys
-        -- Example output: {
-        --   "run": {"original": "input"},
-        --   "step1": {"output": "from_step1"},
-        --   "step2": {"output": "from_step2"}
-        -- }
-        --
-        -- Build object with 'run' key containing original input
-        jsonb_build_object('run', r.input) ||
-        -- Merge with deps_output which already has dependency outputs
-        -- deps_output format: {"dep1": output1, "dep2": output2, ...}
-        -- If no dependencies, defaults to empty object
-        coalesce(dep_out.deps_output, '{}'::jsonb)
-    END as input,
-    st.message_id as msg_id
-  from tasks st
-  join runs r on st.run_id = r.run_id
-  join pgflow.steps step on
-    step.flow_slug = st.flow_slug and
-    step.step_slug = st.step_slug
-  left join deps_outputs dep_out on
-    dep_out.run_id = st.run_id and
-    dep_out.step_slug = st.step_slug
-$$;

package/dist/supabase/migrations/20250918042753_pgflow_temp_handle_map_output_aggregation.sql

@@ -1,489 +0,0 @@
--- Modify "maybe_complete_run" function
-CREATE OR REPLACE FUNCTION "pgflow"."maybe_complete_run" ("run_id" uuid) RETURNS void LANGUAGE plpgsql SET "search_path" = '' AS $$
-declare
-  v_completed_run pgflow.runs%ROWTYPE;
-begin
-  -- ==========================================
-  -- CHECK AND COMPLETE RUN IF FINISHED
-  -- ==========================================
-  -- ---------- Complete run if all steps done ----------
-  UPDATE pgflow.runs
-  SET
-    status = 'completed',
-    completed_at = now(),
-    -- Only compute expensive aggregation when actually completing the run
-    output = (
-      -- ---------- Gather outputs from leaf steps ----------
-      -- Leaf steps = steps with no dependents
-      -- For map steps: aggregate all task outputs into array
-      -- For single steps: use the single task output
-      SELECT jsonb_object_agg(
-        step_slug,
-        CASE
-          WHEN step_type = 'map' THEN aggregated_output
-          ELSE single_output
-        END
-      )
-      FROM (
-        SELECT DISTINCT
-          leaf_state.step_slug,
-          leaf_step.step_type,
-          -- For map steps: aggregate all task outputs
-          CASE WHEN leaf_step.step_type = 'map' THEN
-            (SELECT COALESCE(jsonb_agg(leaf_task.output ORDER BY leaf_task.task_index), '[]'::jsonb)
-             FROM pgflow.step_tasks leaf_task
-             WHERE leaf_task.run_id = leaf_state.run_id
-               AND leaf_task.step_slug = leaf_state.step_slug
-               AND leaf_task.status = 'completed')
-          END as aggregated_output,
-          -- For single steps: get the single output
-          CASE WHEN leaf_step.step_type = 'single' THEN
-            (SELECT leaf_task.output
-             FROM pgflow.step_tasks leaf_task
-             WHERE leaf_task.run_id = leaf_state.run_id
-               AND leaf_task.step_slug = leaf_state.step_slug
-               AND leaf_task.status = 'completed'
-             LIMIT 1)
-          END as single_output
-        FROM pgflow.step_states leaf_state
-        JOIN pgflow.steps leaf_step ON leaf_step.flow_slug = leaf_state.flow_slug AND leaf_step.step_slug = leaf_state.step_slug
-        WHERE leaf_state.run_id = maybe_complete_run.run_id
-          AND leaf_state.status = 'completed'
-          AND NOT EXISTS (
-            SELECT 1
-            FROM pgflow.deps dep
-            WHERE dep.flow_slug = leaf_state.flow_slug
-              AND dep.dep_slug = leaf_state.step_slug
-          )
-      ) leaf_outputs
-    )
-  WHERE pgflow.runs.run_id = maybe_complete_run.run_id
-    AND pgflow.runs.remaining_steps = 0
-    AND pgflow.runs.status != 'completed'
-  RETURNING * INTO v_completed_run;
-
-  -- ==========================================
-  -- BROADCAST COMPLETION EVENT
-  -- ==========================================
-  IF v_completed_run.run_id IS NOT NULL THEN
-    PERFORM realtime.send(
-      jsonb_build_object(
-        'event_type', 'run:completed',
-        'run_id', v_completed_run.run_id,
-        'flow_slug', v_completed_run.flow_slug,
-        'status', 'completed',
-        'output', v_completed_run.output,
-        'completed_at', v_completed_run.completed_at
-      ),
-      'run:completed',
-      concat('pgflow:run:', v_completed_run.run_id),
-      false
-    );
-  END IF;
-end;
-$$;
--- Modify "complete_task" function
-CREATE OR REPLACE FUNCTION "pgflow"."complete_task" ("run_id" uuid, "step_slug" text, "task_index" integer, "output" jsonb) RETURNS SETOF "pgflow"."step_tasks" LANGUAGE plpgsql SET "search_path" = '' AS $$
-declare
-  v_step_state pgflow.step_states%ROWTYPE;
-  v_dependent_map_slug text;
-begin
-
--- ==========================================
--- VALIDATION: Array output for dependent maps
--- ==========================================
--- Must happen BEFORE acquiring locks to fail fast without holding resources
--- Only validate for single steps - map steps produce scalars that get aggregated
-SELECT child_step.step_slug INTO v_dependent_map_slug
-FROM pgflow.deps dependency
-JOIN pgflow.steps child_step ON child_step.flow_slug = dependency.flow_slug
-                             AND child_step.step_slug = dependency.step_slug
-JOIN pgflow.steps parent_step ON parent_step.flow_slug = dependency.flow_slug
-                              AND parent_step.step_slug = dependency.dep_slug
-JOIN pgflow.step_states child_state ON child_state.flow_slug = child_step.flow_slug
-                                    AND child_state.step_slug = child_step.step_slug
-WHERE dependency.dep_slug = complete_task.step_slug  -- parent is the completing step
-  AND dependency.flow_slug = (SELECT r.flow_slug FROM pgflow.runs r WHERE r.run_id = complete_task.run_id)
-  AND parent_step.step_type = 'single'  -- Only validate single steps
-  AND child_step.step_type = 'map'
-  AND child_state.run_id = complete_task.run_id
-  AND child_state.initial_tasks IS NULL
-  AND (complete_task.output IS NULL OR jsonb_typeof(complete_task.output) != 'array')
-LIMIT 1;
-
-IF v_dependent_map_slug IS NOT NULL THEN
-  RAISE EXCEPTION 'Map step % expects array input but dependency % produced % (output: %)',
-    v_dependent_map_slug,
-    complete_task.step_slug,
-    CASE WHEN complete_task.output IS NULL THEN 'null' ELSE jsonb_typeof(complete_task.output) END,
-    complete_task.output;
-END IF;
-
--- ==========================================
--- MAIN CTE CHAIN: Update task and propagate changes
--- ==========================================
-WITH
--- ---------- Lock acquisition ----------
--- Acquire locks in consistent order (run -> step) to prevent deadlocks
-run_lock AS (
-  SELECT * FROM pgflow.runs
-  WHERE pgflow.runs.run_id = complete_task.run_id
-  FOR UPDATE
-),
-step_lock AS (
-  SELECT * FROM pgflow.step_states
-  WHERE pgflow.step_states.run_id = complete_task.run_id
-    AND pgflow.step_states.step_slug = complete_task.step_slug
-  FOR UPDATE
-),
--- ---------- Task completion ----------
--- Update the task record with completion status and output
-task AS (
-  UPDATE pgflow.step_tasks
-  SET
-    status = 'completed',
-    completed_at = now(),
-    output = complete_task.output
-  WHERE pgflow.step_tasks.run_id = complete_task.run_id
-    AND pgflow.step_tasks.step_slug = complete_task.step_slug
-    AND pgflow.step_tasks.task_index = complete_task.task_index
-    AND pgflow.step_tasks.status = 'started'
-  RETURNING *
-),
--- ---------- Step state update ----------
--- Decrement remaining_tasks and potentially mark step as completed
-step_state AS (
-  UPDATE pgflow.step_states
-  SET
-    status = CASE
-    WHEN pgflow.step_states.remaining_tasks = 1 THEN 'completed'  -- Will be 0 after decrement
-    ELSE 'started'
-    END,
-    completed_at = CASE
-    WHEN pgflow.step_states.remaining_tasks = 1 THEN now()  -- Will be 0 after decrement
-    ELSE NULL
-    END,
-    remaining_tasks = pgflow.step_states.remaining_tasks - 1
-  FROM task
-  WHERE pgflow.step_states.run_id = complete_task.run_id
-    AND pgflow.step_states.step_slug = complete_task.step_slug
-  RETURNING pgflow.step_states.*
-),
--- ---------- Dependency resolution ----------
--- Find all child steps that depend on the completed parent step (only if parent completed)
-child_steps AS (
-  SELECT deps.step_slug AS child_step_slug
-  FROM pgflow.deps deps
-  JOIN step_state parent_state ON parent_state.status = 'completed' AND deps.flow_slug = parent_state.flow_slug
-  WHERE deps.dep_slug = complete_task.step_slug  -- dep_slug is the parent, step_slug is the child
-  ORDER BY deps.step_slug  -- Ensure consistent ordering
-),
--- ---------- Lock child steps ----------
--- Acquire locks on all child steps before updating them
-child_steps_lock AS (
-  SELECT * FROM pgflow.step_states
-  WHERE pgflow.step_states.run_id = complete_task.run_id
-    AND pgflow.step_states.step_slug IN (SELECT child_step_slug FROM child_steps)
-  FOR UPDATE
-),
--- ---------- Update child steps ----------
--- Decrement remaining_deps and resolve NULL initial_tasks for map steps
-child_steps_update AS (
-  UPDATE pgflow.step_states child_state
-  SET remaining_deps = child_state.remaining_deps - 1,
-      -- Resolve NULL initial_tasks for child map steps
-      -- This is where child maps learn their array size from the parent
-      -- This CTE only runs when the parent step is complete (see child_steps JOIN)
-      initial_tasks = CASE
-        WHEN child_step.step_type = 'map' AND child_state.initial_tasks IS NULL THEN
-          CASE
-            WHEN parent_step.step_type = 'map' THEN
-              -- Map->map: Count all completed tasks from parent map
-              -- We add 1 because the current task is being completed in this transaction
-              -- but isn't yet visible as 'completed' in the step_tasks table
-              -- TODO: Refactor to use future column step_states.total_tasks
-              -- Would eliminate the COUNT query and just use parent_state.total_tasks
-              (SELECT COUNT(*)::int + 1
-               FROM pgflow.step_tasks parent_tasks
-               WHERE parent_tasks.run_id = complete_task.run_id
-                 AND parent_tasks.step_slug = complete_task.step_slug
-                 AND parent_tasks.status = 'completed'
-                 AND parent_tasks.task_index != complete_task.task_index)
-            ELSE
-              -- Single->map: Use output array length (single steps complete immediately)
-              CASE
-                WHEN complete_task.output IS NOT NULL
-                     AND jsonb_typeof(complete_task.output) = 'array' THEN
-                  jsonb_array_length(complete_task.output)
-                ELSE NULL  -- Keep NULL if not an array
-              END
-          END
-        ELSE child_state.initial_tasks  -- Keep existing value (including NULL)
-      END
-  FROM child_steps children
-  JOIN pgflow.steps child_step ON child_step.flow_slug = (SELECT r.flow_slug FROM pgflow.runs r WHERE r.run_id = complete_task.run_id)
-                               AND child_step.step_slug = children.child_step_slug
-  JOIN pgflow.steps parent_step ON parent_step.flow_slug = (SELECT r.flow_slug FROM pgflow.runs r WHERE r.run_id = complete_task.run_id)
-                                AND parent_step.step_slug = complete_task.step_slug
-  WHERE child_state.run_id = complete_task.run_id
-    AND child_state.step_slug = children.child_step_slug
-)
--- ---------- Update run remaining_steps ----------
--- Decrement the run's remaining_steps counter if step completed
-UPDATE pgflow.runs
-SET remaining_steps = pgflow.runs.remaining_steps - 1
-FROM step_state
-WHERE pgflow.runs.run_id = complete_task.run_id
-  AND step_state.status = 'completed';
-
--- ==========================================
--- POST-COMPLETION ACTIONS
--- ==========================================
-
--- ---------- Get updated state for broadcasting ----------
-SELECT * INTO v_step_state FROM pgflow.step_states
-WHERE pgflow.step_states.run_id = complete_task.run_id AND pgflow.step_states.step_slug = complete_task.step_slug;
-
--- ---------- Handle step completion ----------
-IF v_step_state.status = 'completed' THEN
-  -- Cascade complete any taskless steps that are now ready
-  PERFORM pgflow.cascade_complete_taskless_steps(complete_task.run_id);
-
-  -- Broadcast step:completed event
-  -- For map steps, aggregate all task outputs; for single steps, use the task output
-  PERFORM realtime.send(
-    jsonb_build_object(
-      'event_type', 'step:completed',
-      'run_id', complete_task.run_id,
-      'step_slug', complete_task.step_slug,
-      'status', 'completed',
-      'output', CASE
-        WHEN (SELECT s.step_type FROM pgflow.steps s
-              WHERE s.flow_slug = v_step_state.flow_slug
-                AND s.step_slug = complete_task.step_slug) = 'map' THEN
-          -- Aggregate all task outputs for map steps
-          (SELECT COALESCE(jsonb_agg(st.output ORDER BY st.task_index), '[]'::jsonb)
-           FROM pgflow.step_tasks st
-           WHERE st.run_id = complete_task.run_id
-             AND st.step_slug = complete_task.step_slug
-             AND st.status = 'completed')
-        ELSE
-          -- Single step: use the individual task output
-          complete_task.output
-      END,
-      'completed_at', v_step_state.completed_at
-    ),
-    concat('step:', complete_task.step_slug, ':completed'),
-    concat('pgflow:run:', complete_task.run_id),
-    false
-  );
-END IF;
-
--- ---------- Archive completed task message ----------
--- Move message from active queue to archive table
-PERFORM (
-  WITH completed_tasks AS (
-    SELECT r.flow_slug, st.message_id
-    FROM pgflow.step_tasks st
-    JOIN pgflow.runs r ON st.run_id = r.run_id
-    WHERE st.run_id = complete_task.run_id
-      AND st.step_slug = complete_task.step_slug
-      AND st.task_index = complete_task.task_index
-      AND st.status = 'completed'
-  )
-  SELECT pgmq.archive(ct.flow_slug, ct.message_id)
-  FROM completed_tasks ct
-  WHERE EXISTS (SELECT 1 FROM completed_tasks)
-);
-
--- ---------- Trigger next steps ----------
--- Start any steps that are now ready (deps satisfied)
-PERFORM pgflow.start_ready_steps(complete_task.run_id);
-
--- Check if the entire run is complete
-PERFORM pgflow.maybe_complete_run(complete_task.run_id);
-
--- ---------- Return completed task ----------
-RETURN QUERY SELECT *
-FROM pgflow.step_tasks AS step_task
-WHERE step_task.run_id = complete_task.run_id
-  AND step_task.step_slug = complete_task.step_slug
-  AND step_task.task_index = complete_task.task_index;
-
-end;
-$$;
--- Modify "start_tasks" function
-CREATE OR REPLACE FUNCTION "pgflow"."start_tasks" ("flow_slug" text, "msg_ids" bigint[], "worker_id" uuid) RETURNS SETOF "pgflow"."step_task_record" LANGUAGE sql SET "search_path" = '' AS $$
-with tasks as (
-    select
-      task.flow_slug,
-      task.run_id,
-      task.step_slug,
-      task.task_index,
-      task.message_id
-    from pgflow.step_tasks as task
-    join pgflow.runs r on r.run_id = task.run_id
-    where task.flow_slug = start_tasks.flow_slug
-      and task.message_id = any(msg_ids)
-      and task.status = 'queued'
-      -- MVP: Don't start tasks on failed runs
-      and r.status != 'failed'
-  ),
-  start_tasks_update as (
-    update pgflow.step_tasks
-    set 
-      attempts_count = attempts_count + 1,
-      status = 'started',
-      started_at = now(),
-      last_worker_id = worker_id
-    from tasks
-    where step_tasks.message_id = tasks.message_id
-      and step_tasks.flow_slug = tasks.flow_slug
-      and step_tasks.status = 'queued'
-  ),
-  runs as (
-    select
-      r.run_id,
-      r.input
-    from pgflow.runs r
-    where r.run_id in (select run_id from tasks)
-  ),
-  deps as (
-    select
-      st.run_id,
-      st.step_slug,
-      dep.dep_slug,
-      -- Aggregate map outputs or use single output
-      CASE
-        WHEN dep_step.step_type = 'map' THEN
-          -- Aggregate all task outputs ordered by task_index
-          -- Use COALESCE to return empty array if no tasks
-          (SELECT COALESCE(jsonb_agg(dt.output ORDER BY dt.task_index), '[]'::jsonb)
-           FROM pgflow.step_tasks dt
-           WHERE dt.run_id = st.run_id
-             AND dt.step_slug = dep.dep_slug
-             AND dt.status = 'completed')
-        ELSE
-          -- Single step: use the single task output
-          dep_task.output
-      END as dep_output
-    from tasks st
-    join pgflow.deps dep on dep.flow_slug = st.flow_slug and dep.step_slug = st.step_slug
-    join pgflow.steps dep_step on dep_step.flow_slug = dep.flow_slug and dep_step.step_slug = dep.dep_slug
-    left join pgflow.step_tasks dep_task on
-      dep_task.run_id = st.run_id and
-      dep_task.step_slug = dep.dep_slug and
-      dep_task.status = 'completed'
-      and dep_step.step_type = 'single'  -- Only join for single steps
-  ),
-  deps_outputs as (
-    select
-      d.run_id,
-      d.step_slug,
-      jsonb_object_agg(d.dep_slug, d.dep_output) as deps_output,
-      count(*) as dep_count
-    from deps d
-    group by d.run_id, d.step_slug
-  ),
-  timeouts as (
-    select
-      task.message_id,
-      task.flow_slug,
-      coalesce(step.opt_timeout, flow.opt_timeout) + 2 as vt_delay
-    from tasks task
-    join pgflow.flows flow on flow.flow_slug = task.flow_slug
-    join pgflow.steps step on step.flow_slug = task.flow_slug and step.step_slug = task.step_slug
-  ),
-  -- Batch update visibility timeouts for all messages
-  set_vt_batch as (
-    select pgflow.set_vt_batch(
-      start_tasks.flow_slug,
-      array_agg(t.message_id order by t.message_id),
-      array_agg(t.vt_delay order by t.message_id)
-    )
-    from timeouts t
-  )
-  select
-    st.flow_slug,
-    st.run_id,
-    st.step_slug,
-    -- ==========================================
-    -- INPUT CONSTRUCTION LOGIC
-    -- ==========================================
-    -- This nested CASE statement determines how to construct the input
-    -- for each task based on the step type (map vs non-map).
-    --
-    -- The fundamental difference:
-    -- - Map steps: Receive RAW array elements (e.g., just 42 or "hello")
-    -- - Non-map steps: Receive structured objects with named keys
-    --                  (e.g., {"run": {...}, "dependency1": {...}})
-    -- ==========================================
-    CASE
-      -- -------------------- MAP STEPS --------------------
-      -- Map steps process arrays element-by-element.
-      -- Each task receives ONE element from the array at its task_index position.
-      WHEN step.step_type = 'map' THEN
-        -- Map steps get raw array elements without any wrapper object
-        CASE
-          -- ROOT MAP: Gets array from run input
-          -- Example: run input = [1, 2, 3]
-          --          task 0 gets: 1
-          --          task 1 gets: 2
-          --          task 2 gets: 3
-          WHEN step.deps_count = 0 THEN
-            -- Root map (deps_count = 0): no dependencies, reads from run input.
-            -- Extract the element at task_index from the run's input array.
-            -- Note: If run input is not an array, this will return NULL
-            -- and the flow will fail (validated in start_flow).
-            jsonb_array_element(r.input, st.task_index)
-
-          -- DEPENDENT MAP: Gets array from its single dependency
-          -- Example: dependency output = ["a", "b", "c"]
-          --          task 0 gets: "a"
-          --          task 1 gets: "b"
-          --          task 2 gets: "c"
-          ELSE
-            -- Has dependencies (should be exactly 1 for map steps).
-            -- Extract the element at task_index from the dependency's output array.
-            --
-            -- Why the subquery with jsonb_each?
-            -- - The dependency outputs a raw array: [1, 2, 3]
-            -- - deps_outputs aggregates it into: {"dep_name": [1, 2, 3]}
-            -- - We need to unwrap and get just the array value
-            -- - Map steps have exactly 1 dependency (enforced by add_step)
-            -- - So jsonb_each will return exactly 1 row
-            -- - We extract the 'value' which is the raw array [1, 2, 3]
-            -- - Then get the element at task_index from that array
-            (SELECT jsonb_array_element(value, st.task_index)
-            FROM jsonb_each(dep_out.deps_output)
-            LIMIT 1)
-        END
-
-      -- -------------------- NON-MAP STEPS --------------------
-      -- Regular (non-map) steps receive ALL inputs as a structured object.
-      -- This includes the original run input plus all dependency outputs.
-      ELSE
-        -- Non-map steps get structured input with named keys
-        -- Example output: {
-        --   "run": {"original": "input"},
-        --   "step1": {"output": "from_step1"},
-        --   "step2": {"output": "from_step2"}
-        -- }
-        --
-        -- Build object with 'run' key containing original input
-        jsonb_build_object('run', r.input) ||
-        -- Merge with deps_output which already has dependency outputs
-        -- deps_output format: {"dep1": output1, "dep2": output2, ...}
-        -- If no dependencies, defaults to empty object
-        coalesce(dep_out.deps_output, '{}'::jsonb)
-    END as input,
-    st.message_id as msg_id
-  from tasks st
-  join runs r on st.run_id = r.run_id
-  join pgflow.steps step on
-    step.flow_slug = st.flow_slug and
-    step.step_slug = st.step_slug
-  left join deps_outputs dep_out on
-    dep_out.run_id = st.run_id and
-    dep_out.step_slug = st.step_slug
-$$;