@codemation/core-nodes 0.0.25 → 0.1.1

package/dist/index.d.cts

@@ -14,6 +14,38 @@ import { DynamicStructuredTool } from "@langchain/core/tools";
  */
 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.
+ * Runnable node: **`TInputJson`** is what **`inputSchema`** validates on **`item.json`** (the wire payload).
+ * **`TOutputJson`** is emitted `item.json` on outputs.
  */
-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).
- */
-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 {
@@ -603,16 +626,24 @@ type OAuth2ProviderFromPublicConfig = Readonly<{
   tokenUrlFieldKey: string;
   userInfoUrlFieldKey?: string;
 }>;
+type CredentialOAuth2ScopesFromPublicConfig = Readonly<{
+  presetFieldKey: string;
+  presetScopes: Readonly<Record<string, ReadonlyArray<string>>>;
+  customPresetKey?: string;
+  customScopesFieldKey?: string;
+}>;
 type CredentialOAuth2AuthDefinition = Readonly<{
   kind: "oauth2";
   providerId: string;
   scopes: ReadonlyArray<string>;
+  scopesFromPublicConfig?: CredentialOAuth2ScopesFromPublicConfig;
   clientIdFieldKey?: string;
   clientSecretFieldKey?: string;
 } | {
   kind: "oauth2";
   providerFromPublicConfig: OAuth2ProviderFromPublicConfig;
   scopes: ReadonlyArray<string>;
+  scopesFromPublicConfig?: CredentialOAuth2ScopesFromPublicConfig;
   clientIdFieldKey?: string;
   clientSecretFieldKey?: string;
 }>;
@@ -692,19 +723,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 +799,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 +834,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 +842,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 +851,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 +861,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 +961,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 +969,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 +991,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 +1064,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 +1132,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 +1229,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 +1250,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 +1271,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 +1287,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 +1384,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 +1440,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 +1459,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 +1489,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 +1593,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 +1613,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 +1645,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 +1683,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 +1722,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, ExecutedToolCall, Filter, FilterNode, HttpRequest, HttpRequestDownloadMode, HttpRequestNode, HttpRequestOutputJson, If, IfNode, ItemScopedToolBinding, ManualTrigger, ManualTriggerNode, MapData, MapDataNode, Merge, MergeMode, MergeNode, NoOp, NoOpNode, OpenAIChatModelConfig, OpenAIChatModelFactory, OpenAiChatModelPresets, OpenAiCredentialSession, PlannedToolCall, 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, ExecutedToolCall, Filter, FilterNode, HttpRequest, HttpRequestDownloadMode, HttpRequestNode, HttpRequestOutputJson, If, IfNode, ItemScopedToolBinding, ManualTrigger, ManualTriggerNode, MapData, MapDataNode, Merge, MergeMode, MergeNode, NoOp, NoOpNode, OpenAIChatModelConfig, OpenAIChatModelFactory, OpenAiChatModelPresets, OpenAiCredentialSession, PlannedToolCall, 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.cts.map