@codemation/core 0.0.18 → 0.2.0

package/src/orchestration/RunContinuationService.ts

@@ -5,6 +5,8 @@ import type {
   NodeId,
   NodeInputsByPort,
   NodeOutputs,
+  PendingNodeExecution,
+  PersistedRunSchedulingState,
   PersistedRunState,
   RunDataFactory,
   RunId,
@@ -31,7 +33,6 @@ import { NodeEventPublisher } from "../events/NodeEventPublisher";
 
 import { ActivationEnqueueService } from "../execution/ActivationEnqueueService";
 import { NodeExecutionSnapshotFactory } from "../execution/NodeExecutionSnapshotFactory";
-import { NodeInputsByPortFactory } from "../execution/NodeInputsByPortFactory";
 import { NodeRunStateWriterFactory } from "../execution/NodeRunStateWriterFactory";
 import { NodeActivationRequestComposer } from "../execution/NodeActivationRequestComposer";
 import { PersistedRunStateTerminalBuilder } from "../execution/PersistedRunStateTerminalBuilder";
@@ -65,9 +66,13 @@ export class RunContinuationService {
     nodeId: NodeId;
     inputsByPort: NodeInputsByPort;
   }): Promise<void> {
-    const state = await this.workflowExecutionRepository.load(args.runId);
-    if (!state?.pending) return;
-    if (state.pending.activationId !== args.activationId || state.pending.nodeId !== args.nodeId) return;
+    const [state, schedulingState] = await Promise.all([
+      this.workflowExecutionRepository.load(args.runId),
+      this.workflowExecutionRepository.loadSchedulingState(args.runId),
+    ]);
+    const pendingExecution = schedulingState?.pending;
+    if (!state || !pendingExecution) return;
+    if (pendingExecution.activationId !== args.activationId || pendingExecution.nodeId !== args.nodeId) return;
 
     const startedAt = new Date().toISOString();
     const previous = state.nodeSnapshotsByNodeId?.[args.nodeId];
@@ -98,12 +103,21 @@ export class RunContinuationService {
     nodeId: NodeId;
     outputs: NodeOutputs;
   }): Promise<RunResult> {
-    const state = await this.workflowExecutionRepository.load(args.runId);
+    const [state, schedulingState] = await Promise.all([
+      this.workflowExecutionRepository.load(args.runId),
+      this.workflowExecutionRepository.loadSchedulingState(args.runId),
+    ]);
     if (!state) throw new Error(`Unknown runId: ${args.runId}`);
-    if (state.status !== "pending" || !state.pending) throw new Error(`Run ${args.runId} is not pending`);
-    if (state.pending.activationId !== args.activationId)
+    const pendingExecution = this.requirePendingExecution(
+      args.runId,
+      args.activationId,
+      args.nodeId,
+      state,
+      schedulingState,
+    );
+    if (pendingExecution.activationId !== args.activationId)
       throw new Error(`activationId mismatch for run ${args.runId}`);
-    if (state.pending.nodeId !== args.nodeId) throw new Error(`nodeId mismatch for run ${args.runId}`);
+    if (pendingExecution.nodeId !== args.nodeId) throw new Error(`nodeId mismatch for run ${args.runId}`);
 
     const wf = this.resolvePersistedWorkflow(state);
     if (!wf) throw new Error(`Unknown workflowId: ${state.workflowId}`);
@@ -135,7 +149,7 @@ export class RunContinuationService {
       activationId: args.activationId,
       parent: state.parent,
       finishedAt: completedAt,
-      inputsByPort: state.pending.inputsByPort,
+      inputsByPort: pendingExecution.inputsByPort,
       outputs: args.outputs,
     });
 
@@ -154,6 +168,7 @@ export class RunContinuationService {
           ...(state.nodeSnapshotsByNodeId ?? {}),
           [args.nodeId]: completedSnapshot,
         },
+        finishedAtIso: completedAt,
       });
       await this.workflowExecutionRepository.save(completedState);
       await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
@@ -174,8 +189,8 @@ export class RunContinuationService {
       return result;
     }
 
-    const batchId = state.pending.batchId ?? "batch_1";
-    const queue: RunQueueEntry[] = (state.queue ?? []).map((q) => ({ ...q, batchId: q.batchId ?? batchId }));
+    const batchId = pendingExecution.batchId ?? "batch_1";
+    const queue: RunQueueEntry[] = (schedulingState?.queue ?? []).map((q) => ({ ...q, batchId: q.batchId ?? batchId }));
     const nextNodeSnapshotsByNodeId = {
       ...(state.nodeSnapshotsByNodeId ?? {}),
       [args.nodeId]: completedSnapshot,
@@ -220,6 +235,7 @@ export class RunContinuationService {
         queue: [],
         outputsByNode: data.dump(),
         nodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId,
+        finishedAtIso: completedAt,
       });
       await this.workflowExecutionRepository.save(completedState);
       await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
@@ -250,6 +266,7 @@ export class RunContinuationService {
         queue: queue.map((q) => ({ ...q })),
         outputsByNode: data.dump(),
         nodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId,
+        finishedAtIso: completedAt,
       });
       await this.workflowExecutionRepository.save(failedState);
       await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
@@ -312,12 +329,21 @@ export class RunContinuationService {
     nodeId: NodeId;
     error: Error;
   }): Promise<RunResult> {
-    const state = await this.workflowExecutionRepository.load(args.runId);
+    const [state, schedulingState] = await Promise.all([
+      this.workflowExecutionRepository.load(args.runId),
+      this.workflowExecutionRepository.loadSchedulingState(args.runId),
+    ]);
     if (!state) throw new Error(`Unknown runId: ${args.runId}`);
-    if (state.status !== "pending" || !state.pending) throw new Error(`Run ${args.runId} is not pending`);
-    if (state.pending.activationId !== args.activationId)
+    const pendingExecution = this.requirePendingExecution(
+      args.runId,
+      args.activationId,
+      args.nodeId,
+      state,
+      schedulingState,
+    );
+    if (pendingExecution.activationId !== args.activationId)
       throw new Error(`activationId mismatch for run ${args.runId}`);
-    if (state.pending.nodeId !== args.nodeId) throw new Error(`nodeId mismatch for run ${args.runId}`);
+    if (pendingExecution.nodeId !== args.nodeId) throw new Error(`nodeId mismatch for run ${args.runId}`);
 
     const wf = this.resolvePersistedWorkflow(state);
     if (!wf) throw new Error(`Unknown workflowId: ${state.workflowId}`);
@@ -327,15 +353,28 @@ export class RunContinuationService {
         ? this.asWebhookControlSignal(args.error)
         : undefined;
     if (webhookControlSignal) {
-      return await this.resumeFromWebhookControl({ state, workflow: wf, args, signal: webhookControlSignal });
+      return await this.resumeFromWebhookControl({
+        state,
+        schedulingState,
+        pendingExecution,
+        workflow: wf,
+        args,
+        signal: webhookControlSignal,
+      });
     }
 
     if (failedDefinition && failedDefinition.kind === "node") {
       const nodeHandler = this.policyErrorServices.resolveNodeErrorHandler(failedDefinition.config.nodeErrorHandler);
       if (nodeHandler) {
         try {
-          const ctx = this.buildNodeExecutionContextForPending(state, wf, failedDefinition, args.nodeId);
-          const inputsByPort = state.pending.inputsByPort;
+          const ctx = this.buildNodeExecutionContextForPending(
+            state,
+            pendingExecution,
+            wf,
+            failedDefinition,
+            args.nodeId,
+          );
+          const inputsByPort = pendingExecution.inputsByPort;
           const portKeys = Object.keys(inputsByPort);
           const kind = portKeys.length === 1 && portKeys[0] === "in" ? ("single" as const) : ("multi" as const);
           const items = inputsByPort.in ?? [];
@@ -368,19 +407,20 @@ export class RunContinuationService {
       activationId: args.activationId,
       parent: state.parent,
       finishedAt,
-      inputsByPort: state.pending.inputsByPort,
+      inputsByPort: pendingExecution.inputsByPort,
       error: args.error,
     });
     const failedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
       state,
       engineCounters: state.engineCounters ?? { completedNodeActivations: 0 },
       status: "failed",
-      queue: (state.queue ?? []).map((q) => ({ ...q })),
+      queue: (schedulingState?.queue ?? []).map((q) => ({ ...q })),
       outputsByNode: state.outputsByNode,
       nodeSnapshotsByNodeId: {
         ...(state.nodeSnapshotsByNodeId ?? {}),
         [args.nodeId]: failedSnapshot,
       },
+      finishedAtIso: finishedAt,
     });
     await this.workflowExecutionRepository.save(failedState);
     await this.nodeEventPublisher.publish("nodeFailed", failedSnapshot);
@@ -474,6 +514,8 @@ export class RunContinuationService {
 
   private async resumeFromWebhookControl(args: {
     state: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>;
+    schedulingState: PersistedRunSchedulingState | undefined;
+    pendingExecution: PendingNodeExecution;
     workflow: WorkflowDefinition;
     args: { runId: RunId; activationId: NodeActivationId; nodeId: NodeId; error: Error };
     signal: WebhookControlSignal;
@@ -495,7 +537,7 @@ export class RunContinuationService {
       activationId: args.args.activationId,
       parent: args.state.parent,
       finishedAt: new Date().toISOString(),
-      inputsByPort: args.state.pending?.inputsByPort ?? NodeInputsByPortFactory.empty(),
+      inputsByPort: args.pendingExecution.inputsByPort,
       outputs: triggerOutputs,
     });
 
@@ -514,6 +556,7 @@ export class RunContinuationService {
           ...(args.state.nodeSnapshotsByNodeId ?? {}),
           [args.args.nodeId]: completedSnapshot,
         },
+        finishedAtIso: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt,
       });
       await this.workflowExecutionRepository.save(completedState);
       await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
@@ -552,6 +595,7 @@ export class RunContinuationService {
           ...(args.state.nodeSnapshotsByNodeId ?? {}),
           [args.args.nodeId]: completedSnapshot,
         },
+        finishedAtIso: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt,
       });
       await this.workflowExecutionRepository.save(completedState);
       await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
@@ -580,8 +624,8 @@ export class RunContinuationService {
       return result;
     }
 
-    const batchId = args.state.pending?.batchId ?? "batch_1";
-    const queue: RunQueueEntry[] = (args.state.queue ?? []).map((entry) => ({
+    const batchId = args.pendingExecution.batchId ?? "batch_1";
+    const queue: RunQueueEntry[] = (args.schedulingState?.queue ?? []).map((entry) => ({
       ...entry,
       batchId: entry.batchId ?? batchId,
     }));
@@ -603,6 +647,7 @@ export class RunContinuationService {
           ...(args.state.nodeSnapshotsByNodeId ?? {}),
           [args.args.nodeId]: completedSnapshot,
         },
+        finishedAtIso: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt,
       });
       await this.workflowExecutionRepository.save(completedState);
       await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
@@ -643,6 +688,7 @@ export class RunContinuationService {
           ...(args.state.nodeSnapshotsByNodeId ?? {}),
           [args.args.nodeId]: completedSnapshot,
         },
+        finishedAtIso: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt,
       });
       await this.workflowExecutionRepository.save(failedState);
       await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
@@ -750,6 +796,7 @@ export class RunContinuationService {
 
   private buildNodeExecutionContextForPending(
     state: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>,
+    pendingExecution: PendingNodeExecution,
     wf: WorkflowDefinition,
     def: Readonly<{ id: NodeId; config: NodeExecutionContext["config"] }>,
     nodeId: NodeId,
@@ -767,7 +814,7 @@ export class RunContinuationService {
       data,
       nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, state.parent),
     });
-    const activationId = state.pending!.activationId;
+    const activationId = pendingExecution.activationId;
     return {
       ...base,
       data,
@@ -779,6 +826,29 @@ export class RunContinuationService {
     };
   }
 
+  private requirePendingExecution(
+    runId: RunId,
+    activationId: NodeActivationId,
+    nodeId: NodeId,
+    state: PersistedRunState,
+    schedulingState?: PersistedRunSchedulingState,
+  ): PendingNodeExecution {
+    if (state.status !== "pending") {
+      throw new Error(`Run ${runId} is not pending`);
+    }
+    const pendingExecution = schedulingState?.pending;
+    if (!pendingExecution) {
+      throw new Error(`Run ${runId} is not pending`);
+    }
+    if (pendingExecution.activationId !== activationId) {
+      throw new Error(`activationId mismatch for run ${runId}`);
+    }
+    if (pendingExecution.nodeId !== nodeId) {
+      throw new Error(`nodeId mismatch for run ${runId}`);
+    }
+    return pendingExecution;
+  }
+
   private resolveEngineLimitsFromState(state: PersistedRunState): {
     engineMaxNodeActivations: number;
     engineMaxSubworkflowDepth: number;

package/src/planning/CurrentStateFrontierPlanner.ts

@@ -303,7 +303,17 @@ export class CurrentStateFrontierPlanner {
     if (!incomingEdge) {
       return false;
     }
-    return this.hasOutputPort(currentState, incomingEdge.from.nodeId, incomingEdge.from.output);
+    if (!this.hasOutputPort(currentState, incomingEdge.from.nodeId, incomingEdge.from.output)) {
+      return false;
+    }
+    if (this.usesCollect(nodeId)) {
+      return true;
+    }
+    const items = this.resolveOutputItems(currentState, incomingEdge.from.nodeId, incomingEdge.from.output);
+    if (items.length > 0) {
+      return true;
+    }
+    return this.shouldContinueAfterEmptyOutputFromSource(incomingEdge.from.nodeId);
   }
 
   private resolveInput(currentState: RunCurrentState, nodeId: NodeId, input: InputPortKey): Items {
@@ -335,6 +345,19 @@ export class CurrentStateFrontierPlanner {
     return currentState.outputsByNode[nodeId]?.[output] ?? [];
   }
 
+  private usesCollect(nodeId: NodeId): boolean {
+    const expectedInputs = this.topology.expectedInputsByNode.get(nodeId) ?? [];
+    return expectedInputs.length !== 1 || expectedInputs[0] !== "in";
+  }
+
+  private shouldContinueAfterEmptyOutputFromSource(nodeId: NodeId): boolean {
+    const definition = this.topology.defsById.get(nodeId);
+    if (!definition) {
+      return false;
+    }
+    return definition.config.continueWhenEmptyOutput === true;
+  }
+
   private getPinnedOutputs(currentState: RunCurrentState, nodeId: NodeId): NodeOutputs | undefined {
     return currentState.mutableState?.nodesById?.[nodeId]?.pinnedOutputsByPort;
   }

package/src/runStorage/InMemoryWorkflowExecutionRepository.ts

@@ -3,6 +3,7 @@ import type {
   NodeId,
   NodeOutputs,
   ParentExecutionRef,
+  PersistedRunSchedulingState,
   PersistedRunState,
   RunId,
   RunSummary,
@@ -36,6 +37,7 @@ export class InMemoryWorkflowExecutionRepository
       runId: args.runId,
       workflowId: args.workflowId,
       startedAt: args.startedAt,
+      revision: 0,
       parent: args.parent,
       executionOptions: args.executionOptions,
       control: args.control,
@@ -55,8 +57,19 @@ export class InMemoryWorkflowExecutionRepository
     return this.runs.get(runId);
   }
 
+  async loadSchedulingState(runId: RunId): Promise<PersistedRunSchedulingState | undefined> {
+    const state = this.runs.get(runId);
+    if (!state) {
+      return undefined;
+    }
+    return {
+      pending: state.pending ? { ...state.pending } : undefined,
+      queue: state.queue.map((entry) => ({ ...entry })),
+    };
+  }
+
   async save(state: PersistedRunState): Promise<void> {
-    this.runs.set(state.runId, state);
+    this.runs.set(state.runId, { ...state, revision: (state.revision ?? 0) + 1 });
   }
 
   async deleteRun(runId: RunId): Promise<void> {

package/src/runtime/RunIntentService.ts

@@ -20,6 +20,7 @@ export type StartWorkflowIntent = {
   workflow: WorkflowDefinition;
   startAt?: string;
   items: Items;
+  synthesizeTriggerItems?: boolean;
   parent?: CurrentStateExecutionRequest["parent"];
   executionOptions?: RunExecutionOptions;
   workflowSnapshot?: CurrentStateExecutionRequest["workflowSnapshot"];
@@ -34,6 +35,7 @@ export type RerunFromNodeIntent = {
   nodeId: NodeId;
   currentState: RunCurrentState;
   items?: Items;
+  synthesizeTriggerItems?: boolean;
   parent?: CurrentStateExecutionRequest["parent"];
   executionOptions?: RunExecutionOptions;
   workflowSnapshot?: CurrentStateExecutionRequest["workflowSnapshot"];
@@ -58,22 +60,16 @@ export class RunIntentService {
   ) {}
 
   async startWorkflow(args: StartWorkflowIntent): Promise<RunResult> {
+    const items = await this.resolveStartWorkflowItems(args);
     if (args.startAt && !args.currentState && !args.stopCondition && !args.reset) {
-      return await this.engine.runWorkflow(
-        args.workflow,
-        args.startAt,
-        args.items,
-        args.parent,
-        args.executionOptions,
-        {
-          workflowSnapshot: args.workflowSnapshot,
-          mutableState: args.mutableState,
-        },
-      );
+      return await this.engine.runWorkflow(args.workflow, args.startAt, items, args.parent, args.executionOptions, {
+        workflowSnapshot: args.workflowSnapshot,
+        mutableState: args.mutableState,
+      });
     }
     return await this.engine.runWorkflowFromState({
       workflow: args.workflow,
-      items: args.items,
+      items,
       parent: args.parent,
       executionOptions: args.executionOptions,
       workflowSnapshot: args.workflowSnapshot,
@@ -85,8 +81,9 @@ export class RunIntentService {
   }
 
   async rerunFromNode(args: RerunFromNodeIntent): Promise<RunResult> {
-    if (args.items) {
-      return await this.engine.runWorkflow(args.workflow, args.nodeId, args.items, args.parent, args.executionOptions, {
+    const items = await this.resolveRerunItems(args);
+    if (items) {
+      return await this.engine.runWorkflow(args.workflow, args.nodeId, items, args.parent, args.executionOptions, {
         workflowSnapshot: args.workflowSnapshot,
         mutableState: args.mutableState,
       });
@@ -103,6 +100,63 @@ export class RunIntentService {
     });
   }
 
+  private async resolveStartWorkflowItems(args: StartWorkflowIntent): Promise<Items> {
+    if (this.hasNonEmptyItems(args.items)) {
+      return args.items;
+    }
+    const triggerNodeId = this.resolveStartWorkflowTriggerNodeId(args);
+    if (!triggerNodeId) {
+      return args.items;
+    }
+    return (await this.engine.createTriggerTestItems({ workflow: args.workflow, nodeId: triggerNodeId })) ?? args.items;
+  }
+
+  private async resolveRerunItems(args: RerunFromNodeIntent): Promise<Items | undefined> {
+    if (this.hasNonEmptyItems(args.items)) {
+      return args.items;
+    }
+    const triggerNodeId = this.resolveRerunTriggerNodeId(args);
+    if (!triggerNodeId) {
+      return args.items;
+    }
+    return (await this.engine.createTriggerTestItems({ workflow: args.workflow, nodeId: triggerNodeId })) ?? args.items;
+  }
+
+  private resolveStartWorkflowTriggerNodeId(args: StartWorkflowIntent): NodeId | undefined {
+    if (args.stopCondition?.kind === "nodeCompleted" && this.isTriggerNode(args.workflow, args.stopCondition.nodeId)) {
+      return args.stopCondition.nodeId;
+    }
+    if (!args.synthesizeTriggerItems) {
+      return undefined;
+    }
+    if (args.startAt && this.isTriggerNode(args.workflow, args.startAt)) {
+      return args.startAt;
+    }
+    return this.firstTriggerNodeId(args.workflow);
+  }
+
+  private resolveRerunTriggerNodeId(args: RerunFromNodeIntent): NodeId | undefined {
+    if (this.isTriggerNode(args.workflow, args.nodeId)) {
+      return args.nodeId;
+    }
+    if (!args.synthesizeTriggerItems) {
+      return undefined;
+    }
+    return this.firstTriggerNodeId(args.workflow);
+  }
+
+  private firstTriggerNodeId(workflow: WorkflowDefinition): NodeId | undefined {
+    return workflow.nodes.find((node) => node.kind === "trigger")?.id;
+  }
+
+  private isTriggerNode(workflow: WorkflowDefinition, nodeId: string): boolean {
+    return workflow.nodes.find((node) => node.id === nodeId)?.kind === "trigger";
+  }
+
+  private hasNonEmptyItems(items: Items | undefined): boolean {
+    return (items?.length ?? 0) > 0;
+  }
+
   resolveWebhookTrigger(args: { endpointPath: string; method: HttpMethod }): WebhookTriggerResolution {
     return this.engine.resolveWebhookTrigger(args);
   }

package/src/scheduler/DefaultDrivingScheduler.ts

@@ -1,5 +1,6 @@
 import type {
   NodeActivationContinuation,
+  PreparedNodeActivationDispatch,
   NodeActivationReceipt,
   NodeActivationRequest,
   NodeActivationScheduler,
@@ -26,7 +27,7 @@ export class DefaultDrivingScheduler implements NodeActivationScheduler {
     this.inline.setContinuation(continuation);
   }
 
-  async enqueue(request: NodeActivationRequest): Promise<NodeActivationReceipt> {
+  async prepareDispatch(request: NodeActivationRequest): Promise<PreparedNodeActivationDispatch> {
     const selection = await this.selectScheduler(request);
     if (selection.mode === "worker") {
       if (request.kind === "multi") {
@@ -44,15 +45,19 @@ export class DefaultDrivingScheduler implements NodeActivationScheduler {
         executionOptions: request.executionOptions,
       };
 
-      const receipt = await this.workerScheduler.enqueue(workerRequest);
-      return { receiptId: receipt.receiptId, mode: "worker", queue: selection.queue };
+      return {
+        receipt: {
+          receiptId: request.activationId,
+          mode: "worker",
+          queue: selection.queue,
+        },
+        dispatch: async () => {
+          await this.workerScheduler.enqueue(workerRequest);
+        },
+      };
     }
 
-    return await this.enqueueInline(request);
-  }
-
-  notifyPendingStatePersisted(runId: string): void {
-    this.inline.notifyPendingStatePersisted(runId);
+    return await this.prepareInlineDispatch(request);
   }
 
   /**
@@ -93,8 +98,13 @@ export class DefaultDrivingScheduler implements NodeActivationScheduler {
     return request.ctx.config.execution?.hint !== undefined || request.ctx.config.execution?.queue !== undefined;
   }
 
-  private async enqueueInline(request: NodeActivationRequest): Promise<NodeActivationReceipt> {
-    const receipt = await this.inline.enqueue(request);
-    return { ...receipt, mode: "local" };
+  private async prepareInlineDispatch(request: NodeActivationRequest): Promise<PreparedNodeActivationDispatch> {
+    const prepared = await this.inline.prepareDispatch(request);
+    return {
+      receipt: { ...prepared.receipt, mode: "local" },
+      dispatch: async () => {
+        await prepared.dispatch();
+      },
+    };
   }
 }

package/src/scheduler/InlineDrivingScheduler.ts

@@ -1,21 +1,20 @@
 import type {
   NodeActivationContinuation,
+  PreparedNodeActivationDispatch,
   NodeActivationReceipt,
   NodeActivationRequest,
   NodeActivationScheduler,
-  RunId,
 } from "../types";
 import { NodeExecutor } from "../execution/NodeExecutor";
 
 export class InlineDrivingScheduler implements NodeActivationScheduler {
   private continuation: NodeActivationContinuation | undefined;
-  private readonly drainingRuns = new Set<RunId>();
+  private readonly drainingRuns = new Set<string>();
   private readonly queuesByRunId = new Map<
-    RunId,
+    string,
     Array<Readonly<{ request: NodeActivationRequest; receipt: NodeActivationReceipt }>>
   >();
-  private readonly scheduledRuns = new Set<RunId>();
-  private seq = 0;
+  private readonly scheduledRuns = new Set<string>();
 
   constructor(private readonly nodeExecutor: NodeExecutor) {}
 
@@ -23,23 +22,20 @@ export class InlineDrivingScheduler implements NodeActivationScheduler {
     this.continuation = continuation;
   }
 
-  async enqueue(request: NodeActivationRequest): Promise<NodeActivationReceipt> {
-    const receipt: NodeActivationReceipt = { receiptId: `inline_${++this.seq}`, mode: "local" };
-    const q = this.queuesByRunId.get(request.runId) ?? [];
-    q.push({ request, receipt });
-    this.queuesByRunId.set(request.runId, q);
-
-    return receipt;
-  }
-
-  notifyPendingStatePersisted(runId: RunId): void {
-    if ((this.queuesByRunId.get(runId)?.length ?? 0) === 0) {
-      return;
-    }
-    this.scheduleDrain(runId);
+  async prepareDispatch(request: NodeActivationRequest): Promise<PreparedNodeActivationDispatch> {
+    const receipt: NodeActivationReceipt = { receiptId: request.activationId, mode: "local" };
+    return {
+      receipt,
+      dispatch: async () => {
+        const queue = this.queuesByRunId.get(request.runId) ?? [];
+        queue.push({ request, receipt });
+        this.queuesByRunId.set(request.runId, queue);
+        this.scheduleDrain(request.runId);
+      },
+    };
   }
 
-  private async drainRun(runId: RunId): Promise<void> {
+  private async drainRun(runId: string): Promise<void> {
     if (this.drainingRuns.has(runId)) return;
     this.drainingRuns.add(runId);
     this.scheduledRuns.delete(runId);
@@ -78,7 +74,7 @@ export class InlineDrivingScheduler implements NodeActivationScheduler {
     }
   }
 
-  private scheduleDrain(runId: RunId): void {
+  private scheduleDrain(runId: string): void {
     if (this.drainingRuns.has(runId) || this.scheduledRuns.has(runId)) {
       return;
     }

package/src/testing/CapturingScheduler.ts

@@ -0,0 +1,15 @@
+import type { NodeExecutionRequest, NodeExecutionScheduler } from "../types";
+
+/**
+ * Test scheduler that records enqueue requests without executing a real queue.
+ */
+export class CapturingScheduler implements NodeExecutionScheduler {
+  lastRequest: NodeExecutionRequest | undefined;
+  requests: NodeExecutionRequest[] = [];
+
+  async enqueue(request: NodeExecutionRequest): Promise<{ receiptId: string }> {
+    this.lastRequest = request;
+    this.requests.push(request);
+    return { receiptId: `receipt_${this.requests.length}` };
+  }
+}

package/src/testing/EngineTestKitRunIdFactory.ts

@@ -0,0 +1,24 @@
+import type { RunIdFactory } from "../types";
+
+/**
+ * @internal Test harness id factory shared by registrar kit wiring.
+ */
+export class EngineTestKitRunIdFactory implements RunIdFactory {
+  private runCounter = 0;
+  private activationCounter = 0;
+
+  constructor(
+    private readonly makeRunIdValue: () => string,
+    private readonly makeActivationIdValue: () => string,
+  ) {}
+
+  makeRunId(): string {
+    this.runCounter += 1;
+    return this.makeRunIdValue();
+  }
+
+  makeActivationId(): string {
+    this.activationCounter += 1;
+    return this.makeActivationIdValue();
+  }
+}

package/src/testing/InMemoryTriggerSetupStateRepository.ts

@@ -0,0 +1,21 @@
+import type { PersistedTriggerSetupState, TriggerSetupStateRepository } from "../types";
+
+export class InMemoryTriggerSetupStateRepository implements TriggerSetupStateRepository {
+  private readonly statesByKey = new Map<string, PersistedTriggerSetupState>();
+
+  async load(trigger: { workflowId: string; nodeId: string }): Promise<PersistedTriggerSetupState | undefined> {
+    return this.statesByKey.get(this.toKey(trigger));
+  }
+
+  async save(state: PersistedTriggerSetupState): Promise<void> {
+    this.statesByKey.set(this.toKey(state.trigger), state);
+  }
+
+  async delete(trigger: { workflowId: string; nodeId: string }): Promise<void> {
+    this.statesByKey.delete(this.toKey(trigger));
+  }
+
+  private toKey(trigger: { workflowId: string; nodeId: string }): string {
+    return `${trigger.workflowId}:${trigger.nodeId}`;
+  }
+}