@pikku/core 0.12.38 → 0.12.39

package/src/wirings/workflow/graph/graph-runner.ts

@@ -565,14 +565,21 @@ export async function continueGraph(
   }
 }
 
-export async function executeGraphStep(
+/**
+ * Invoke a graph node's RPC with the graph + workflow wires, capturing any
+ * branch the node selects and persisting it. Shared by the queued
+ * (executeGraphStep) and inline (executeGraphNodeInline) executors so both build
+ * the wire and record the branch identically — only their child-workflow and
+ * onError handling differs around this call.
+ */
+async function invokeGraphNodeRpc(
   workflowService: PikkuWorkflowService,
   rpcService: any,
   runId: string,
   stepId: string,
   nodeId: string,
   rpcName: string,
-  data: any,
+  input: any,
   graphName: string
 ): Promise<any> {
   const wireState: GraphWireState = {}
@@ -588,6 +595,28 @@ export async function executeGraphStep(
     getState: () => workflowService.getRunState(runId),
   }
 
+  const result = await rpcService.rpcWithWire(rpcName, input, {
+    graph: graphWire,
+    workflow: workflowService.createWorkflowWire(graphName, runId, rpcService),
+  })
+
+  if (wireState.branchKey) {
+    await workflowService.setBranchTaken(stepId, wireState.branchKey)
+  }
+
+  return result
+}
+
+export async function executeGraphStep(
+  workflowService: PikkuWorkflowService,
+  rpcService: any,
+  runId: string,
+  stepId: string,
+  nodeId: string,
+  rpcName: string,
+  data: any,
+  graphName: string
+): Promise<any> {
   try {
     let result: any
 
@@ -622,18 +651,16 @@ export async function executeGraphStep(
         throw new ChildWorkflowStartedException(runId, stepId, childRunId)
       }
     } else {
-      result = await rpcService.rpcWithWire(rpcName, data, {
-        graph: graphWire,
-        workflow: workflowService.createWorkflowWire(
-          graphName,
-          runId,
-          rpcService
-        ),
-      })
-    }
-
-    if (wireState.branchKey) {
-      await workflowService.setBranchTaken(stepId, wireState.branchKey)
+      result = await invokeGraphNodeRpc(
+        workflowService,
+        rpcService,
+        runId,
+        stepId,
+        nodeId,
+        rpcName,
+        data,
+        graphName
+      )
     }
 
     return result
@@ -705,37 +732,30 @@ async function executeGraphNodeInline(
   runId: string,
   graphName: string,
   nodeId: string,
+  instanceKey: string,
   input: any,
-  nodes: Record<string, any>
+  nodes: Record<string, any>,
+  fromStepName?: string
 ): Promise<void> {
   const node = nodes[nodeId]
   if (!node) return
 
   const rpcName = node.rpcName
 
+  // Persist under the physical instance key (node, node#1 … for revisits) and
+  // record the predecessor — same as the queued path (queueGraphNode), so an
+  // inline graph run stores identical step rows + provenance.
   const stepState = await workflowService.insertStepState(
     runId,
-    nodeId,
+    instanceKey,
     rpcName,
     input,
-    { retries: node.retries ?? 0, retryDelay: node.retryDelay }
+    { retries: node.retries ?? 0, retryDelay: node.retryDelay },
+    fromStepName
   )
 
   await workflowService.setStepRunning(stepState.stepId)
 
-  const wireState: GraphWireState = {}
-  const graphWire: PikkuGraphWire = {
-    runId,
-    graphName,
-    nodeId,
-    branch: (key: string) => {
-      wireState.branchKey = key
-    },
-    setState: (name: string, value: unknown) =>
-      workflowService.updateRunState(runId, name, value),
-    getState: () => workflowService.getRunState(runId),
-  }
-
   try {
     let result: any
 
@@ -764,20 +784,15 @@ async function executeGraphNodeInline(
       }
       result = childRun?.output
     } else {
-      result = await rpcService.rpcWithWire(rpcName, input, {
-        graph: graphWire,
-        workflow: workflowService.createWorkflowWire(
-          graphName,
-          runId,
-          rpcService
-        ),
-      })
-    }
-
-    if (wireState.branchKey) {
-      await workflowService.setBranchTaken(
+      result = await invokeGraphNodeRpc(
+        workflowService,
+        rpcService,
+        runId,
         stepState.stepId,
-        wireState.branchKey
+        nodeId,
+        rpcName,
+        input,
+        graphName
       )
     }
 
@@ -811,8 +826,10 @@ async function executeGraphNodeInline(
             runId,
             graphName,
             errorNodeId,
+            errorNodeId,
             { error: { message: (error as Error).message } },
-            nodes
+            nodes,
+            nodeId
           )
         )
       )
@@ -831,20 +848,22 @@ async function continueGraphInline(
   triggerInput: any,
   entryNodeIds: string[]
 ): Promise<void> {
+  // Drive the run to completion in-process using the SAME planner as the queued
+  // path (continueGraph): each loop plans the next wave of transitions, executes
+  // them inline (vs queueGraphNode dispatch), then re-plans. Sharing the planner
+  // gives the inline path joins, cycle revisits and fromStepName provenance
+  // identical to the queue — instead of a second, weaker traversal.
   while (true) {
     const {
-      completedNodeIds: rawCompleted,
       failedNodeIds: rawFailed,
-      branchKeys: rawBranch,
+      branchKeys: branchByStep,
+      completedNodeIds: rawCompleted,
     } = await workflowService.getCompletedGraphState(runId)
-    const completedNodeIds = remapStepNamesToNodeIds(
-      rawCompleted,
-      nodes,
-      graphName
-    )
-    const completedNodeIdSet = new Set(completedNodeIds)
+    // Validate step/branch names map to unambiguous nodes (planning keys
+    // physically; these calls only surface ambiguous template configs).
+    remapStepNamesToNodeIds(rawCompleted, nodes, graphName)
+    remapBranchKeys(branchByStep, nodes, graphName)
     const failedNodeIds = remapStepNamesToNodeIds(rawFailed, nodes, graphName)
-    const branchKeys = remapBranchKeys(rawBranch, nodes, graphName)
 
     if (failedNodeIds.length > 0) {
       const failedNode = failedNodeIds[0]!
@@ -856,46 +875,31 @@ async function continueGraphInline(
       return
     }
 
-    const candidateNodes = new Set<string>()
-
-    for (const nodeId of completedNodeIds) {
-      const node = nodes[nodeId]
-      if (!node?.next) continue
-
-      const nextNodes = resolveNextFromConfig(node.next, branchKeys[nodeId])
-      for (const nextNode of nextNodes) {
-        candidateNodes.add(nextNode)
-      }
-    }
-
-    for (const entryId of entryNodeIds) {
-      candidateNodes.add(entryId)
-    }
-
-    if (candidateNodes.size === 0 && completedNodeIds.length > 0) {
-      await workflowService.updateRunStatus(runId, 'completed')
+    const run = await workflowService.getRun(runId)
+    if (run?.status === 'suspended') {
       return
     }
 
-    const unstartedNodes = await workflowService.getNodesWithoutSteps(runId, [
-      ...candidateNodes,
-    ])
-
-    const nodesToExecute = unstartedNodes.filter((nodeId) => {
-      const node = nodes[nodeId]
-      return node && areDependenciesSatisfied(node, completedNodeIdSet)
-    })
+    const instances = await workflowService.getStepInstances(runId)
+    const plan = planGraphTransitions(
+      nodes,
+      instances,
+      branchByStep,
+      entryNodeIds,
+      graphName
+    )
 
-    if (nodesToExecute.length === 0) {
-      if (completedNodeIds.length > 0 && unstartedNodes.length === 0) {
+    if (plan.toFire.length === 0) {
+      if (!plan.hasInFlight && !plan.blockedWaiting) {
         await workflowService.updateRunStatus(runId, 'completed')
       }
       return
     }
 
+    let executed = 0
     await Promise.all(
-      nodesToExecute.map(async (nodeId) => {
-        const node = nodes[nodeId]
+      plan.toFire.map(async (fire) => {
+        const node = nodes[fire.logical]
         if (!node?.rpcName) return
 
         const referencedNodeIds = extractReferencedNodeIds(node.input).filter(
@@ -905,21 +909,25 @@ async function continueGraphInline(
           runId,
           referencedNodeIds
         )
-
         const nodeResults = { trigger: triggerInput, ...fetchedResults }
         const resolvedInput = resolveSerializedInput(node.input, nodeResults)
 
+        executed++
         await executeGraphNodeInline(
           workflowService,
           rpcService,
           runId,
           graphName,
-          nodeId,
+          fire.logical,
+          fire.instanceKey,
           resolvedInput,
-          nodes
+          nodes,
+          fire.fromStepName
         )
       })
     )
+    // Nothing executable fired (e.g. nodes without an rpcName) → can't progress.
+    if (executed === 0) return
   }
 }
 
@@ -1002,6 +1010,7 @@ export async function runWorkflowGraph(
               runId,
               graphName,
               nodeId,
+              nodeId,
               resolvedInput,
               nodes
             )

package/src/wirings/workflow/index.ts

@@ -12,6 +12,20 @@ export {
 } from './pikku-workflow-service.js'
 export { deriveInvocationId, uuidv5 } from './workflow-invocation-id.js'
 
+// Time-travel: reconstruct run state at any point from durable history
+export {
+  buildRunTimeline,
+  reconstructStateAt,
+  reconstructFinalState,
+} from './run-timeline.js'
+export type {
+  RunTimeline,
+  RunTimelineEvent,
+  ReconstructedRunState,
+  ReconstructedStep,
+  RunPhase,
+} from './run-timeline.js'
+
 // Internal registration functions (used by generated code)
 export { addWorkflow } from './dsl/workflow-runner.js'