@codemation/core 0.2.0 → 0.2.3

package/src/execution/ActivationEnqueueService.ts

@@ -21,6 +21,7 @@ import type {
 import { RunQueuePlanner } from "../planning/RunQueuePlanner";
 
 import { NodeEventPublisher } from "../events/NodeEventPublisher";
+import type { NodeActivationRequestInputPreparer } from "./NodeActivationRequestInputPreparer";
 import { NodeExecutionSnapshotFactory } from "./NodeExecutionSnapshotFactory";
 import { NodeInputsByPortFactory } from "./NodeInputsByPortFactory";
 
@@ -51,6 +52,7 @@ export class ActivationEnqueueService {
     private readonly activationScheduler: ActivationSchedulerPort,
     private readonly workflowExecutionRepository: WorkflowExecutionRepository,
     private readonly nodeEventPublisher: NodeEventPublisher,
+    private readonly nodeActivationRequestInputPreparer: NodeActivationRequestInputPreparer,
   ) {}
 
   async enqueueActivation(args: ActivationEnqueueRequest): Promise<RunResult> {
@@ -62,12 +64,13 @@ export class ActivationEnqueueService {
   async enqueueActivationWithSnapshot(
     args: ActivationEnqueueRequest,
   ): Promise<{ result: RunResult; queuedSnapshot: NodeExecutionSnapshot }> {
-    const preparedDispatch = await this.activationScheduler.prepareDispatch(args.request);
-    const inputsByPort = NodeInputsByPortFactory.fromRequest(args.request);
+    const preparedRequest = await this.nodeActivationRequestInputPreparer.prepare(args.request);
+    const preparedDispatch = await this.activationScheduler.prepareDispatch(preparedRequest);
+    const inputsByPort = NodeInputsByPortFactory.fromRequest(preparedRequest);
     const itemsIn =
-      args.request.kind === "multi"
-        ? args.planner.sumItemsByPort(args.request.inputsByPort)
-        : args.request.input.length;
+      preparedRequest.kind === "multi"
+        ? args.planner.sumItemsByPort(preparedRequest.inputsByPort)
+        : preparedRequest.input.length;
     const enqueuedAt = new Date().toISOString();
     const pending: PendingNodeExecution = {
       runId: args.runId,

package/src/execution/NodeActivationRequestInputPreparer.ts

@@ -0,0 +1,89 @@
+import { z, ZodError } from "zod";
+
+import type { Item, NodeActivationRequest, RunnableNodeConfig, WorkflowNodeInstanceFactory } from "../types";
+
+import { NodeInputContractError } from "./NodeInputContractError";
+
+/**
+ * Maps and validates per-item inputs for {@link ItemNode} before enqueue persistence.
+ */
+export class NodeActivationRequestInputPreparer {
+  constructor(private readonly workflowNodeInstanceFactory: WorkflowNodeInstanceFactory) {}
+
+  async prepare(request: NodeActivationRequest): Promise<NodeActivationRequest> {
+    if (request.kind !== "single") {
+      return request;
+    }
+    const nodeInstance: unknown = this.workflowNodeInstanceFactory.createByType(request.ctx.config.type);
+    if (!this.hasExecuteOne(nodeInstance)) {
+      return request;
+    }
+    const inputSchema = this.resolveInputSchema(nodeInstance, request.ctx.config as RunnableNodeConfig);
+    const config = request.ctx.config as RunnableNodeConfig;
+    const mappedItems: Item[] = [];
+    for (let i = 0; i < request.input.length; i++) {
+      const item = request.input[i] as Item;
+      try {
+        const mappedRaw = config.mapInput
+          ? await Promise.resolve(
+              config.mapInput({
+                item,
+                itemIndex: i,
+                items: request.input,
+                ctx: request.ctx,
+              }),
+            )
+          : item.json;
+        const parsed = inputSchema.parse(mappedRaw);
+        mappedItems.push({ ...item, json: parsed });
+      } catch (cause) {
+        const message = this.formatContractFailure(cause);
+        throw new NodeInputContractError(
+          `Node ${request.nodeId} activation ${request.activationId}: input contract failed: ${message}`,
+          request.nodeId,
+          request.activationId,
+          cause,
+        );
+      }
+    }
+    return {
+      ...request,
+      input: mappedItems,
+    };
+  }
+
+  private hasExecuteOne(nodeInstance: unknown): boolean {
+    return (
+      typeof nodeInstance === "object" &&
+      nodeInstance !== null &&
+      typeof (nodeInstance as { executeOne?: unknown }).executeOne === "function"
+    );
+  }
+
+  private resolveInputSchema(
+    nodeInstance: unknown,
+    config: RunnableNodeConfig,
+  ): {
+    parse: (data: unknown) => unknown;
+  } {
+    const fromInstance = (nodeInstance as { inputSchema?: unknown }).inputSchema;
+    if (fromInstance && typeof (fromInstance as { parse?: unknown }).parse === "function") {
+      return fromInstance as { parse: (data: unknown) => unknown };
+    }
+    const fromConfig = config.inputSchema;
+    if (fromConfig && typeof fromConfig.parse === "function") {
+      return fromConfig as { parse: (data: unknown) => unknown };
+    }
+    return z.unknown();
+  }
+
+  private formatContractFailure(cause: unknown): string {
+    if (cause instanceof ZodError) {
+      return cause.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ");
+    }
+    if (cause instanceof Error) {
+      return cause.message;
+    }
+    return String(cause);
+  }
+}

package/src/execution/NodeExecutor.ts

@@ -1,4 +1,11 @@
-import type { MultiInputNode, Node, NodeActivationRequest, NodeOutputs, WorkflowNodeInstanceFactory } from "../types";
+import type {
+  Item,
+  MultiInputNode,
+  Node,
+  NodeActivationRequest,
+  NodeOutputs,
+  WorkflowNodeInstanceFactory,
+} from "../types";
 
 import { InProcessRetryRunner } from "./InProcessRetryRunner";
 
@@ -34,10 +41,40 @@ export class NodeExecutor {
     request: Extract<NodeActivationRequest, { kind: "single" }>,
     node: unknown,
   ): Promise<NodeOutputs> {
+    if (this.hasExecuteOne(node)) {
+      return await this.executeItemNode(request, node);
+    }
     const singleInputNode = node as Node;
     if (typeof (singleInputNode as { execute?: unknown }).execute !== "function") {
       throw new Error(`Node ${request.nodeId} does not support execute but received single-input activation`);
     }
     return await singleInputNode.execute(request.input, request.ctx as any);
   }
+
+  private hasExecuteOne(node: unknown): node is { executeOne: (args: unknown) => unknown | Promise<unknown> } {
+    return (
+      typeof node === "object" && node !== null && typeof (node as { executeOne?: unknown }).executeOne === "function"
+    );
+  }
+
+  private async executeItemNode(
+    request: Extract<NodeActivationRequest, { kind: "single" }>,
+    node: { executeOne: (args: unknown) => unknown | Promise<unknown> },
+  ): Promise<NodeOutputs> {
+    const out: Item[] = [];
+    for (let i = 0; i < request.input.length; i++) {
+      const item = request.input[i] as Item;
+      const outputJson = await Promise.resolve(
+        node.executeOne({
+          input: item.json,
+          item,
+          itemIndex: i,
+          items: request.input,
+          ctx: request.ctx,
+        }),
+      );
+      out.push({ ...item, json: outputJson });
+    }
+    return { main: out };
+  }
 }

package/src/execution/NodeInputContractError.ts

@@ -0,0 +1,13 @@
+import type { NodeActivationId, NodeId } from "../types";
+
+export class NodeInputContractError extends Error {
+  constructor(
+    message: string,
+    public readonly nodeId: NodeId,
+    public readonly activationId: NodeActivationId,
+    public readonly cause?: unknown,
+  ) {
+    super(message);
+    this.name = "NodeInputContractError";
+  }
+}

package/src/execution/index.ts

@@ -1,4 +1,6 @@
 export { ActivationEnqueueService } from "./ActivationEnqueueService";
+export { NodeActivationRequestInputPreparer } from "./NodeActivationRequestInputPreparer";
+export { NodeInputContractError } from "./NodeInputContractError";
 export { CredentialResolverFactory } from "./CredentialResolverFactory";
 export { DefaultAsyncSleeper } from "./DefaultAsyncSleeper";
 export { DefaultExecutionContextFactory } from "./DefaultExecutionContextFactory";

package/src/orchestration/RunContinuationService.ts

@@ -1,7 +1,10 @@
 import type {
   ActivationIdFactory,
+  EngineRunCounters,
   NodeActivationId,
+  NodeActivationRequest,
   NodeExecutionContext,
+  NodeExecutionSnapshot,
   NodeId,
   NodeInputsByPort,
   NodeOutputs,
@@ -32,6 +35,7 @@ import type { EngineWaiters } from "../orchestration/EngineWaiters";
 import { NodeEventPublisher } from "../events/NodeEventPublisher";
 
 import { ActivationEnqueueService } from "../execution/ActivationEnqueueService";
+import { NodeInputsByPortFactory } from "../execution/NodeInputsByPortFactory";
 import { NodeExecutionSnapshotFactory } from "../execution/NodeExecutionSnapshotFactory";
 import { NodeRunStateWriterFactory } from "../execution/NodeRunStateWriterFactory";
 import { NodeActivationRequestComposer } from "../execution/NodeActivationRequestComposer";
@@ -301,26 +305,43 @@ export class RunContinuationService {
       nodeDefinition: def,
     });
 
-    const { queuedSnapshot, result } = await this.activationEnqueueService.enqueueActivationWithSnapshot({
-      runId: state.runId,
-      workflowId: state.workflowId,
-      startedAt: state.startedAt,
-      parent: state.parent,
-      executionOptions: state.executionOptions,
-      control: state.control,
-      workflowSnapshot: state.workflowSnapshot,
-      mutableState: state.mutableState,
-      policySnapshot: state.policySnapshot,
-      pendingQueue: queue,
-      request,
-      previousNodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId,
-      planner,
-      engineCounters,
-      connectionInvocations: state.connectionInvocations ?? [],
-    });
-    await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-    await this.nodeEventPublisher.publish("nodeQueued", queuedSnapshot);
-    return result;
+    try {
+      const { queuedSnapshot, result } = await this.activationEnqueueService.enqueueActivationWithSnapshot({
+        runId: state.runId,
+        workflowId: state.workflowId,
+        startedAt: state.startedAt,
+        parent: state.parent,
+        executionOptions: state.executionOptions,
+        control: state.control,
+        workflowSnapshot: state.workflowSnapshot,
+        mutableState: state.mutableState,
+        policySnapshot: state.policySnapshot,
+        pendingQueue: queue,
+        request,
+        previousNodeSnapshotsByNodeId: nextNodeSnapshotsByNodeId,
+        planner,
+        engineCounters,
+        connectionInvocations: state.connectionInvocations ?? [],
+      });
+      await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
+      await this.nodeEventPublisher.publish("nodeQueued", queuedSnapshot);
+      return result;
+    } catch (cause) {
+      const error = cause instanceof Error ? cause : new Error(String(cause));
+      return await this.terminateRunAfterActivationEnqueueRejected({
+        wf,
+        state,
+        queue,
+        nextNodeId: next.nodeId,
+        request,
+        completedSnapshot,
+        nextNodeSnapshotsByNodeId,
+        outputsByNode: data.dump(),
+        engineCounters,
+        error,
+        completedAt,
+      });
+    }
   }
 
   async resumeFromNodeError(args: {
@@ -744,36 +765,64 @@ export class RunContinuationService {
       nodeDefinition: nextDefinition,
     });
 
-    const { queuedSnapshot, result } = await this.activationEnqueueService.enqueueActivationWithSnapshot({
-      runId: args.state.runId,
-      workflowId: args.state.workflowId,
-      startedAt: args.state.startedAt,
-      parent: args.state.parent,
-      executionOptions: args.state.executionOptions,
-      control: args.state.control,
-      workflowSnapshot: args.state.workflowSnapshot,
-      mutableState: args.state.mutableState,
-      policySnapshot: args.state.policySnapshot,
-      pendingQueue: queue,
-      request,
-      previousNodeSnapshotsByNodeId: {
-        ...(args.state.nodeSnapshotsByNodeId ?? {}),
-        [args.args.nodeId]: completedSnapshot,
-      },
-      planner,
-      engineCounters,
-      connectionInvocations: args.state.connectionInvocations ?? [],
-    });
-    await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
-    await this.nodeEventPublisher.publish("nodeQueued", queuedSnapshot);
-    this.waiters.resolveWebhookResponse({
-      runId: args.state.runId,
-      workflowId: args.state.workflowId,
-      startedAt: args.state.startedAt,
-      runStatus: "pending",
-      response: args.signal.responseItems,
-    });
-    return result;
+    const mergedSnapshots = {
+      ...(args.state.nodeSnapshotsByNodeId ?? {}),
+      [args.args.nodeId]: completedSnapshot,
+    };
+
+    try {
+      const { queuedSnapshot, result } = await this.activationEnqueueService.enqueueActivationWithSnapshot({
+        runId: args.state.runId,
+        workflowId: args.state.workflowId,
+        startedAt: args.state.startedAt,
+        parent: args.state.parent,
+        executionOptions: args.state.executionOptions,
+        control: args.state.control,
+        workflowSnapshot: args.state.workflowSnapshot,
+        mutableState: args.state.mutableState,
+        policySnapshot: args.state.policySnapshot,
+        pendingQueue: queue,
+        request,
+        previousNodeSnapshotsByNodeId: mergedSnapshots,
+        planner,
+        engineCounters,
+        connectionInvocations: args.state.connectionInvocations ?? [],
+      });
+      await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
+      await this.nodeEventPublisher.publish("nodeQueued", queuedSnapshot);
+      this.waiters.resolveWebhookResponse({
+        runId: args.state.runId,
+        workflowId: args.state.workflowId,
+        startedAt: args.state.startedAt,
+        runStatus: "pending",
+        response: args.signal.responseItems,
+      });
+      return result;
+    } catch (cause) {
+      const error = cause instanceof Error ? cause : new Error(String(cause));
+      const finishedAt = completedSnapshot.finishedAt ?? completedSnapshot.updatedAt;
+      const result = await this.terminateRunAfterActivationEnqueueRejected({
+        wf: args.workflow,
+        state: args.state,
+        queue,
+        nextNodeId: next.nodeId,
+        request,
+        completedSnapshot,
+        nextNodeSnapshotsByNodeId: mergedSnapshots,
+        outputsByNode: data.dump(),
+        engineCounters,
+        error,
+        completedAt: finishedAt,
+      });
+      this.waiters.resolveWebhookResponse({
+        runId: args.state.runId,
+        workflowId: args.state.workflowId,
+        startedAt: args.state.startedAt,
+        runStatus: "pending",
+        response: args.signal.responseItems,
+      });
+      return result;
+    }
   }
 
   private asWebhookControlSignal(error: Error): WebhookControlSignal | undefined {
@@ -860,6 +909,88 @@ export class RunContinuationService {
     };
   }
 
+  /**
+   * Next activation could not be enqueued (e.g. input contract / mapping failed in the preparer).
+   * Marks the target node failed and terminates the run.
+   */
+  private async terminateRunAfterActivationEnqueueRejected(
+    args: Readonly<{
+      wf: WorkflowDefinition;
+      state: PersistedRunState;
+      queue: RunQueueEntry[];
+      nextNodeId: NodeId;
+      request: NodeActivationRequest;
+      completedSnapshot: NodeExecutionSnapshot;
+      nextNodeSnapshotsByNodeId: NonNullable<PersistedRunState["nodeSnapshotsByNodeId"]>;
+      outputsByNode: PersistedRunState["outputsByNode"];
+      engineCounters: EngineRunCounters;
+      error: Error;
+      completedAt: string;
+    }>,
+  ): Promise<RunResult> {
+    const finishedAt = args.completedAt;
+    const inputsByPort = NodeInputsByPortFactory.fromRequest(args.request);
+    const failedSnapshot = NodeExecutionSnapshotFactory.failed({
+      previous: undefined,
+      runId: args.state.runId,
+      workflowId: args.state.workflowId,
+      nodeId: args.nextNodeId,
+      activationId: args.request.activationId,
+      parent: args.state.parent,
+      finishedAt,
+      inputsByPort,
+      error: args.error,
+    });
+    const failedState = this.persistedRunStateTerminalBuilder.mergeTerminal({
+      state: args.state,
+      engineCounters: args.engineCounters,
+      status: "failed",
+      queue: args.queue.map((q) => ({ ...q })),
+      outputsByNode: args.outputsByNode,
+      nodeSnapshotsByNodeId: {
+        ...args.nextNodeSnapshotsByNodeId,
+        [args.nextNodeId]: failedSnapshot,
+      },
+      finishedAtIso: finishedAt,
+    });
+    await this.workflowExecutionRepository.save(failedState);
+    await this.nodeEventPublisher.publish("nodeCompleted", args.completedSnapshot);
+    await this.nodeEventPublisher.publish("nodeFailed", failedSnapshot);
+
+    const wfErr = this.policyErrorServices.resolveWorkflowErrorHandler(args.wf.workflowErrorHandler);
+    if (wfErr) {
+      await Promise.resolve(
+        wfErr.onError({
+          runId: args.state.runId,
+          workflowId: args.state.workflowId,
+          workflow: args.wf,
+          failedNodeId: args.nextNodeId,
+          error: args.error,
+          startedAt: args.state.startedAt,
+          finishedAt,
+        }),
+      );
+    }
+
+    await this.terminalPersistence.maybeDeleteAfterTerminalState({
+      workflow: args.wf,
+      state: failedState,
+      finalStatus: "failed",
+      finishedAt,
+    });
+
+    const message = args.error.message ?? String(args.error);
+    const result: RunResult = {
+      runId: args.state.runId,
+      workflowId: args.state.workflowId,
+      startedAt: args.state.startedAt,
+      status: "failed",
+      error: { message },
+    };
+    this.waiters.resolveRunCompletion(result);
+    return result;
+  }
+
   private formatNodeLabel(args: {
     definition?: Readonly<{ id: NodeId; name?: string; type: unknown }>;
     nodeId: NodeId;

package/src/planning/RunQueuePlanner.ts

@@ -149,6 +149,17 @@ export class RunQueuePlanner {
     }
   }
 
+  /**
+   * Matches `CurrentStateFrontierPlanner.buildFrontierQueue`: anything that is not exactly one input
+   * port named `in` participates in multi-port collect (Merge after `If` branches, etc.). Routing must
+   * not depend solely on `nodeInstances.get(toNodeId)?.executeMulti`, or a Merge can be enqueued as a
+   * single-input job and `NodeExecutor` will call `execute` on a multi-input-only implementation.
+   */
+  private usesTopologyCollectMerge(toNodeId: NodeId): boolean {
+    const expectedInputs = this.topology.expectedInputsByNode.get(toNodeId) ?? [];
+    return expectedInputs.length !== 1 || expectedInputs[0] !== "in";
+  }
+
   private enqueueEdge(
     queue: RunQueueEntry[],
     args: Readonly<{
@@ -159,7 +170,7 @@ export class RunQueuePlanner {
     }>,
   ): void {
     const target = this.nodeInstances.get(args.to.nodeId);
-    const isMulti = this.isMultiInputNode(target);
+    const isMulti = this.usesTopologyCollectMerge(args.to.nodeId) || this.isMultiInputNode(target);
 
     if (!isMulti) {
       if (args.items.length === 0) {

package/src/runtime/EngineFactory.ts

@@ -5,6 +5,7 @@ import { MissingRuntimeExecutionMarker } from "../workflowSnapshots/MissingRunti
 import { WorkflowSnapshotCodec } from "../workflowSnapshots/WorkflowSnapshotCodec";
 import { WorkflowSnapshotResolver } from "../workflowSnapshots/WorkflowSnapshotResolver";
 import { ActivationEnqueueService } from "../execution/ActivationEnqueueService";
+import { NodeActivationRequestInputPreparer } from "../execution/NodeActivationRequestInputPreparer";
 import { NodeActivationRequestComposer } from "../execution/NodeActivationRequestComposer";
 import { PersistedRunStateTerminalBuilder } from "../execution/PersistedRunStateTerminalBuilder";
 import { NodeExecutionRequestHandlerService } from "../orchestration/NodeExecutionRequestHandlerService";
@@ -61,10 +62,12 @@ export class EngineFactory {
     );
 
     const semantics = new RunStateSemantics(new MissingRuntimeExecutionMarker());
+    const nodeActivationRequestInputPreparer = new NodeActivationRequestInputPreparer(deps.workflowNodeInstanceFactory);
     const activationEnqueueService = new ActivationEnqueueService(
       deps.activationScheduler,
       deps.workflowExecutionRepository,
       nodeEventPublisher,
+      nodeActivationRequestInputPreparer,
     );
     const runExecutionContextFactory = new WorkflowRunExecutionContextFactory(
       deps.executionContextFactory,

package/src/testing/ItemHarnessNode.ts

@@ -0,0 +1,27 @@
+import type { Item, ItemNode, Items, NodeExecutionContext } from "../types";
+
+import type { ItemHarnessNodeConfig } from "./ItemHarnessNodeConfig";
+
+/**
+ * Item-mode harness node for engine tests (see {@link ItemHarnessNodeConfig}).
+ */
+export class ItemHarnessNode implements ItemNode<ItemHarnessNodeConfig<any, any, any>, unknown, unknown> {
+  readonly kind = "node" as const;
+  readonly outputPorts = ["main"] as const;
+
+  async executeOne(args: {
+    input: unknown;
+    item: Item;
+    itemIndex: number;
+    items: Items;
+    ctx: NodeExecutionContext<ItemHarnessNodeConfig<any, any, any>>;
+  }): Promise<unknown> {
+    return await args.ctx.config.runOne({
+      input: args.input as never,
+      item: args.item,
+      itemIndex: args.itemIndex,
+      items: args.items,
+      ctx: args.ctx,
+    });
+  }
+}

package/src/testing/ItemHarnessNodeConfig.ts

@@ -0,0 +1,43 @@
+import type { ZodType } from "zod";
+
+import type { TypeToken } from "../di";
+import type { Item, ItemInputMapper, Items, NodeExecutionContext, RunnableNodeConfig } from "../types";
+
+import { ItemHarnessNode } from "./ItemHarnessNode";
+
+/**
+ * Item-mode harness node config for engine tests: engine applies {@link RunnableNodeConfig.inputSchema} +
+ * optional {@link RunnableNodeConfig.mapInput}, then {@link ItemHarnessNode.executeOne} per item.
+ */
+export class ItemHarnessNodeConfig<TIn = unknown, TOut = unknown, TWire = TIn> implements RunnableNodeConfig<
+  TIn,
+  TOut,
+  TWire
+> {
+  readonly kind = "node" as const;
+  readonly type: TypeToken<unknown> = ItemHarnessNode;
+
+  constructor(
+    public readonly name: string,
+    public readonly inputSchema: ZodType<TIn>,
+    public readonly runOne: (args: {
+      input: TIn;
+      item: Item<TWire>;
+      itemIndex: number;
+      items: Items<TWire>;
+      ctx: NodeExecutionContext<ItemHarnessNodeConfig<TIn, TOut, TWire>>;
+    }) => TOut | Promise<TOut>,
+    public readonly opts: Readonly<{
+      id?: string;
+      mapInput?: ItemInputMapper<TWire, TIn>;
+    }> = {},
+  ) {}
+
+  get mapInput(): ItemInputMapper<TWire, TIn> | undefined {
+    return this.opts.mapInput;
+  }
+
+  get id(): string | undefined {
+    return this.opts.id;
+  }
+}

package/src/testing/RegistrarEngineTestKitFactory.ts

@@ -29,6 +29,7 @@ import { RejectingCredentialSessionService } from "./RejectingCredentialSessionS
 import { CapturingScheduler } from "./CapturingScheduler";
 import { PrefixedSequentialIdGenerator } from "./PrefixedSequentialIdGenerator";
 import type { RegistrarEngineTestKitHandle, RegistrarEngineTestKitOptions } from "./RegistrarEngineTestKit.types";
+import { ItemHarnessNode } from "./ItemHarnessNode";
 import { SubWorkflowRunnerNode } from "./SubWorkflowRunnerTestNode";
 import { WorkflowTestHarnessManualTriggerNode } from "./WorkflowTestHarnessManualTrigger";
 
@@ -108,6 +109,7 @@ export class RegistrarEngineTestKitFactory {
       SubWorkflowRunnerNode,
       new SubWorkflowRunnerNode(workflowRunner as WorkflowRunnerService),
     );
+    dependencyContainer.registerInstance(ItemHarnessNode, new ItemHarnessNode());
     dependencyContainer.registerInstance(
       WorkflowTestHarnessManualTriggerNode,
       new WorkflowTestHarnessManualTriggerNode(),

package/src/testing.ts

@@ -4,6 +4,8 @@
 export { InMemoryLiveWorkflowRepository } from "./runtime/InMemoryLiveWorkflowRepository";
 export { WorkflowSnapshotCodec as PersistedWorkflowSnapshotFactory } from "./workflowSnapshots/WorkflowSnapshotCodec";
 export { RejectingCredentialSessionService } from "./testing/RejectingCredentialSessionService";
+export { ItemHarnessNode } from "./testing/ItemHarnessNode";
+export { ItemHarnessNodeConfig } from "./testing/ItemHarnessNodeConfig";
 export { CapturingScheduler } from "./testing/CapturingScheduler";
 export { PrefixedSequentialIdGenerator } from "./testing/PrefixedSequentialIdGenerator";
 export {

package/src/workflow/dsl/ChainCursorResolver.ts

@@ -38,7 +38,7 @@ export class ChainCursor<TCurrentJson> {
     private readonly cursorOutput: OutputPortKey,
   ) {}
 
-  then<TConfig extends RunnableNodeConfig<TCurrentJson, any>>(
+  then<TInputJson, TOutputJson, TConfig extends RunnableNodeConfig<TInputJson, TOutputJson, TCurrentJson>>(
     config: TConfig,
   ): ChainCursor<RunnableNodeOutputJson<TConfig>> {
     const next = (this.wf as any).add(config) as NodeRef;

package/src/workflow/dsl/workflowBuilderTypes.ts

@@ -1,6 +1,6 @@
 import type { RunnableNodeConfig, RunnableNodeOutputJson, TriggerNodeConfig } from "../../types";
 
-export type AnyRunnableNodeConfig = RunnableNodeConfig<any, any>;
+export type AnyRunnableNodeConfig = RunnableNodeConfig<any, any, any>;
 
 export type AnyTriggerNodeConfig = TriggerNodeConfig<any>;
 
@@ -10,7 +10,7 @@ export type ValidStepSequence<
 > = TSteps extends readonly []
   ? readonly []
   : TSteps extends readonly [infer TFirst, ...infer TRest]
-    ? TFirst extends RunnableNodeConfig<TCurrentJson, infer TNextJson>
+    ? TFirst extends RunnableNodeConfig<infer _TIn, infer TNextJson, TCurrentJson>
       ? TRest extends ReadonlyArray<AnyRunnableNodeConfig>
         ? readonly [TFirst, ...ValidStepSequence<TNextJson, TRest>]
         : never
@@ -22,7 +22,7 @@ export type StepSequenceOutput<TCurrentJson, TSteps extends ReadonlyArray<AnyRun
     ? TSteps extends readonly []
       ? TCurrentJson
       : TSteps extends readonly [infer TFirst, ...infer TRest]
-        ? TFirst extends RunnableNodeConfig<TCurrentJson, infer TNextJson>
+        ? TFirst extends RunnableNodeConfig<infer _TIn, infer TNextJson, TCurrentJson>
           ? TRest extends ReadonlyArray<AnyRunnableNodeConfig>
             ? StepSequenceOutput<TNextJson, TRest>
             : never
@@ -46,7 +46,7 @@ export type BranchStepsArg<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnabl
 
 export type BranchMoreArgs<
   TCurrentJson,
-  TFirstStep extends RunnableNodeConfig<TCurrentJson, any>,
+  TFirstStep extends RunnableNodeConfig<any, any, TCurrentJson>,
   TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>,
 > = TRestSteps & ValidStepSequence<RunnableNodeOutputJson<TFirstStep>, TRestSteps>;
 
@@ -55,7 +55,10 @@ export type BooleanWhenOverloads<TCurrentJson, TReturn> = {
     branch: boolean,
     steps: BranchStepsArg<TCurrentJson, TSteps>,
   ): TReturn;
-  <TFirstStep extends RunnableNodeConfig<TCurrentJson, any>, TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>>(
+  <
+    TFirstStep extends RunnableNodeConfig<any, any, TCurrentJson>,
+    TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>,
+  >(
     branch: boolean,
     step: TFirstStep,
     ...more: BranchMoreArgs<TCurrentJson, TFirstStep, TRestSteps>