@codemation/core 0.2.1 → 0.3.0

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>