@pikku/core 0.12.38 → 0.12.40

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'
 

package/src/wirings/workflow/pikku-workflow-service.test.ts

@@ -126,19 +126,19 @@ describe('pikku-workflow-service run-level inline', () => {
 describe('pikku-workflow-service per-function step dispatch', () => {
   // Expose the protected dispatchStep so we can assert the dispatch decision
   // in isolation: a step queues only when its function opts out of inline
-  // execution (inline: false).
+  // execution (workflowQueued: true).
   class TestWorkflowService extends InMemoryWorkflowService {
     public callDispatchStep(rpcName: string) {
       return this.dispatchStep('run-1', 'step-1', rpcName, {})
     }
   }
 
-  const setupFunction = (rpcName: string, inline?: boolean) => {
+  const setupFunction = (rpcName: string, workflowQueued?: boolean) => {
     pikkuState(null, 'rpc', 'meta')[rpcName] = rpcName as any
     pikkuState(null, 'function', 'meta')[rpcName] = {
       pikkuFuncId: rpcName,
       sessionless: true,
-      ...(inline === undefined ? {} : { inline }),
+      ...(workflowQueued === undefined ? {} : { workflowQueued }),
     } as any
   }
 
@@ -166,7 +166,7 @@ describe('pikku-workflow-service per-function step dispatch', () => {
     cleanup('defaultInlineStep')
   })
 
-  test('inline: false step IS dispatched to the queue when a queueService exists', async () => {
+  test('workflowQueued: true step IS dispatched to the queue when a queueService exists', async () => {
     const ws = new TestWorkflowService()
     let queued = false
     pikkuState(null, 'package', 'singletonServices', {
@@ -178,36 +178,25 @@ describe('pikku-workflow-service per-function step dispatch', () => {
       },
     } as any)
 
-    setupFunction('queuedStep', false)
+    setupFunction('queuedStep', true)
     const dispatched = await ws.callDispatchStep('queuedStep')
-    assert.equal(dispatched, true, 'inline:false step should dispatch')
-    assert.equal(queued, true, 'inline:false step should queue')
+    assert.equal(dispatched, true, 'workflowQueued step should dispatch')
+    assert.equal(queued, true, 'workflowQueued step should queue')
     cleanup('queuedStep')
   })
 
-  test('inline: false step warns and runs inline when no queueService is configured', async () => {
+  test('workflowQueued: true step throws when no queueService is configured', async () => {
     const ws = new TestWorkflowService()
-    let warned = false
     pikkuState(null, 'package', 'singletonServices', {
-      logger: {
-        error() {},
-        info() {},
-        warn: () => {
-          warned = true
-        },
-        debug() {},
-      },
+      logger: { error() {}, info() {}, warn() {}, debug() {} },
       // no queueService
     } as any)
 
-    setupFunction('queuedStepNoQueue', false)
-    const dispatched = await ws.callDispatchStep('queuedStepNoQueue')
-    assert.equal(
-      dispatched,
-      false,
-      'falls back to inline when no queue service'
+    setupFunction('queuedStepNoQueue', true)
+    await assert.rejects(
+      () => ws.callDispatchStep('queuedStepNoQueue'),
+      /workflowQueued: true.*no queue service/i
     )
-    assert.equal(warned, true, 'should warn about the misconfiguration')
     cleanup('queuedStepNoQueue')
   })
 })