@codemation/core-nodes 0.0.25 → 0.1.1

package/src/nodes/SubWorkflowNode.ts

@@ -1,11 +1,10 @@
-import type { Item, Items, Node, NodeExecutionContext, NodeOutputs, WorkflowRunnerService } from "@codemation/core";
-
-import { CoreTokens, inject, node } from "@codemation/core";
+import type { Item, RunnableNode, RunnableNodeExecuteArgs, WorkflowRunnerService } from "@codemation/core";
+import { CoreTokens, emitPorts, inject, node } from "@codemation/core";
 
 import { SubWorkflow } from "./subWorkflow";
 
 @node({ packageName: "@codemation/core-nodes" })
-export class SubWorkflowNode implements Node<SubWorkflow<any, any>> {
+export class SubWorkflowNode implements RunnableNode<SubWorkflow<any, any>> {
   kind = "node" as const;
   outputPorts = ["main"] as const;
 
@@ -14,52 +13,51 @@ export class SubWorkflowNode implements Node<SubWorkflow<any, any>> {
     private readonly workflows: WorkflowRunnerService,
   ) {}
 
-  async execute(items: Items, ctx: NodeExecutionContext<SubWorkflow<any, any>>): Promise<NodeOutputs> {
+  async execute(args: RunnableNodeExecuteArgs<SubWorkflow<any, any>>): Promise<unknown> {
+    const current = args.item as Item;
+    const metaBase = (
+      current.meta && typeof current.meta === "object" ? (current.meta as Record<string, unknown>) : {}
+    ) as Record<string, unknown>;
+    const cmBase =
+      metaBase._cm && typeof metaBase._cm === "object"
+        ? (metaBase._cm as Record<string, unknown>)
+        : ({} as Record<string, unknown>);
+    const originIndex = typeof cmBase.originIndex === "number" ? (cmBase.originIndex as number) : undefined;
+
+    const result = await this.workflows.runById({
+      workflowId: args.ctx.config.workflowId,
+      startAt: args.ctx.config.startAt,
+      items: [current],
+      parent: {
+        runId: args.ctx.runId,
+        workflowId: args.ctx.workflowId,
+        nodeId: args.ctx.nodeId,
+        subworkflowDepth: args.ctx.subworkflowDepth,
+        engineMaxNodeActivations: args.ctx.engineMaxNodeActivations,
+        engineMaxSubworkflowDepth: args.ctx.engineMaxSubworkflowDepth,
+      },
+    });
+    if (result.status !== "completed") {
+      throw new Error(`Subworkflow ${args.ctx.config.workflowId} did not complete (status=${result.status})`);
+    }
     const out: Item[] = [];
-    for (let i = 0; i < items.length; i++) {
-      const current = items[i]!;
-      const metaBase = (
-        current.meta && typeof current.meta === "object" ? (current.meta as Record<string, unknown>) : {}
-      ) as Record<string, unknown>;
-      const cmBase =
-        metaBase._cm && typeof metaBase._cm === "object"
-          ? (metaBase._cm as Record<string, unknown>)
+    for (const produced of result.outputs) {
+      const childMetaBase =
+        produced.meta && typeof produced.meta === "object"
+          ? (produced.meta as Record<string, unknown>)
+          : ({} as Record<string, unknown>);
+      const childCmBase =
+        childMetaBase._cm && typeof childMetaBase._cm === "object"
+          ? (childMetaBase._cm as Record<string, unknown>)
           : ({} as Record<string, unknown>);
-      const originIndex = typeof cmBase.originIndex === "number" ? (cmBase.originIndex as number) : undefined;
 
-      const result = await this.workflows.runById({
-        workflowId: ctx.config.workflowId,
-        startAt: ctx.config.startAt,
-        items: [current],
-        parent: {
-          runId: ctx.runId,
-          workflowId: ctx.workflowId,
-          nodeId: ctx.nodeId,
-          subworkflowDepth: ctx.subworkflowDepth,
-          engineMaxNodeActivations: ctx.engineMaxNodeActivations,
-          engineMaxSubworkflowDepth: ctx.engineMaxSubworkflowDepth,
-        },
+      out.push({
+        ...produced,
+        meta: originIndex === undefined ? childMetaBase : { ...childMetaBase, _cm: { ...childCmBase, originIndex } },
+        paired: current.paired ?? produced.paired,
       });
-      if (result.status !== "completed")
-        throw new Error(`Subworkflow ${ctx.config.workflowId} did not complete (status=${result.status})`);
-      for (const produced of result.outputs) {
-        const childMetaBase =
-          produced.meta && typeof produced.meta === "object"
-            ? (produced.meta as Record<string, unknown>)
-            : ({} as Record<string, unknown>);
-        const childCmBase =
-          childMetaBase._cm && typeof childMetaBase._cm === "object"
-            ? (childMetaBase._cm as Record<string, unknown>)
-            : ({} as Record<string, unknown>);
-
-        out.push({
-          ...produced,
-          meta: originIndex === undefined ? childMetaBase : { ...childMetaBase, _cm: { ...childCmBase, originIndex } },
-          paired: current.paired ?? produced.paired,
-        });
-      }
     }
 
-    return { main: out };
+    return emitPorts({ main: out });
   }
 }

package/src/nodes/SwitchNode.ts

@@ -0,0 +1,29 @@
+import type { RunnableNode, RunnableNodeExecuteArgs } from "@codemation/core";
+import { emitPorts, node } from "@codemation/core";
+
+import type { Switch } from "./switch";
+import { tagItemForRouterFanIn } from "./mergeExecutionUtils.types";
+
+/**
+ * Routes each item to exactly one output port. Port names must match workflow edges (see {@link Switch} config).
+ */
+@node({ packageName: "@codemation/core-nodes" })
+export class SwitchNode implements RunnableNode<Switch<any>> {
+  kind = "node" as const;
+
+  async execute(args: RunnableNodeExecuteArgs<Switch<any>>): Promise<unknown> {
+    const tagged = tagItemForRouterFanIn({
+      item: args.item,
+      itemIndex: args.itemIndex,
+      nodeId: args.ctx.nodeId,
+    });
+    const key = await Promise.resolve(
+      args.ctx.config.cfg.resolveCaseKey(args.item, args.itemIndex, args.items, args.ctx),
+    );
+    const { cases, defaultCase } = args.ctx.config.cfg;
+    const port = cases.includes(key) ? key : defaultCase;
+    return emitPorts({
+      [port]: [tagged],
+    });
+  }
+}

package/src/nodes/WaitNode.ts

@@ -1,4 +1,4 @@
-import type { Items, Node, NodeExecutionContext, NodeOutputs } from "@codemation/core";
+import type { RunnableNode, RunnableNodeExecuteArgs } from "@codemation/core";
 
 import { node } from "@codemation/core";
 
@@ -6,17 +6,19 @@ import { Wait } from "./wait";
 import { WaitDuration } from "./WaitDurationFactory";
 
 @node({ packageName: "@codemation/core-nodes" })
-export class WaitNode implements Node<Wait<any>> {
+export class WaitNode implements RunnableNode<Wait<any>> {
   kind = "node" as const;
   outputPorts = ["main"] as const;
 
-  async execute(items: Items, ctx: NodeExecutionContext<Wait<any>>): Promise<NodeOutputs> {
-    const milliseconds = WaitDuration.normalize(ctx.config.milliseconds);
-    if (milliseconds > 0) {
-      await new Promise<void>((resolve) => {
-        setTimeout(resolve, milliseconds);
-      });
+  async execute(args: RunnableNodeExecuteArgs<Wait<any>>): Promise<unknown> {
+    if (args.itemIndex === 0) {
+      const milliseconds = WaitDuration.normalize(args.ctx.config.milliseconds);
+      if (milliseconds > 0) {
+        await new Promise<void>((resolve) => {
+          setTimeout(resolve, milliseconds);
+        });
+      }
     }
-    return { main: items };
+    return args.item;
   }
 }

package/src/nodes/if.ts

@@ -7,6 +7,7 @@ export class If<TInputJson = unknown> implements RunnableNodeConfig<TInputJson,
   readonly type: TypeToken<unknown> = IfNode;
   readonly execution = { hint: "local" } as const;
   readonly icon = "lucide:split" as const;
+  readonly declaredOutputPorts = ["true", "false"] as const;
   constructor(
     public readonly name: string,
     public readonly predicate: (

package/src/nodes/mergeExecutionUtils.types.ts

@@ -1,10 +1,36 @@
-import type { InputPortKey, Item, Items } from "@codemation/core";
+import type { InputPortKey, Item, Items, NodeId } from "@codemation/core";
+import { getOriginIndexFromItem } from "@codemation/core";
 
 export function getOriginIndex(item: Item): number | undefined {
-  const meta = item.meta as Record<string, unknown> | undefined;
-  const cm = meta?._cm as Record<string, unknown> | undefined;
-  const v = cm?.originIndex;
-  return typeof v === "number" && Number.isFinite(v) ? v : undefined;
+  return getOriginIndexFromItem(item);
+}
+
+/**
+ * Tags items routed to fan-in merge-by-origin (same contract as {@link IfNode} / {@link SwitchNode}).
+ */
+export function tagItemForRouterFanIn<TJson>(
+  args: Readonly<{
+    item: Item<TJson>;
+    itemIndex: number;
+    nodeId: NodeId;
+    inputPortLabel?: string;
+  }>,
+): Item<TJson> {
+  const { item, itemIndex, nodeId, inputPortLabel = "$in" } = args;
+  const metaBase = (item.meta && typeof item.meta === "object" ? (item.meta as Record<string, unknown>) : {}) as Record<
+    string,
+    unknown
+  >;
+  const cmBase =
+    metaBase._cm && typeof metaBase._cm === "object"
+      ? (metaBase._cm as Record<string, unknown>)
+      : ({} as Record<string, unknown>);
+  const originIndex = typeof cmBase.originIndex === "number" ? (cmBase.originIndex as number) : itemIndex;
+  return {
+    ...item,
+    meta: { ...metaBase, _cm: { ...cmBase, originIndex } },
+    paired: [{ nodeId, output: inputPortLabel, itemIndex: originIndex }, ...(item.paired ?? [])],
+  };
 }
 
 export function orderedInputs(

package/src/nodes/switch.ts

@@ -0,0 +1,33 @@
+import type { Item, Items, NodeExecutionContext, RunnableNodeConfig, TypeToken } from "@codemation/core";
+
+import { SwitchNode } from "./SwitchNode";
+
+export type SwitchCaseKeyResolver<TInputJson = unknown> = (
+  item: Item<TInputJson>,
+  index: number,
+  items: Items<TInputJson>,
+  ctx: NodeExecutionContext<Switch<TInputJson>>,
+) => string | Promise<string>;
+
+export class Switch<TInputJson = unknown> implements RunnableNodeConfig<TInputJson, TInputJson> {
+  readonly kind = "node" as const;
+  readonly type: TypeToken<unknown> = SwitchNode;
+  readonly execution = { hint: "local" } as const;
+  readonly icon = "lucide:git-branch-plus" as const;
+  readonly lineageCarry = "carryThrough" as const;
+  readonly declaredOutputPorts: ReadonlyArray<string>;
+
+  constructor(
+    public readonly name: string,
+    public readonly cfg: Readonly<{
+      cases: readonly string[];
+      defaultCase: string;
+      resolveCaseKey: SwitchCaseKeyResolver<TInputJson>;
+    }>,
+    public readonly id?: string,
+  ) {
+    this.declaredOutputPorts = [...new Set([...cfg.cases, cfg.defaultCase])].sort();
+  }
+}
+
+export { SwitchNode } from "./SwitchNode";

package/src/register.types.ts

@@ -12,6 +12,7 @@ import { ConnectionCredentialNode } from "./nodes/ConnectionCredentialNode";
 import { AggregateNode } from "./nodes/aggregate";
 import { FilterNode } from "./nodes/filter";
 import { SplitNode } from "./nodes/split";
+import { SwitchNode } from "./nodes/switch";
 
 /**
  * Registrar for built-in nodes. In a real project, this would use tsyringe's
@@ -40,4 +41,5 @@ export function registerCoreNodes(container: Container): void {
   void SplitNode;
   void FilterNode;
   void AggregateNode;
+  void SwitchNode;
 }

package/src/workflowAuthoring/WorkflowBranchBuilder.types.ts

@@ -1,6 +1,17 @@
-import type { AnyRunnableNodeConfig, DefinedNode, RunnableNodeConfig, RunnableNodeOutputJson } from "@codemation/core";
+import type {
+  AnyRunnableNodeConfig,
+  DefinedNode,
+  Item,
+  Items,
+  NodeExecutionContext,
+  RunnableNodeConfig,
+  RunnableNodeOutputJson,
+} from "@codemation/core";
 import { z } from "zod";
+import { Aggregate } from "../nodes/aggregate";
+import { Filter } from "../nodes/filter";
 import { MapData } from "../nodes/mapData";
+import { Split } from "../nodes/split";
 import { Wait } from "../nodes/wait";
 import type { WorkflowAgentOptions } from "./WorkflowAuthoringOptions.types";
 import { WorkflowAgentNodeFactory } from "./WorkflowAgentNodeFactory.types";
@@ -10,7 +21,7 @@ import { WorkflowDurationParser } from "./WorkflowDurationParser.types";
 export class WorkflowBranchBuilder<TCurrentJson> {
   constructor(private readonly steps: ReadonlyArray<AnyRunnableNodeConfig> = []) {}
 
-  then<TInputJson, TOutputJson, TConfig extends RunnableNodeConfig<TInputJson, TOutputJson, TCurrentJson>>(
+  then<TOutputJson, TConfig extends RunnableNodeConfig<TCurrentJson, TOutputJson>>(
     config: TConfig,
   ): WorkflowBranchBuilder<RunnableNodeOutputJson<TConfig>> {
     return new WorkflowBranchBuilder<RunnableNodeOutputJson<TConfig>>([...this.steps, config]);
@@ -48,6 +59,101 @@ export class WorkflowBranchBuilder<TCurrentJson> {
     ) as WorkflowBranchBuilder<TCurrentJson>;
   }
 
+  split<TElem>(
+    getElements: (item: Item<TCurrentJson>, ctx: NodeExecutionContext<Split<TCurrentJson, TElem>>) => readonly TElem[],
+  ): WorkflowBranchBuilder<TElem>;
+  split<TElem>(
+    name: string,
+    getElements: (item: Item<TCurrentJson>, ctx: NodeExecutionContext<Split<TCurrentJson, TElem>>) => readonly TElem[],
+    id?: string,
+  ): WorkflowBranchBuilder<TElem>;
+  split<TElem>(
+    nameOrGetter:
+      | string
+      | ((item: Item<TCurrentJson>, ctx: NodeExecutionContext<Split<TCurrentJson, TElem>>) => readonly TElem[]),
+    getElementsOrUndefined?: (
+      item: Item<TCurrentJson>,
+      ctx: NodeExecutionContext<Split<TCurrentJson, TElem>>,
+    ) => readonly TElem[],
+    id?: string,
+  ): WorkflowBranchBuilder<TElem> {
+    const name = typeof nameOrGetter === "string" ? nameOrGetter : "Split";
+    const getElements = typeof nameOrGetter === "string" ? getElementsOrUndefined! : nameOrGetter;
+    return this.then(new Split<TCurrentJson, TElem>(name, getElements, id)) as WorkflowBranchBuilder<TElem>;
+  }
+
+  filter(
+    predicate: (
+      item: Item<TCurrentJson>,
+      index: number,
+      items: Items<TCurrentJson>,
+      ctx: NodeExecutionContext<Filter<TCurrentJson>>,
+    ) => boolean,
+  ): WorkflowBranchBuilder<TCurrentJson>;
+  filter(
+    name: string,
+    predicate: (
+      item: Item<TCurrentJson>,
+      index: number,
+      items: Items<TCurrentJson>,
+      ctx: NodeExecutionContext<Filter<TCurrentJson>>,
+    ) => boolean,
+    id?: string,
+  ): WorkflowBranchBuilder<TCurrentJson>;
+  filter(
+    nameOrPredicate:
+      | string
+      | ((
+          item: Item<TCurrentJson>,
+          index: number,
+          items: Items<TCurrentJson>,
+          ctx: NodeExecutionContext<Filter<TCurrentJson>>,
+        ) => boolean),
+    predicateOrUndefined?: (
+      item: Item<TCurrentJson>,
+      index: number,
+      items: Items<TCurrentJson>,
+      ctx: NodeExecutionContext<Filter<TCurrentJson>>,
+    ) => boolean,
+    id?: string,
+  ): WorkflowBranchBuilder<TCurrentJson> {
+    const name = typeof nameOrPredicate === "string" ? nameOrPredicate : "Filter";
+    const predicate = typeof nameOrPredicate === "string" ? predicateOrUndefined! : nameOrPredicate;
+    return this.then(new Filter<TCurrentJson>(name, predicate, id)) as WorkflowBranchBuilder<TCurrentJson>;
+  }
+
+  aggregate<TOut>(
+    aggregateFn: (
+      items: Items<TCurrentJson>,
+      ctx: NodeExecutionContext<Aggregate<TCurrentJson, TOut>>,
+    ) => TOut | Promise<TOut>,
+  ): WorkflowBranchBuilder<TOut>;
+  aggregate<TOut>(
+    name: string,
+    aggregateFn: (
+      items: Items<TCurrentJson>,
+      ctx: NodeExecutionContext<Aggregate<TCurrentJson, TOut>>,
+    ) => TOut | Promise<TOut>,
+    id?: string,
+  ): WorkflowBranchBuilder<TOut>;
+  aggregate<TOut>(
+    nameOrFn:
+      | string
+      | ((
+          items: Items<TCurrentJson>,
+          ctx: NodeExecutionContext<Aggregate<TCurrentJson, TOut>>,
+        ) => TOut | Promise<TOut>),
+    aggregateFnOrUndefined?: (
+      items: Items<TCurrentJson>,
+      ctx: NodeExecutionContext<Aggregate<TCurrentJson, TOut>>,
+    ) => TOut | Promise<TOut>,
+    id?: string,
+  ): WorkflowBranchBuilder<TOut> {
+    const name = typeof nameOrFn === "string" ? nameOrFn : "Aggregate";
+    const aggregateFn = typeof nameOrFn === "string" ? aggregateFnOrUndefined! : nameOrFn;
+    return this.then(new Aggregate<TCurrentJson, TOut>(name, aggregateFn, id)) as WorkflowBranchBuilder<TOut>;
+  }
+
   agent<TOutputSchema extends z.ZodTypeAny>(
     options: WorkflowAgentOptions<TCurrentJson, TOutputSchema>,
   ): WorkflowBranchBuilder<z.output<TOutputSchema>>;

package/src/workflowAuthoring/WorkflowChain.types.ts

@@ -1,8 +1,21 @@
-import type { DefinedNode, RunnableNodeConfig, RunnableNodeOutputJson, WorkflowDefinition } from "@codemation/core";
+import type {
+  DefinedNode,
+  Item,
+  Items,
+  NodeExecutionContext,
+  RunnableNodeConfig,
+  RunnableNodeOutputJson,
+  WorkflowDefinition,
+} from "@codemation/core";
 import { ChainCursor } from "@codemation/core";
 import { z } from "zod";
+import { Aggregate } from "../nodes/aggregate";
+import { Filter } from "../nodes/filter";
 import { If } from "../nodes/if";
 import { MapData } from "../nodes/mapData";
+import { Merge, type MergeMode } from "../nodes/merge";
+import { Split } from "../nodes/split";
+import { Switch } from "../nodes/switch";
 import { Wait } from "../nodes/wait";
 import type { WorkflowAgentOptions } from "./WorkflowAuthoringOptions.types";
 import { WorkflowAgentNodeFactory } from "./WorkflowAgentNodeFactory.types";
@@ -13,12 +26,13 @@ import { WorkflowDurationParser } from "./WorkflowDurationParser.types";
 type BranchCallback<TCurrentJson, TNextJson> = (
   branch: WorkflowBranchBuilder<TCurrentJson>,
 ) => WorkflowBranchBuilder<TNextJson>;
+type RouteBranchCallback<TCurrentJson, TNextJson> = (branch: WorkflowChain<TCurrentJson>) => WorkflowChain<TNextJson>;
 type BranchOutputMatch<TLeft, TRight> = [TLeft] extends [TRight] ? ([TRight] extends [TLeft] ? true : false) : false;
 
 export class WorkflowChain<TCurrentJson> {
   constructor(private readonly chain: ChainCursor<TCurrentJson>) {}
 
-  then<TInputJson, TOutputJson, TConfig extends RunnableNodeConfig<TInputJson, TOutputJson, TCurrentJson>>(
+  then<TOutputJson, TConfig extends RunnableNodeConfig<TCurrentJson, TOutputJson>>(
     config: TConfig,
   ): WorkflowChain<RunnableNodeOutputJson<TConfig>> {
     return new WorkflowChain(this.chain.then(config));
@@ -52,6 +66,124 @@ export class WorkflowChain<TCurrentJson> {
     ) as WorkflowChain<TCurrentJson>;
   }
 
+  split<TElem>(
+    getElements: (item: Item<TCurrentJson>, ctx: NodeExecutionContext<Split<TCurrentJson, TElem>>) => readonly TElem[],
+  ): WorkflowChain<TElem>;
+  split<TElem>(
+    name: string,
+    getElements: (item: Item<TCurrentJson>, ctx: NodeExecutionContext<Split<TCurrentJson, TElem>>) => readonly TElem[],
+    id?: string,
+  ): WorkflowChain<TElem>;
+  split<TElem>(
+    nameOrGetter:
+      | string
+      | ((item: Item<TCurrentJson>, ctx: NodeExecutionContext<Split<TCurrentJson, TElem>>) => readonly TElem[]),
+    getElementsOrUndefined?: (
+      item: Item<TCurrentJson>,
+      ctx: NodeExecutionContext<Split<TCurrentJson, TElem>>,
+    ) => readonly TElem[],
+    id?: string,
+  ): WorkflowChain<TElem> {
+    const name = typeof nameOrGetter === "string" ? nameOrGetter : "Split";
+    const getElements = typeof nameOrGetter === "string" ? getElementsOrUndefined! : nameOrGetter;
+    return this.then(new Split<TCurrentJson, TElem>(name, getElements, id)) as WorkflowChain<TElem>;
+  }
+
+  filter(
+    predicate: (
+      item: Item<TCurrentJson>,
+      index: number,
+      items: Items<TCurrentJson>,
+      ctx: NodeExecutionContext<Filter<TCurrentJson>>,
+    ) => boolean,
+  ): WorkflowChain<TCurrentJson>;
+  filter(
+    name: string,
+    predicate: (
+      item: Item<TCurrentJson>,
+      index: number,
+      items: Items<TCurrentJson>,
+      ctx: NodeExecutionContext<Filter<TCurrentJson>>,
+    ) => boolean,
+    id?: string,
+  ): WorkflowChain<TCurrentJson>;
+  filter(
+    nameOrPredicate:
+      | string
+      | ((
+          item: Item<TCurrentJson>,
+          index: number,
+          items: Items<TCurrentJson>,
+          ctx: NodeExecutionContext<Filter<TCurrentJson>>,
+        ) => boolean),
+    predicateOrUndefined?: (
+      item: Item<TCurrentJson>,
+      index: number,
+      items: Items<TCurrentJson>,
+      ctx: NodeExecutionContext<Filter<TCurrentJson>>,
+    ) => boolean,
+    id?: string,
+  ): WorkflowChain<TCurrentJson> {
+    const name = typeof nameOrPredicate === "string" ? nameOrPredicate : "Filter";
+    const predicate = typeof nameOrPredicate === "string" ? predicateOrUndefined! : nameOrPredicate;
+    return this.then(new Filter<TCurrentJson>(name, predicate, id)) as WorkflowChain<TCurrentJson>;
+  }
+
+  aggregate<TOut>(
+    aggregateFn: (
+      items: Items<TCurrentJson>,
+      ctx: NodeExecutionContext<Aggregate<TCurrentJson, TOut>>,
+    ) => TOut | Promise<TOut>,
+  ): WorkflowChain<TOut>;
+  aggregate<TOut>(
+    name: string,
+    aggregateFn: (
+      items: Items<TCurrentJson>,
+      ctx: NodeExecutionContext<Aggregate<TCurrentJson, TOut>>,
+    ) => TOut | Promise<TOut>,
+    id?: string,
+  ): WorkflowChain<TOut>;
+  aggregate<TOut>(
+    nameOrFn:
+      | string
+      | ((
+          items: Items<TCurrentJson>,
+          ctx: NodeExecutionContext<Aggregate<TCurrentJson, TOut>>,
+        ) => TOut | Promise<TOut>),
+    aggregateFnOrUndefined?: (
+      items: Items<TCurrentJson>,
+      ctx: NodeExecutionContext<Aggregate<TCurrentJson, TOut>>,
+    ) => TOut | Promise<TOut>,
+    id?: string,
+  ): WorkflowChain<TOut> {
+    const name = typeof nameOrFn === "string" ? nameOrFn : "Aggregate";
+    const aggregateFn = typeof nameOrFn === "string" ? aggregateFnOrUndefined! : nameOrFn;
+    return this.then(new Aggregate<TCurrentJson, TOut>(name, aggregateFn, id)) as WorkflowChain<TOut>;
+  }
+
+  merge(): WorkflowChain<TCurrentJson>;
+  merge(cfg: Readonly<{ mode: MergeMode; prefer?: ReadonlyArray<string> }>, id?: string): WorkflowChain<TCurrentJson>;
+  merge(
+    name: string,
+    cfg?: Readonly<{ mode: MergeMode; prefer?: ReadonlyArray<string> }>,
+    id?: string,
+  ): WorkflowChain<TCurrentJson>;
+  merge(
+    nameOrCfg?: string | Readonly<{ mode: MergeMode; prefer?: ReadonlyArray<string> }>,
+    cfgOrId?: Readonly<{ mode: MergeMode; prefer?: ReadonlyArray<string> }> | string,
+    id?: string,
+  ): WorkflowChain<TCurrentJson> {
+    const name = typeof nameOrCfg === "string" ? nameOrCfg : "Merge";
+    const cfg =
+      typeof nameOrCfg === "string"
+        ? ((typeof cfgOrId === "string" ? undefined : cfgOrId) ?? { mode: "passThrough" as const })
+        : (nameOrCfg ?? { mode: "passThrough" as const });
+    const mergeId = typeof cfgOrId === "string" ? cfgOrId : id;
+    return new WorkflowChain(
+      this.chain.thenIntoInputHints(new Merge<TCurrentJson>(name, cfg, mergeId)),
+    ) as WorkflowChain<TCurrentJson>;
+  }
+
   if<TBranchJson>(
     predicate: (item: TCurrentJson) => boolean,
     branches: Readonly<{
@@ -95,6 +227,79 @@ export class WorkflowChain<TCurrentJson> {
     ) as WorkflowChain<BranchOutputMatch<TTrueJson, TFalseJson> extends true ? TTrueJson : never>;
   }
 
+  route<TBranchJson>(
+    branches: Readonly<Record<string, RouteBranchCallback<TCurrentJson, TBranchJson> | undefined>>,
+  ): WorkflowChain<TBranchJson> {
+    const mappedBranches = Object.fromEntries(
+      Object.entries(branches).map(([port, branchFactory]) => [
+        port,
+        branchFactory
+          ? (branch: ChainCursor<TCurrentJson>) => branchFactory(new WorkflowChain(branch)).chain
+          : undefined,
+      ]),
+    ) as Readonly<
+      Record<string, ((branch: ChainCursor<TCurrentJson>) => ChainCursor<TBranchJson> | undefined) | undefined>
+    >;
+    return new WorkflowChain(
+      this.chain.route(
+        mappedBranches as Readonly<
+          Record<string, (branch: ChainCursor<TCurrentJson>) => ChainCursor<TBranchJson> | undefined>
+        >,
+      ),
+    ) as WorkflowChain<TBranchJson>;
+  }
+
+  switch<TBranchJson>(
+    cfg: Readonly<{
+      cases: readonly string[];
+      defaultCase: string;
+      resolveCaseKey: (item: TCurrentJson) => string | Promise<string>;
+      branches: Readonly<Record<string, RouteBranchCallback<TCurrentJson, TBranchJson> | undefined>>;
+    }>,
+  ): WorkflowChain<TBranchJson>;
+  switch<TBranchJson>(
+    name: string,
+    cfg: Readonly<{
+      cases: readonly string[];
+      defaultCase: string;
+      resolveCaseKey: (item: TCurrentJson) => string | Promise<string>;
+      branches: Readonly<Record<string, RouteBranchCallback<TCurrentJson, TBranchJson> | undefined>>;
+    }>,
+    id?: string,
+  ): WorkflowChain<TBranchJson>;
+  switch<TBranchJson>(
+    nameOrCfg:
+      | string
+      | Readonly<{
+          cases: readonly string[];
+          defaultCase: string;
+          resolveCaseKey: (item: TCurrentJson) => string | Promise<string>;
+          branches: Readonly<Record<string, RouteBranchCallback<TCurrentJson, TBranchJson> | undefined>>;
+        }>,
+    cfgOrUndefined?: Readonly<{
+      cases: readonly string[];
+      defaultCase: string;
+      resolveCaseKey: (item: TCurrentJson) => string | Promise<string>;
+      branches: Readonly<Record<string, RouteBranchCallback<TCurrentJson, TBranchJson> | undefined>>;
+    }>,
+    id?: string,
+  ): WorkflowChain<TBranchJson> {
+    const name = typeof nameOrCfg === "string" ? nameOrCfg : "Switch";
+    const cfg = (typeof nameOrCfg === "string" ? cfgOrUndefined : nameOrCfg)!;
+    const switched = this.then(
+      new Switch<TCurrentJson>(
+        name,
+        {
+          cases: cfg.cases,
+          defaultCase: cfg.defaultCase,
+          resolveCaseKey: (item) => cfg.resolveCaseKey(item.json as TCurrentJson),
+        },
+        id,
+      ),
+    ) as WorkflowChain<TCurrentJson>;
+    return switched.route(cfg.branches);
+  }
+
   agent<TOutputSchema extends z.ZodTypeAny>(
     options: WorkflowAgentOptions<TCurrentJson, TOutputSchema>,
   ): WorkflowChain<z.output<TOutputSchema>>;

package/src/workflowBuilder.types.ts

@@ -1,9 +1,6 @@
 import type { WorkflowId } from "@codemation/core";
 import { WorkflowBuilder } from "@codemation/core";
-import { Merge } from "./nodes/merge";
 
 export function createWorkflowBuilder(meta: Readonly<{ id: WorkflowId; name: string }>): WorkflowBuilder {
-  return new WorkflowBuilder(meta, {
-    makeMergeNode: (name) => new Merge(name, { mode: "passThrough", prefer: ["true", "false"] }),
-  });
+  return new WorkflowBuilder(meta);
 }