@codemation/core-nodes 0.0.25 → 0.1.0

package/dist/index.d.ts

@@ -14,6 +14,38 @@ import { ZodType, input, output, z } from "zod";
  */
 type CanvasIconName = string;
 //#endregion
+//#region ../core/src/contracts/emitPorts.d.ts
+declare const EMIT_PORTS_BRAND: unique symbol;
+type PortsEmission = Readonly<{
+  readonly [EMIT_PORTS_BRAND]: true;
+  readonly ports: Readonly<Partial<Record<OutputPortKey, Items | ReadonlyArray<JsonNonArray>>>>;
+}>;
+//#endregion
+//#region ../core/src/contracts/itemValue.d.ts
+declare const ITEM_VALUE_BRAND: unique symbol;
+type ItemValueResolvedContext = Readonly<{
+  runId: RunId;
+  workflowId: WorkflowId;
+  nodeId: NodeId;
+  activationId: NodeActivationId;
+  data: RunDataSnapshot;
+}>;
+/**
+ * Context aligned with former {@link ItemInputMapperContext} — use **`data`** to read any completed upstream node.
+ */
+type ItemValueContext = ItemValueResolvedContext;
+type ItemValueArgs<TItemJson = unknown> = Readonly<{
+  item: Item<TItemJson>;
+  itemIndex: number;
+  items: Items<TItemJson>;
+  ctx: ItemValueContext;
+}>;
+type ItemValueCallback<T, TItemJson = unknown> = (args: ItemValueArgs<TItemJson>) => T | Promise<T>;
+type ItemValue<T, TItemJson = unknown> = Readonly<{
+  readonly [ITEM_VALUE_BRAND]: true;
+  readonly fn: ItemValueCallback<T, TItemJson>;
+}>;
+//#endregion
 //#region ../core/src/contracts/retryPolicySpec.types.d.ts
 /**
  * In-process retry policy for runnable nodes. Serialized configs use the same
@@ -43,7 +75,6 @@ interface ExponentialRetryPolicySpec {
 }
 //#endregion
 //#region ../core/src/contracts/runTypes.d.ts
-
 type NodeInputsByPort = Readonly<Record<InputPortKey, Items>>;
 type NodeExecutionStatus = "pending" | "queued" | "running" | "completed" | "failed" | "skipped";
 interface NodeExecutionError {
@@ -115,17 +146,17 @@ interface TriggerInstanceId {
 }
 //#endregion
 //#region ../core/src/workflow/dsl/workflowBuilderTypes.d.ts
-type AnyRunnableNodeConfig = RunnableNodeConfig<any, any, any>;
+type AnyRunnableNodeConfig = RunnableNodeConfig<any, any>;
 type AnyTriggerNodeConfig = TriggerNodeConfig<any>;
-type ValidStepSequence<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TSteps extends readonly [] ? readonly [] : TSteps extends readonly [infer TFirst, ...infer TRest] ? TFirst extends RunnableNodeConfig<infer _TIn, infer TNextJson, TCurrentJson> ? TRest extends ReadonlyArray<AnyRunnableNodeConfig> ? readonly [TFirst, ...ValidStepSequence<TNextJson, TRest>] : never : never : TSteps;
-type StepSequenceOutput<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined> = TSteps extends ReadonlyArray<AnyRunnableNodeConfig> ? TSteps extends readonly [] ? TCurrentJson : TSteps extends readonly [infer TFirst, ...infer TRest] ? TFirst extends RunnableNodeConfig<infer _TIn, infer TNextJson, TCurrentJson> ? TRest extends ReadonlyArray<AnyRunnableNodeConfig> ? StepSequenceOutput<TNextJson, TRest> : never : never : TCurrentJson : TCurrentJson;
+type ValidStepSequence<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TSteps extends readonly [] ? readonly [] : TSteps extends readonly [infer TFirst, ...infer TRest] ? TFirst extends RunnableNodeConfig<TCurrentJson, infer TNextJson> ? TRest extends ReadonlyArray<AnyRunnableNodeConfig> ? readonly [TFirst, ...ValidStepSequence<TNextJson, TRest>] : never : never : TSteps;
+type StepSequenceOutput<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined> = TSteps extends ReadonlyArray<AnyRunnableNodeConfig> ? TSteps extends readonly [] ? TCurrentJson : TSteps extends readonly [infer TFirst, ...infer TRest] ? TFirst extends RunnableNodeConfig<TCurrentJson, infer TNextJson> ? TRest extends ReadonlyArray<AnyRunnableNodeConfig> ? StepSequenceOutput<TNextJson, TRest> : never : never : TCurrentJson : TCurrentJson;
 type TypesMatch<TLeft, TRight> = [TLeft] extends [TRight] ? ([TRight] extends [TLeft] ? true : false) : false;
 type BranchOutputGuard<TCurrentJson, TTrueSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined, TFalseSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined> = TypesMatch<StepSequenceOutput<TCurrentJson, TTrueSteps>, StepSequenceOutput<TCurrentJson, TFalseSteps>> extends true ? unknown : never;
 type BranchStepsArg<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TSteps & ValidStepSequence<TCurrentJson, TSteps>;
-type BranchMoreArgs<TCurrentJson, TFirstStep extends RunnableNodeConfig<any, any, TCurrentJson>, TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TRestSteps & ValidStepSequence<RunnableNodeOutputJson<TFirstStep>, TRestSteps>;
+type BranchMoreArgs<TCurrentJson, TFirstStep extends RunnableNodeConfig<TCurrentJson, any>, TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TRestSteps & ValidStepSequence<RunnableNodeOutputJson<TFirstStep>, TRestSteps>;
 type BooleanWhenOverloads<TCurrentJson, TReturn> = {
   <TSteps extends ReadonlyArray<AnyRunnableNodeConfig>>(branch: boolean, steps: BranchStepsArg<TCurrentJson, TSteps>): TReturn;
-  <TFirstStep extends RunnableNodeConfig<any, any, TCurrentJson>, TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>>(branch: boolean, step: TFirstStep, ...more: BranchMoreArgs<TCurrentJson, TFirstStep, TRestSteps>): TReturn;
+  <TFirstStep extends RunnableNodeConfig<TCurrentJson, any>, TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>>(branch: boolean, step: TFirstStep, ...more: BranchMoreArgs<TCurrentJson, TFirstStep, TRestSteps>): TReturn;
 };
 //#endregion
 //#region ../core/src/workflow/dsl/WhenBuilder.d.ts
@@ -140,6 +171,11 @@ declare class WhenBuilder<TCurrentJson> {
 }
 //#endregion
 //#region ../core/src/workflow/dsl/ChainCursorResolver.d.ts
+type ChainCursorEndpoint = Readonly<{
+  node: NodeRef;
+  output: OutputPortKey;
+  inputPortHint?: InputPortKey;
+}>;
 type ChainCursorWhenOverloads<TCurrentJson> = BooleanWhenOverloads<TCurrentJson, WhenBuilder<TCurrentJson>> & {
   <TTrueSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined, TFalseSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined>(branches: Readonly<{
     true?: TTrueSteps extends ReadonlyArray<AnyRunnableNodeConfig> ? BranchStepsArg<TCurrentJson, TTrueSteps> : never;
@@ -148,12 +184,14 @@ type ChainCursorWhenOverloads<TCurrentJson> = BooleanWhenOverloads<TCurrentJson,
 };
 declare class ChainCursor<TCurrentJson> {
   private readonly wf;
-  private readonly cursor;
-  private readonly cursorOutput;
-  constructor(wf: WorkflowBuilder, cursor: NodeRef, cursorOutput: OutputPortKey);
-  then<TInputJson$1, TOutputJson$1, TConfig extends RunnableNodeConfig<TInputJson$1, TOutputJson$1, TCurrentJson>>(config: TConfig): ChainCursor<RunnableNodeOutputJson<TConfig>>;
+  private readonly endpoints;
+  constructor(wf: WorkflowBuilder, endpoints: ReadonlyArray<ChainCursorEndpoint>);
+  then<TOutputJson$1, TConfig extends RunnableNodeConfig<TCurrentJson, TOutputJson$1>>(config: TConfig): ChainCursor<RunnableNodeOutputJson<TConfig>>;
+  thenIntoInputHints<TOutputJson$1, TConfig extends RunnableNodeConfig<any, TOutputJson$1>>(config: TConfig): ChainCursor<RunnableNodeOutputJson<TConfig>>;
   readonly when: ChainCursorWhenOverloads<TCurrentJson>;
+  route<TNextJson$1>(branches: Readonly<Record<OutputPortKey, (branch: ChainCursor<TCurrentJson>) => ChainCursor<TNextJson$1> | undefined>>): ChainCursor<TNextJson$1>;
   build(): WorkflowDefinition;
+  private resolveSharedInputPortHint;
 }
 //#endregion
 //#region ../core/src/workflow/dsl/WorkflowBuilder.d.ts
@@ -166,9 +204,7 @@ declare class WorkflowBuilder {
   constructor(meta: {
     id: WorkflowId;
     name: string;
-  }, options?: Readonly<{
-    makeMergeNode?: (name: string) => AnyRunnableNodeConfig;
-  }> | undefined);
+  }, options?: Readonly<Record<string, never>> | undefined);
   private add;
   private connect;
   trigger<TConfig extends AnyTriggerNodeConfig>(config: TConfig): ChainCursor<TriggerNodeOutputJson<TConfig>>;
@@ -274,31 +310,39 @@ interface TriggerTestItemsContext<TConfig extends TriggerNodeConfig<any, any> =
 interface TriggerCleanupHandle {
   stop(): Promise<void> | void;
 }
-interface Node<TConfig extends NodeConfigBase = NodeConfigBase> {
-  kind: "node";
-  outputPorts: ReadonlyArray<OutputPortKey>;
-  execute(items: Items, ctx: NodeExecutionContext<TConfig>): Promise<NodeOutputs>;
-}
 /**
- * Single-input runnable node with per-item execution on `main` only (1→1 default).
- * Engine applies {@link RunnableNodeConfig.mapInput} (if any) + `inputSchema.parse` before `executeOne`.
+ * Per-item runnable node: return JSON, an array to fan-out on `main`, or {@link emitPorts} for multi-port emission.
+ * Engine applies `inputSchema.parse(item.json)` and passes the result as `args.input` (wire `item.json` is unchanged).
  */
-interface ItemNode<TConfig extends NodeConfigBase = NodeConfigBase, TInputJson$1 = unknown, TOutputJson$1 = unknown> {
+interface RunnableNodeExecuteArgs<TConfig extends RunnableNodeConfig<any, any> = RunnableNodeConfig<any, any>, TInputJson$1 = unknown> {
+  readonly input: TInputJson$1;
+  readonly item: Item;
+  readonly itemIndex: number;
+  readonly items: Items;
+  readonly ctx: NodeExecutionContext<TConfig>;
+}
+interface RunnableNode<TConfig extends RunnableNodeConfig<any, any> = RunnableNodeConfig<any, any>, TInputJson$1 = unknown, _TOutputJson = unknown> {
   readonly kind: "node";
-  readonly outputPorts: readonly ["main"];
+  /**
+   * Declared output ports (e.g. `["main"]`).
+   *
+   * Prefer describing dynamic router ports (Switch) and fixed multi-ports (If true/false)
+   * via {@link NodeConfigBase.declaredOutputPorts}. Engine defaults to `["main"]` when omitted.
+   */
+  readonly outputPorts?: ReadonlyArray<OutputPortKey>;
   /** When omitted, engine uses {@link RunnableNodeConfig.inputSchema} or `z.unknown()`. */
   readonly inputSchema?: ZodType<TInputJson$1>;
-  executeOne(args: Readonly<{
-    input: TInputJson$1;
-    item: Item;
-    itemIndex: number;
-    items: Items;
-    ctx: NodeExecutionContext<TConfig>;
-  }>): Promise<TOutputJson$1> | TOutputJson$1;
+  execute(args: RunnableNodeExecuteArgs<TConfig, TInputJson$1>): Promise<unknown> | unknown;
 }
 interface MultiInputNode<TConfig extends NodeConfigBase = NodeConfigBase> {
   kind: "node";
-  outputPorts: ReadonlyArray<OutputPortKey>;
+  /**
+   * Declared output ports (typically `["main"]`).
+   *
+   * Prefer describing ports for authoring/canvas via {@link NodeConfigBase.declaredOutputPorts}.
+   * Engine defaults to `["main"]` when omitted.
+   */
+  outputPorts?: ReadonlyArray<OutputPortKey>;
   executeMulti(inputsByPort: NodeInputsByPort, ctx: NodeExecutionContext<TConfig>): Promise<NodeOutputs>;
 }
 type TriggerSetupStateFor<TConfig extends TriggerNodeConfig<any, any>> = TriggerNodeSetupState<TConfig>;
@@ -325,6 +369,8 @@ interface JsonObject {
 }
 type JsonValue = JsonPrimitive | JsonObject | JsonArray;
 type JsonArray = ReadonlyArray<JsonValue>;
+/** JSON value that is not a top-level array (nested arrays inside objects are allowed). */
+type JsonNonArray = JsonPrimitive | JsonObject;
 interface Edge {
   from: {
     nodeId: NodeId;
@@ -385,65 +431,42 @@ interface NodeConfigBase {
    * main batches skip downstream execution and propagate the empty path.
    */
   readonly continueWhenEmptyOutput?: boolean;
+  /**
+   * Declared I/O port names for canvas authoring (unioned with ports inferred from edges).
+   * Use for dynamic routers (Switch) and future error ports.
+   */
+  readonly declaredOutputPorts?: ReadonlyArray<OutputPortKey>;
+  readonly declaredInputPorts?: ReadonlyArray<InputPortKey>;
   getCredentialRequirements?(): ReadonlyArray<CredentialRequirement>;
 }
 declare const runnableNodeInputType: unique symbol;
 declare const runnableNodeOutputType: unique symbol;
-/** Phantom: JSON shape on the wire from upstream before {@link RunnableNodeConfig.mapInput}. */
-declare const runnableNodeWireType: unique symbol;
 declare const triggerNodeOutputType: unique symbol;
+type LineageCarryPolicy = "emitOnly" | "carryThrough";
 /**
- * Read-only execution slice passed to {@link RunnableNodeConfig.mapInput} (aligned with the engine’s
- * node execution context for `runId`, `data`, etc.). Use **`ctx.data`** to read **any completed** upstream
- * node’s outputs in this run (e.g. `ctx.data.getOutputItems(nodeIdA, "main")` while mapping at D), not only
- * the immediate predecessor’s {@link ItemInputMapperArgs.item}.
- */
-interface ItemInputMapperContext {
-  readonly runId: RunId;
-  readonly workflowId: WorkflowId;
-  /** Node whose activation is being prepared (the consumer of `mapInput`). */
-  readonly nodeId: NodeId;
-  readonly activationId: NodeActivationId;
-  readonly parent?: ParentExecutionRef;
-  readonly data: RunDataSnapshot;
-}
-/**
- * Arguments for optional per-item input mapping applied by the engine before Zod validation.
- */
-interface ItemInputMapperArgs<TWireJson$1 = unknown> {
-  readonly item: Item<TWireJson$1>;
-  readonly itemIndex: number;
-  readonly items: Items<TWireJson$1>;
-  readonly ctx: ItemInputMapperContext;
-}
-/**
- * Per-item mapper before Zod validation. Uses a **bivariant** method signature so concrete
- * `ItemInputMapper<SpecificWire, TIn>` remains assignable to `RunnableNodeConfig` fields typed as
- * `ItemInputMapper<unknown, unknown>` (same pattern as React-style callbacks).
+ * Runnable node: **`TInputJson`** is what **`inputSchema`** validates on **`item.json`** (the wire payload).
+ * **`TOutputJson`** is emitted `item.json` on outputs.
  */
-type ItemInputMapper<TWireJson$1 = unknown, TInputJson$1 = unknown> = {
-  bivarianceHack(args: ItemInputMapperArgs<TWireJson$1>): TInputJson$1 | Promise<TInputJson$1>;
-}["bivarianceHack"];
-/**
- * Runnable node: **`TInputJson`** is the payload after `mapInput` (if any) + Zod validation — what {@link ItemNode}
- * `executeOne` receives. **`TOutputJson`** is emitted `item.json` on outputs. **`TWireJson`** is `item.json` from
- * upstream **before** `mapInput`; it defaults to **`TInputJson`** when there is no mapper or wire differs from execute input.
- */
-interface RunnableNodeConfig<TInputJson$1 = unknown, TOutputJson$1 = unknown, TWireJson$1 = TInputJson$1> extends NodeConfigBase {
+interface RunnableNodeConfig<TInputJson$1 = unknown, TOutputJson$1 = unknown> extends NodeConfigBase {
   readonly kind: "node";
   readonly [runnableNodeInputType]?: TInputJson$1;
   readonly [runnableNodeOutputType]?: TOutputJson$1;
-  readonly [runnableNodeWireType]?: TWireJson$1;
   /**
-   * Optional Zod input contract for {@link ItemNode} when not set on the node class.
+   * Optional Zod input contract for {@link RunnableNode} when not set on the node class.
    * Resolution order: node instance `inputSchema`, then config `inputSchema`, then `z.unknown()`.
    */
   readonly inputSchema?: ZodType<TInputJson$1>;
   /**
-   * Optional per-item mapper: engine applies it before validating against the node’s `inputSchema`.
-   * When omitted, the engine validates `item.json` directly.
+   * Overrides default lineage propagation for `execute` outputs (binary/meta/paired).
+   * Routers with multiple {@link RunnableNode#outputPorts} default to **`carryThrough`**; others default to **`emitOnly`**.
+   */
+  readonly lineageCarry?: LineageCarryPolicy;
+  /**
+   * When an activation receives **zero** input items, the engine normally runs `execute` zero times.
+   * Set to **`runOnce`** to run `execute` once with an empty `items` batch (and a synthetic wire item for schema parsing).
+   * Used by batch-style callback nodes (built-in `Callback`) so `callback([], ctx)` still runs.
    */
-  readonly mapInput?: ItemInputMapper<TWireJson$1, TInputJson$1>;
+  readonly emptyBatchExecution?: "skip" | "runOnce";
 }
 declare const triggerNodeSetupStateType: unique symbol;
 interface TriggerNodeConfig<TOutputJson$1 = unknown, TSetupState$1 extends JsonValue | undefined = undefined> extends NodeConfigBase {
@@ -451,8 +474,8 @@ interface TriggerNodeConfig<TOutputJson$1 = unknown, TSetupState$1 extends JsonV
   readonly [triggerNodeOutputType]?: TOutputJson$1;
   readonly [triggerNodeSetupStateType]?: TSetupState$1;
 }
-type RunnableNodeInputJson<TConfig extends RunnableNodeConfig<any, any, any>> = TConfig extends RunnableNodeConfig<infer TInputJson, any, any> ? TInputJson : never;
-type RunnableNodeOutputJson<TConfig extends RunnableNodeConfig<any, any, any>> = TConfig extends RunnableNodeConfig<any, infer TOutputJson, any> ? TOutputJson : never;
+type RunnableNodeInputJson<TConfig extends RunnableNodeConfig<any, any>> = TConfig extends RunnableNodeConfig<infer TInputJson, any> ? TInputJson : never;
+type RunnableNodeOutputJson<TConfig extends RunnableNodeConfig<any, any>> = TConfig extends RunnableNodeConfig<any, infer TOutputJson> ? TOutputJson : never;
 type TriggerNodeOutputJson<TConfig extends TriggerNodeConfig<any, any>> = TConfig extends TriggerNodeConfig<infer TOutputJson, any> ? TOutputJson : never;
 type TriggerNodeSetupState<TConfig extends TriggerNodeConfig<any, any>> = TConfig extends TriggerNodeConfig<any, infer TSetupState> ? TSetupState : never;
 interface NodeDefinition {
@@ -692,19 +715,19 @@ type DefinedNodeCredentialBinding = ResolvableCredentialType | Readonly<{
   readonly helpUrl?: string;
 }>;
 type DefinedNodeCredentialBindings = Readonly<Record<string, DefinedNodeCredentialBinding>>;
-interface DefinedNode<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1, TOutputJson$1, _TBindings extends DefinedNodeCredentialBindings | undefined = undefined, TWireJson$1 = TInputJson$1> {
+interface DefinedNode<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1, TOutputJson$1, _TBindings extends DefinedNodeCredentialBindings | undefined = undefined> {
   readonly kind: "defined-node";
   readonly key: TKey$1;
   readonly title: string;
   readonly description?: string;
-  create(config: TConfig, name?: string, id?: string): RunnableNodeConfig<TInputJson$1, TOutputJson$1, TWireJson$1>;
+  create(config: TConfig, name?: string, id?: string): RunnableNodeConfig<TInputJson$1, TOutputJson$1>;
   register(context: {
     registerNode<TValue>(token: TypeToken<TValue>, implementation?: TypeToken<TValue>): void;
   }): void;
 }
 //#endregion
 //#region ../core/src/ai/NodeBackedToolConfig.d.ts
-declare class NodeBackedToolConfig<TNodeConfig extends RunnableNodeConfig<any, any, any>, TInputSchema extends ZodSchemaAny, TOutputSchema extends ZodSchemaAny> implements ToolConfig {
+declare class NodeBackedToolConfig<TNodeConfig extends RunnableNodeConfig<any, any>, TInputSchema extends ZodSchemaAny, TOutputSchema extends ZodSchemaAny> implements ToolConfig {
   readonly name: string;
   readonly node: TNodeConfig;
   readonly type: TypeToken<unknown>;
@@ -768,7 +791,7 @@ type AgentMessageLine<TInputJson$1 = unknown> = AgentMessageDto | AgentMessageTe
  * Message list for an agent. Prefer a **plain array** of `{ role, content }` (optionally with function `content` for templates).
  * Use the object form only when you need `buildMessages` to append messages after optional `prompt` lines.
  */
-type AgentMessageConfig<TInputJson$1 = unknown> = ReadonlyArray<AgentMessageLine<TInputJson$1>> | {
+type AgentMessageConfig<TInputJson$1 = unknown> = ItemValue<ReadonlyArray<AgentMessageLine<TInputJson$1>>, TInputJson$1> | ReadonlyArray<AgentMessageLine<TInputJson$1>> | {
   readonly prompt?: ReadonlyArray<AgentMessageLine<TInputJson$1>>;
   readonly buildMessages?: (args: AgentMessageBuildArgs<TInputJson$1>) => ReadonlyArray<AgentMessageDto>;
 };
@@ -803,7 +826,7 @@ interface ChatModelFactory<TConfig extends ChatModelConfig = ChatModelConfig> {
     ctx: NodeExecutionContext<any>;
   }>): Promise<LangChainChatModelLike> | LangChainChatModelLike;
 }
-type NodeBackedToolInputMapperArgs<TNodeConfig extends RunnableNodeConfig<any, any, any>, TToolInput = unknown> = Readonly<{
+type NodeBackedToolInputMapperArgs<TNodeConfig extends RunnableNodeConfig<any, any>, TToolInput = unknown> = Readonly<{
   input: TToolInput;
   item: Item;
   itemIndex: number;
@@ -811,7 +834,7 @@ type NodeBackedToolInputMapperArgs<TNodeConfig extends RunnableNodeConfig<any, a
   ctx: NodeExecutionContext<any>;
   node: TNodeConfig;
 }>;
-type NodeBackedToolOutputMapperArgs<TNodeConfig extends RunnableNodeConfig<any, any, any>, TToolInput = unknown> = Readonly<{
+type NodeBackedToolOutputMapperArgs<TNodeConfig extends RunnableNodeConfig<any, any>, TToolInput = unknown> = Readonly<{
   input: TToolInput;
   item: Item;
   itemIndex: number;
@@ -820,9 +843,9 @@ type NodeBackedToolOutputMapperArgs<TNodeConfig extends RunnableNodeConfig<any,
   node: TNodeConfig;
   outputs: NodeOutputs;
 }>;
-type NodeBackedToolInputMapper<TNodeConfig extends RunnableNodeConfig<any, any, any>, TToolInput = unknown> = (args: NodeBackedToolInputMapperArgs<TNodeConfig, TToolInput>) => Item<RunnableNodeInputJson<TNodeConfig>> | RunnableNodeInputJson<TNodeConfig>;
-type NodeBackedToolOutputMapper<TNodeConfig extends RunnableNodeConfig<any, any, any>, TToolInput = unknown, TToolOutput = unknown> = (args: NodeBackedToolOutputMapperArgs<TNodeConfig, TToolInput>) => TToolOutput;
-type NodeBackedToolConfigOptions<TNodeConfig extends RunnableNodeConfig<any, any, any>, TInputSchema extends ZodSchemaAny, TOutputSchema extends ZodSchemaAny> = Readonly<{
+type NodeBackedToolInputMapper<TNodeConfig extends RunnableNodeConfig<any, any>, TToolInput = unknown> = (args: NodeBackedToolInputMapperArgs<TNodeConfig, TToolInput>) => Item<RunnableNodeInputJson<TNodeConfig>> | RunnableNodeInputJson<TNodeConfig>;
+type NodeBackedToolOutputMapper<TNodeConfig extends RunnableNodeConfig<any, any>, TToolInput = unknown, TToolOutput = unknown> = (args: NodeBackedToolOutputMapperArgs<TNodeConfig, TToolInput>) => TToolOutput;
+type NodeBackedToolConfigOptions<TNodeConfig extends RunnableNodeConfig<any, any>, TInputSchema extends ZodSchemaAny, TOutputSchema extends ZodSchemaAny> = Readonly<{
   description?: string;
   presentation?: AgentCanvasPresentation;
   inputSchema: TInputSchema;
@@ -830,13 +853,35 @@ type NodeBackedToolConfigOptions<TNodeConfig extends RunnableNodeConfig<any, any
   mapInput?: NodeBackedToolInputMapper<TNodeConfig, input<TInputSchema>>;
   mapOutput?: NodeBackedToolOutputMapper<TNodeConfig, input<TInputSchema>, output<TOutputSchema>>;
 }>;
-interface AgentNodeConfig<TInputJson$1 = unknown, TOutputJson$1 = unknown, TWireJson$1 = TInputJson$1> extends RunnableNodeConfig<TInputJson$1, TOutputJson$1, TWireJson$1> {
+interface AgentNodeConfig<TInputJson$1 = unknown, TOutputJson$1 = unknown> extends RunnableNodeConfig<TInputJson$1, TOutputJson$1> {
   readonly messages: AgentMessageConfig<TInputJson$1>;
   readonly chatModel: ChatModelConfig;
   readonly tools?: ReadonlyArray<ToolConfig>;
   readonly guardrails?: AgentGuardrailConfig;
 }
 //#endregion
+//#region ../core/src/execution/ItemValueResolver.d.ts
+/**
+ * Resolves {@link import("../contracts/itemValue").ItemValue} leaves on runnable config before {@link RunnableNode.execute}.
+ */
+declare class ItemValueResolver {
+  resolveConfigForItem<TConfig extends RunnableNodeConfig<any, any>>(ctx: NodeExecutionContext<TConfig>, item: Item, itemIndex: number, items: ReadonlyArray<Item>): Promise<NodeExecutionContext<TConfig>>;
+}
+//#endregion
+//#region ../core/src/execution/NodeOutputNormalizer.d.ts
+declare class NodeOutputNormalizer {
+  normalizeExecuteResult(args: Readonly<{
+    baseItem: Item;
+    raw: unknown;
+    carry: LineageCarryPolicy;
+  }>): NodeOutputs;
+  private arrayFanOutToMain;
+  private emitPortsToOutputs;
+  private normalizePortPayload;
+  private isItemLike;
+  private applyLineage;
+}
+//#endregion
 //#region src/chatModels/openAiChatModelConfig.d.ts
 declare class OpenAIChatModelConfig implements ChatModelConfig {
   readonly name: string;
@@ -908,7 +953,7 @@ declare class AgentToolCallPortMap {
 }
 //#endregion
 //#region src/nodes/AIAgentConfig.d.ts
-interface AIAgentOptions<TInputJson$1 = unknown, _TOutputJson = unknown, TWireJson$1 = TInputJson$1> {
+interface AIAgentOptions<TInputJson$1 = unknown, _TOutputJson = unknown> {
   readonly name: string;
   readonly messages: AgentMessageConfig<TInputJson$1>;
   readonly chatModel: ChatModelConfig;
@@ -916,16 +961,14 @@ interface AIAgentOptions<TInputJson$1 = unknown, _TOutputJson = unknown, TWireJs
   readonly id?: string;
   readonly retryPolicy?: RetryPolicySpec;
   readonly guardrails?: AgentGuardrailConfig;
-  /** Engine applies with {@link RunnableNodeConfig.inputSchema} before {@link AIAgentNode.executeOne}. */
+  /** Engine applies with {@link RunnableNodeConfig.inputSchema} before {@link AIAgentNode.execute}. */
   readonly inputSchema?: ZodType<TInputJson$1>;
-  /** Per-item mapper before validation; use with {@link inputSchema} so persisted run inputs show the prompt payload. */
-  readonly mapInput?: ItemInputMapper<TWireJson$1, TInputJson$1>;
 }
 /**
  * AI agent: credential bindings are keyed to connection-owned LLM/tool node ids (ConnectionNodeIdFactory),
  * not to the agent workflow node id.
  */
-declare class AIAgent<TInputJson$1 = unknown, TOutputJson$1 = unknown, TWireJson$1 = TInputJson$1> implements RunnableNodeConfig<TInputJson$1, TOutputJson$1, TWireJson$1>, AgentNodeConfig<TInputJson$1, TOutputJson$1, TWireJson$1> {
+declare class AIAgent<TInputJson$1 = unknown, TOutputJson$1 = unknown> implements RunnableNodeConfig<TInputJson$1, TOutputJson$1>, AgentNodeConfig<TInputJson$1, TOutputJson$1> {
   readonly kind: "node";
   readonly type: TypeToken<unknown>;
   readonly execution: {
@@ -940,8 +983,7 @@ declare class AIAgent<TInputJson$1 = unknown, TOutputJson$1 = unknown, TWireJson
   readonly retryPolicy: RetryPolicySpec;
   readonly guardrails?: AgentGuardrailConfig;
   readonly inputSchema?: ZodType<TInputJson$1>;
-  readonly mapInput?: ItemInputMapper<TWireJson$1, TInputJson$1>;
-  constructor(options: AIAgentOptions<TInputJson$1, TOutputJson$1, TWireJson$1>);
+  constructor(options: AIAgentOptions<TInputJson$1, TOutputJson$1>);
 }
 //#endregion
 //#region src/nodes/ConnectionCredentialExecutionContextFactory.d.ts
@@ -1014,36 +1056,33 @@ declare class AIAgentExecutionHelpersFactory {
 //#region src/nodes/NodeBackedToolRuntime.d.ts
 declare class NodeBackedToolRuntime {
   private readonly nodeResolver;
-  constructor(nodeResolver: NodeResolver);
+  private readonly itemValueResolver;
+  private readonly outputNormalizer;
+  constructor(nodeResolver: NodeResolver, itemValueResolver: ItemValueResolver, outputNormalizer: NodeOutputNormalizer);
   execute(config: NodeBackedToolConfig<any, ZodSchemaAny, ZodSchemaAny>, args: ToolExecuteArgs): Promise<unknown>;
   private executeResolvedNode;
-  private isNode;
+  private isRunnableNode;
   private isMultiInputNode;
 }
 //#endregion
 //#region src/nodes/AIAgentNode.d.ts
-declare class AIAgentNode implements ItemNode<AIAgent<any, any>, unknown, unknown> {
+declare class AIAgentNode implements RunnableNode<AIAgent<any, any>> {
   private readonly nodeResolver;
   private readonly nodeBackedToolRuntime;
   private readonly executionHelpers;
   kind: "node";
   outputPorts: readonly ["main"];
   /**
-   * Engine applies {@link RunnableNodeConfig.mapInput} + parse before {@link #executeOne}. Prefer modeling
-   * prompts as {@code { messages: [{ role, content }, ...] }} so persisted inputs are visible in the UI.
+   * Engine validates {@link RunnableNodeConfig.inputSchema} (Zod) on {@code item.json} before enqueue, then resolves
+   * per-item **`itemValue`** leaves on config before {@link #execute}. Prefer modeling prompts as
+   * {@code { messages: [{ role, content }, ...] }} (on input or config) so persisted inputs are visible in the UI.
    */
   readonly inputSchema: z.ZodUnknown;
   private readonly connectionCredentialExecutionContextFactory;
   /** One resolved model/tools bundle per activation context (same ctx across items in a batch). */
   private readonly preparedByExecutionContext;
   constructor(nodeResolver: NodeResolver, credentialSessions: CredentialSessionService, nodeBackedToolRuntime: NodeBackedToolRuntime, executionHelpers: AIAgentExecutionHelpersFactory);
-  executeOne(args: {
-    input: unknown;
-    item: Item;
-    itemIndex: number;
-    items: Items;
-    ctx: NodeExecutionContext<AIAgent<any, any>>;
-  }): Promise<unknown>;
+  execute(args: RunnableNodeExecuteArgs<AIAgent<any, any>>): Promise<unknown>;
   private getOrPrepareExecution;
   /**
    * Resolves the chat model and tools once per activation, then reuses for every item in the batch.
@@ -1085,38 +1124,48 @@ declare class AIAgentNode implements ItemNode<AIAgent<any, any>, unknown, unknow
 }
 //#endregion
 //#region src/nodes/CallbackNode.d.ts
-declare class CallbackNode implements Node<Callback<any, any>> {
+declare class CallbackNode implements RunnableNode<Callback<any, any>> {
   kind: "node";
   outputPorts: readonly ["main"];
-  execute(items: Items, ctx: NodeExecutionContext<Callback<any, any>>): Promise<NodeOutputs>;
+  execute(args: RunnableNodeExecuteArgs<Callback<any, any>>): Promise<unknown>;
 }
 //#endregion
 //#region src/nodes/CallbackResultNormalizerFactory.d.ts
 declare class CallbackResultNormalizer {
-  static toNodeOutputs(result: Items | void, items: Items): NodeOutputs;
+  static toPortsEmission(result: Items | PortsEmission | void, items: Items): PortsEmission;
 }
 //#endregion
 //#region src/nodes/CallbackNodeFactory.d.ts
-type CallbackHandler<TInputJson$1 = unknown, TOutputJson$1 = TInputJson$1, TConfig extends Callback<TInputJson$1, TOutputJson$1> = Callback<TInputJson$1, TOutputJson$1>> = (items: Items<TInputJson$1>, ctx: NodeExecutionContext<TConfig>) => Promise<Items<TOutputJson$1> | void> | Items<TOutputJson$1> | void;
+type CallbackHandler<TInputJson$1 = unknown, TOutputJson$1 = TInputJson$1, TConfig extends Callback<TInputJson$1, TOutputJson$1> = Callback<TInputJson$1, TOutputJson$1>> = (items: Items<TInputJson$1>, ctx: NodeExecutionContext<TConfig>) => Promise<Items<TOutputJson$1> | PortsEmission | void> | Items<TOutputJson$1> | PortsEmission | void;
+type CallbackOptions = Readonly<{
+  id?: string;
+  retryPolicy?: RetryPolicySpec;
+  nodeErrorHandler?: NodeErrorHandlerSpec;
+  declaredOutputPorts?: ReadonlyArray<string>;
+}>;
 declare class Callback<TInputJson$1 = unknown, TOutputJson$1 = TInputJson$1> implements RunnableNodeConfig<TInputJson$1, TOutputJson$1> {
   readonly name: string;
   readonly callback: CallbackHandler<TInputJson$1, TOutputJson$1>;
-  readonly id?: string | undefined;
   readonly kind: "node";
   readonly type: TypeToken<unknown>;
   readonly execution: {
     readonly hint: "local";
   };
   readonly icon: "lucide:braces";
-  constructor(name?: string, callback?: CallbackHandler<TInputJson$1, TOutputJson$1>, id?: string | undefined);
+  readonly emptyBatchExecution: "runOnce";
+  readonly id?: string;
+  readonly retryPolicy?: RetryPolicySpec;
+  readonly nodeErrorHandler?: NodeErrorHandlerSpec;
+  readonly declaredOutputPorts?: ReadonlyArray<string>;
+  constructor(name?: string, callback?: CallbackHandler<TInputJson$1, TOutputJson$1>, idOrOptions?: string | CallbackOptions, options?: CallbackOptions);
   private static defaultCallback;
 }
 //#endregion
 //#region src/nodes/HttpRequestNodeFactory.d.ts
-declare class HttpRequestNode implements Node<HttpRequest<any, any>> {
+declare class HttpRequestNode implements RunnableNode<HttpRequest<any, any>> {
   readonly kind: "node";
   readonly outputPorts: readonly ["main"];
-  execute(items: Items, ctx: NodeExecutionContext<HttpRequest<any, any>>): Promise<NodeOutputs>;
+  execute(args: RunnableNodeExecuteArgs<HttpRequest<any, any>>): Promise<unknown>;
   private executeItem;
   private resolveUrl;
   private asRecord;
@@ -1172,10 +1221,10 @@ declare class HttpRequest<TInputJson$1 = Readonly<{
 }
 //#endregion
 //#region src/nodes/AggregateNode.d.ts
-declare class AggregateNode implements Node<Aggregate<any, any>> {
+declare class AggregateNode implements RunnableNode<Aggregate<any, any>> {
   kind: "node";
   outputPorts: readonly ["main"];
-  execute(items: Items, ctx: NodeExecutionContext<Aggregate<any, any>>): Promise<NodeOutputs>;
+  execute(args: RunnableNodeExecuteArgs<Aggregate<any, any>>): Promise<unknown>;
 }
 //#endregion
 //#region src/nodes/aggregate.d.ts
@@ -1193,10 +1242,10 @@ declare class Aggregate<TIn = unknown, TOut = unknown> implements RunnableNodeCo
 }
 //#endregion
 //#region src/nodes/FilterNode.d.ts
-declare class FilterNode implements Node<Filter<any>> {
+declare class FilterNode implements RunnableNode<Filter<any>> {
   kind: "node";
   outputPorts: readonly ["main"];
-  execute(items: Items, ctx: NodeExecutionContext<Filter<any>>): Promise<NodeOutputs>;
+  execute(args: RunnableNodeExecuteArgs<Filter<any>>): unknown;
 }
 //#endregion
 //#region src/nodes/filter.d.ts
@@ -1214,10 +1263,9 @@ declare class Filter<TIn = unknown> implements RunnableNodeConfig<TIn, TIn> {
 }
 //#endregion
 //#region src/nodes/IfNode.d.ts
-declare class IfNode implements Node<If<any>> {
+declare class IfNode implements RunnableNode<If<any>> {
   kind: "node";
-  outputPorts: readonly ["true", "false"];
-  execute(items: Items, ctx: NodeExecutionContext<If<any>>): Promise<NodeOutputs>;
+  execute(args: RunnableNodeExecuteArgs<If<any>>): unknown;
 }
 //#endregion
 //#region src/nodes/if.d.ts
@@ -1231,14 +1279,49 @@ declare class If<TInputJson$1 = unknown> implements RunnableNodeConfig<TInputJso
     readonly hint: "local";
   };
   readonly icon: "lucide:split";
+  readonly declaredOutputPorts: readonly ["true", "false"];
   constructor(name: string, predicate: (item: Item<TInputJson$1>, index: number, items: Items<TInputJson$1>, ctx: NodeExecutionContext<If<TInputJson$1>>) => boolean, id?: string | undefined);
 }
 //#endregion
+//#region src/nodes/SwitchNode.d.ts
+/**
+ * Routes each item to exactly one output port. Port names must match workflow edges (see {@link Switch} config).
+ */
+declare class SwitchNode implements RunnableNode<Switch<any>> {
+  kind: "node";
+  execute(args: RunnableNodeExecuteArgs<Switch<any>>): Promise<unknown>;
+}
+//#endregion
+//#region src/nodes/switch.d.ts
+type SwitchCaseKeyResolver<TInputJson$1 = unknown> = (item: Item<TInputJson$1>, index: number, items: Items<TInputJson$1>, ctx: NodeExecutionContext<Switch<TInputJson$1>>) => string | Promise<string>;
+declare class Switch<TInputJson$1 = unknown> implements RunnableNodeConfig<TInputJson$1, TInputJson$1> {
+  readonly name: string;
+  readonly cfg: Readonly<{
+    cases: readonly string[];
+    defaultCase: string;
+    resolveCaseKey: SwitchCaseKeyResolver<TInputJson$1>;
+  }>;
+  readonly id?: string | undefined;
+  readonly kind: "node";
+  readonly type: TypeToken<unknown>;
+  readonly execution: {
+    readonly hint: "local";
+  };
+  readonly icon: "lucide:git-branch-plus";
+  readonly lineageCarry: "carryThrough";
+  readonly declaredOutputPorts: ReadonlyArray<string>;
+  constructor(name: string, cfg: Readonly<{
+    cases: readonly string[];
+    defaultCase: string;
+    resolveCaseKey: SwitchCaseKeyResolver<TInputJson$1>;
+  }>, id?: string | undefined);
+}
+//#endregion
 //#region src/nodes/SplitNode.d.ts
-declare class SplitNode implements Node<Split<any, any>> {
+declare class SplitNode implements RunnableNode<Split<any, any>> {
   kind: "node";
   outputPorts: readonly ["main"];
-  execute(items: Items, ctx: NodeExecutionContext<Split<any, any>>): Promise<NodeOutputs>;
+  execute(args: RunnableNodeExecuteArgs<Split<any, any>>): unknown;
 }
 //#endregion
 //#region src/nodes/split.d.ts
@@ -1293,17 +1376,11 @@ declare class ManualTrigger<TOutputJson$1 = unknown> implements TriggerNodeConfi
 }
 //#endregion
 //#region src/nodes/MapDataNode.d.ts
-declare class MapDataNode implements ItemNode<MapData<any, any>, unknown, unknown> {
+declare class MapDataNode implements RunnableNode<MapData<any, any>> {
   kind: "node";
   outputPorts: readonly ["main"];
   readonly inputSchema: z.ZodUnknown;
-  executeOne(args: {
-    input: unknown;
-    item: Item;
-    itemIndex: number;
-    items: Items;
-    ctx: NodeExecutionContext<MapData<any, any>>;
-  }): Promise<unknown>;
+  execute(args: RunnableNodeExecuteArgs<MapData<any, any>>): Promise<unknown>;
 }
 //#endregion
 //#region src/nodes/mapData.d.ts
@@ -1355,10 +1432,10 @@ declare class Merge<TInputJson$1 = unknown, TOutputJson$1 = TInputJson$1> implem
 }
 //#endregion
 //#region src/nodes/NoOpNode.d.ts
-declare class NoOpNode implements Node<NoOp<any>> {
+declare class NoOpNode implements RunnableNode<NoOp<any>> {
   kind: "node";
   outputPorts: readonly ["main"];
-  execute(items: Items, _ctx: NodeExecutionContext<NoOp<any>>): Promise<NodeOutputs>;
+  execute(args: RunnableNodeExecuteArgs<NoOp<any>>): unknown;
 }
 //#endregion
 //#region src/nodes/noOp.d.ts
@@ -1374,12 +1451,12 @@ declare class NoOp<TItemJson = unknown> implements RunnableNodeConfig<TItemJson,
 }
 //#endregion
 //#region src/nodes/SubWorkflowNode.d.ts
-declare class SubWorkflowNode implements Node<SubWorkflow<any, any>> {
+declare class SubWorkflowNode implements RunnableNode<SubWorkflow<any, any>> {
   private readonly workflows;
   kind: "node";
   outputPorts: readonly ["main"];
   constructor(workflows: WorkflowRunnerService);
-  execute(items: Items, ctx: NodeExecutionContext<SubWorkflow<any, any>>): Promise<NodeOutputs>;
+  execute(args: RunnableNodeExecuteArgs<SubWorkflow<any, any>>): Promise<unknown>;
 }
 //#endregion
 //#region src/nodes/subWorkflow.d.ts
@@ -1404,10 +1481,10 @@ declare class WaitDuration {
 }
 //#endregion
 //#region src/nodes/WaitNode.d.ts
-declare class WaitNode implements Node<Wait<any>> {
+declare class WaitNode implements RunnableNode<Wait<any>> {
   kind: "node";
   outputPorts: readonly ["main"];
-  execute(items: Items, ctx: NodeExecutionContext<Wait<any>>): Promise<NodeOutputs>;
+  execute(args: RunnableNodeExecuteArgs<Wait<any>>): Promise<unknown>;
 }
 //#endregion
 //#region src/nodes/wait.d.ts
@@ -1508,11 +1585,17 @@ interface WorkflowAgentOptions<TCurrentJson, TOutputSchema extends z.ZodTypeAny
 declare class WorkflowBranchBuilder<TCurrentJson> {
   private readonly steps;
   constructor(steps?: ReadonlyArray<AnyRunnableNodeConfig>);
-  then<TInputJson$1, TOutputJson$1, TConfig extends RunnableNodeConfig<TInputJson$1, TOutputJson$1, TCurrentJson>>(config: TConfig): WorkflowBranchBuilder<RunnableNodeOutputJson<TConfig>>;
+  then<TOutputJson$1, TConfig extends RunnableNodeConfig<TCurrentJson, TOutputJson$1>>(config: TConfig): WorkflowBranchBuilder<RunnableNodeOutputJson<TConfig>>;
   map<TNextJson$1>(mapper: (item: TCurrentJson) => TNextJson$1): WorkflowBranchBuilder<TNextJson$1>;
   map<TNextJson$1>(name: string, mapper: (item: TCurrentJson) => TNextJson$1, id?: string): WorkflowBranchBuilder<TNextJson$1>;
   wait(duration: number | string): WorkflowBranchBuilder<TCurrentJson>;
   wait(name: string, duration: number | string, id?: string): 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>;
+  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>;
+  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>;
   agent<TOutputSchema extends z.ZodTypeAny>(options: WorkflowAgentOptions<TCurrentJson, TOutputSchema>): WorkflowBranchBuilder<z.output<TOutputSchema>>;
   agent(options: WorkflowAgentOptions<TCurrentJson, undefined>): WorkflowBranchBuilder<Record<string, unknown>>;
   agent<TOutputSchema extends z.ZodTypeAny>(name: string, options: WorkflowAgentOptions<TCurrentJson, TOutputSchema | undefined>): WorkflowBranchBuilder<TOutputSchema extends z.ZodTypeAny ? z.output<TOutputSchema> : Record<string, unknown>>;
@@ -1522,14 +1605,30 @@ declare class WorkflowBranchBuilder<TCurrentJson> {
 //#endregion
 //#region src/workflowAuthoring/WorkflowChain.types.d.ts
 type BranchCallback<TCurrentJson, TNextJson$1> = (branch: WorkflowBranchBuilder<TCurrentJson>) => WorkflowBranchBuilder<TNextJson$1>;
+type RouteBranchCallback<TCurrentJson, TNextJson$1> = (branch: WorkflowChain<TCurrentJson>) => WorkflowChain<TNextJson$1>;
 declare class WorkflowChain<TCurrentJson> {
   private readonly chain;
   constructor(chain: ChainCursor<TCurrentJson>);
-  then<TInputJson$1, TOutputJson$1, TConfig extends RunnableNodeConfig<TInputJson$1, TOutputJson$1, TCurrentJson>>(config: TConfig): WorkflowChain<RunnableNodeOutputJson<TConfig>>;
+  then<TOutputJson$1, TConfig extends RunnableNodeConfig<TCurrentJson, TOutputJson$1>>(config: TConfig): WorkflowChain<RunnableNodeOutputJson<TConfig>>;
   map<TNextJson$1>(mapper: (item: TCurrentJson) => TNextJson$1): WorkflowChain<TNextJson$1>;
   map<TNextJson$1>(name: string, mapper: (item: TCurrentJson) => TNextJson$1, id?: string): WorkflowChain<TNextJson$1>;
   wait(duration: number | string): WorkflowChain<TCurrentJson>;
   wait(name: string, duration: number | string, id?: string): 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>;
+  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>;
+  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>;
+  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>;
   if<TBranchJson>(predicate: (item: TCurrentJson) => boolean, branches: Readonly<{
     true?: BranchCallback<TCurrentJson, TBranchJson>;
     false?: BranchCallback<TCurrentJson, TBranchJson>;
@@ -1538,6 +1637,19 @@ declare class WorkflowChain<TCurrentJson> {
     true?: BranchCallback<TCurrentJson, TBranchJson>;
     false?: BranchCallback<TCurrentJson, TBranchJson>;
   }>): WorkflowChain<TBranchJson>;
+  route<TBranchJson>(branches: Readonly<Record<string, RouteBranchCallback<TCurrentJson, TBranchJson> | undefined>>): 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>;
   agent<TOutputSchema extends z.ZodTypeAny>(options: WorkflowAgentOptions<TCurrentJson, TOutputSchema>): WorkflowChain<z.output<TOutputSchema>>;
   agent(options: WorkflowAgentOptions<TCurrentJson, undefined>): WorkflowChain<Record<string, unknown>>;
   agent<TOutputSchema extends z.ZodTypeAny>(name: string, options: WorkflowAgentOptions<TCurrentJson, TOutputSchema | undefined>): WorkflowChain<TOutputSchema extends z.ZodTypeAny ? z.output<TOutputSchema> : Record<string, unknown>>;
@@ -1563,10 +1675,10 @@ declare function workflow(id: string): WorkflowAuthoringBuilder;
  * Placeholder runnable node for connection-owned workflow nodes (LLM/tool slots).
  * The engine does not schedule these; they exist for credentials, tokens, and UI identity.
  */
-declare class ConnectionCredentialNode implements Node<ConnectionCredentialNodeConfig> {
+declare class ConnectionCredentialNode implements RunnableNode<ConnectionCredentialNodeConfig> {
   kind: "node";
   outputPorts: readonly ["main"];
-  execute(_items: Items, _ctx: NodeExecutionContext<ConnectionCredentialNodeConfig>): Promise<NodeOutputs>;
+  execute(_args: RunnableNodeExecuteArgs<ConnectionCredentialNodeConfig>): unknown;
 }
 //#endregion
 //#region src/nodes/ConnectionCredentialNodeConfig.d.ts
@@ -1602,5 +1714,5 @@ declare class AIAgentConnectionWorkflowExpander {
   private assertNoIdCollision;
 }
 //#endregion
-export { AIAgent, AIAgentConnectionWorkflowExpander, AIAgentExecutionHelpersFactory, AIAgentNode, AgentItemPortMap, AgentMessageFactory, AgentOutputFactory, AgentToolCallPortMap, Aggregate, AggregateNode, Callback, CallbackHandler, CallbackNode, CallbackResultNormalizer, CanvasIconName, ConnectionCredentialExecutionContextFactory, ConnectionCredentialNode, ConnectionCredentialNodeConfig, ConnectionCredentialNodeConfigFactory, type ExecutedToolCall, Filter, FilterNode, HttpRequest, HttpRequestDownloadMode, HttpRequestNode, HttpRequestOutputJson, If, IfNode, type ItemScopedToolBinding, ManualTrigger, ManualTriggerNode, MapData, MapDataNode, Merge, MergeMode, MergeNode, NoOp, NoOpNode, OpenAIChatModelConfig, OpenAIChatModelFactory, OpenAiChatModelPresets, OpenAiCredentialSession, type PlannedToolCall, type ResolvedTool, Split, SplitNode, SubWorkflow, SubWorkflowNode, Wait, WaitDuration, WaitNode, WebhookRespondNowAndContinueError, WebhookRespondNowError, WebhookTrigger, WebhookTriggerNode, type WorkflowAgentOptions, WorkflowAuthoringBuilder, WorkflowBranchBuilder, WorkflowChain, createWorkflowBuilder, openAiChatModelPresets, registerCoreNodes, workflow };
+export { AIAgent, AIAgentConnectionWorkflowExpander, AIAgentExecutionHelpersFactory, AIAgentNode, AgentItemPortMap, AgentMessageFactory, AgentOutputFactory, AgentToolCallPortMap, Aggregate, AggregateNode, Callback, CallbackHandler, CallbackNode, CallbackOptions, CallbackResultNormalizer, CanvasIconName, ConnectionCredentialExecutionContextFactory, ConnectionCredentialNode, ConnectionCredentialNodeConfig, ConnectionCredentialNodeConfigFactory, type ExecutedToolCall, Filter, FilterNode, HttpRequest, HttpRequestDownloadMode, HttpRequestNode, HttpRequestOutputJson, If, IfNode, type ItemScopedToolBinding, ManualTrigger, ManualTriggerNode, MapData, MapDataNode, Merge, MergeMode, MergeNode, NoOp, NoOpNode, OpenAIChatModelConfig, OpenAIChatModelFactory, OpenAiChatModelPresets, OpenAiCredentialSession, type PlannedToolCall, type ResolvedTool, Split, SplitNode, SubWorkflow, SubWorkflowNode, Switch, SwitchCaseKeyResolver, SwitchNode, Wait, WaitDuration, WaitNode, WebhookRespondNowAndContinueError, WebhookRespondNowError, WebhookTrigger, WebhookTriggerNode, type WorkflowAgentOptions, WorkflowAuthoringBuilder, WorkflowBranchBuilder, WorkflowChain, createWorkflowBuilder, openAiChatModelPresets, registerCoreNodes, workflow };
 //# sourceMappingURL=index.d.ts.map