@codemation/core-nodes 0.0.24 → 0.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemation/core-nodes",
-  "version": "0.0.24",
+  "version": "0.1.0",
   "publishConfig": {
     "access": "public"
   },
@@ -31,11 +31,12 @@
     "@langchain/core": "^1.1.31",
     "@langchain/openai": "^1.2.12",
     "lucide-react": "^0.577.0",
-    "@codemation/core": "0.2.3"
+    "@codemation/core": "0.4.0"
   },
   "devDependencies": {
     "@types/node": "^25.3.5",
     "eslint": "^10.0.3",
+    "reflect-metadata": "^0.2.2",
     "tsdown": "^0.15.5",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
@@ -43,6 +44,7 @@
     "zod": "^4.3.6"
   },
   "scripts": {
+    "changeset:verify": "pnpm --workspace-root run changeset:verify",
     "dev": "tsdown --watch",
     "build": "tsdown",
     "typecheck": "tsc -p tsconfig.json --noEmit",

package/src/index.ts

@@ -9,6 +9,7 @@ export * from "./nodes/httpRequest";
 export * from "./nodes/aggregate";
 export * from "./nodes/filter";
 export * from "./nodes/if";
+export * from "./nodes/switch";
 export * from "./nodes/split";
 export * from "./nodes/ManualTriggerFactory";
 export * from "./nodes/mapData";

package/src/nodes/AIAgentConfig.ts

@@ -4,7 +4,6 @@ import {
   type AgentMessageConfig,
   type AgentNodeConfig,
   type ChatModelConfig,
-  type ItemInputMapper,
   type RetryPolicySpec,
   type RunnableNodeConfig,
   type ToolConfig,
@@ -14,7 +13,7 @@ import type { ZodType } from "zod";
 
 import { AIAgentNode } from "./AIAgentNode";
 
-export interface AIAgentOptions<TInputJson = unknown, _TOutputJson = unknown, TWireJson = TInputJson> {
+export interface AIAgentOptions<TInputJson = unknown, _TOutputJson = unknown> {
   readonly name: string;
   readonly messages: AgentMessageConfig<TInputJson>;
   readonly chatModel: ChatModelConfig;
@@ -22,18 +21,16 @@ export interface AIAgentOptions<TInputJson = unknown, _TOutputJson = unknown, TW
   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>;
-  /** Per-item mapper before validation; use with {@link inputSchema} so persisted run inputs show the prompt payload. */
-  readonly mapInput?: ItemInputMapper<TWireJson, TInputJson>;
 }
 
 /**
  * AI agent: credential bindings are keyed to connection-owned LLM/tool node ids (ConnectionNodeIdFactory),
  * not to the agent workflow node id.
  */
-export class AIAgent<TInputJson = unknown, TOutputJson = unknown, TWireJson = TInputJson>
-  implements RunnableNodeConfig<TInputJson, TOutputJson, TWireJson>, AgentNodeConfig<TInputJson, TOutputJson, TWireJson>
+export class AIAgent<TInputJson = unknown, TOutputJson = unknown>
+  implements RunnableNodeConfig<TInputJson, TOutputJson>, AgentNodeConfig<TInputJson, TOutputJson>
 {
   readonly kind = "node" as const;
   readonly type: TypeToken<unknown> = AIAgentNode;
@@ -47,9 +44,8 @@ export class AIAgent<TInputJson = unknown, TOutputJson = unknown, TWireJson = TI
   readonly retryPolicy: RetryPolicySpec;
   readonly guardrails?: AgentGuardrailConfig;
   readonly inputSchema?: ZodType<TInputJson>;
-  readonly mapInput?: ItemInputMapper<TWireJson, TInputJson>;
 
-  constructor(options: AIAgentOptions<TInputJson, TOutputJson, TWireJson>) {
+  constructor(options: AIAgentOptions<TInputJson, TOutputJson>) {
     this.name = options.name;
     this.messages = options.messages;
     this.chatModel = options.chatModel;
@@ -58,6 +54,5 @@ export class AIAgent<TInputJson = unknown, TOutputJson = unknown, TWireJson = TI
     this.retryPolicy = options.retryPolicy ?? RetryPolicy.defaultForAiAgent;
     this.guardrails = options.guardrails;
     this.inputSchema = options.inputSchema;
-    this.mapInput = options.mapInput;
   }
 }

package/src/nodes/AIAgentNode.ts

@@ -4,12 +4,13 @@ import type {
   ChatModelConfig,
   ChatModelFactory,
   Item,
-  ItemNode,
   Items,
   JsonValue,
   LangChainChatModelLike,
   NodeExecutionContext,
   NodeInputsByPort,
+  RunnableNode,
+  RunnableNodeExecuteArgs,
   Tool,
   ToolConfig,
   ZodSchemaAny,
@@ -59,12 +60,13 @@ interface PreparedAgentExecution {
 }
 
 @node({ packageName: "@codemation/core-nodes" })
-export class AIAgentNode implements ItemNode<AIAgent<any, any>, unknown, unknown> {
+export class AIAgentNode implements RunnableNode<AIAgent<any, any>> {
   kind = "node" as const;
   outputPorts = ["main"] as const;
   /**
-   * 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.unknown();
 
@@ -89,13 +91,7 @@ export class AIAgentNode implements ItemNode<AIAgent<any, any>, unknown, unknown
       this.executionHelpers.createConnectionCredentialExecutionContextFactory(credentialSessions);
   }
 
-  async executeOne(args: {
-    input: unknown;
-    item: Item;
-    itemIndex: number;
-    items: Items;
-    ctx: NodeExecutionContext<AIAgent<any, any>>;
-  }): Promise<unknown> {
+  async execute(args: RunnableNodeExecuteArgs<AIAgent<any, any>>): Promise<unknown> {
     const prepared = await this.getOrPrepareExecution(args.ctx);
     const itemWithMappedJson = { ...args.item, json: args.input };
     const resultItem = await this.runAgentForItem(prepared, itemWithMappedJson, args.itemIndex, args.items);

package/src/nodes/AggregateNode.ts

@@ -1,19 +1,18 @@
-import type { Items, Node, NodeExecutionContext, NodeOutputs } from "@codemation/core";
+import type { RunnableNode, RunnableNodeExecuteArgs } from "@codemation/core";
 
 import { node } from "@codemation/core";
 
 import type { Aggregate } from "./aggregate";
 
 @node({ packageName: "@codemation/core-nodes" })
-export class AggregateNode implements Node<Aggregate<any, any>> {
+export class AggregateNode implements RunnableNode<Aggregate<any, any>> {
   kind = "node" as const;
   outputPorts = ["main"] as const;
 
-  async execute(items: Items, ctx: NodeExecutionContext<Aggregate<any, any>>): Promise<NodeOutputs> {
-    if (items.length === 0) {
-      return { main: [] };
+  async execute(args: RunnableNodeExecuteArgs<Aggregate<any, any>>): Promise<unknown> {
+    if (args.itemIndex !== args.items.length - 1) {
+      return [];
     }
-    const json = await Promise.resolve(ctx.config.aggregate(items as Items, ctx));
-    return { main: [{ json }] };
+    return Promise.resolve(args.ctx.config.aggregate(args.items, args.ctx));
   }
 }

package/src/nodes/CallbackNode.ts

@@ -1,17 +1,29 @@
-import type { Items, Node, NodeExecutionContext, NodeOutputs } from "@codemation/core";
-
+import type { RunnableNode, RunnableNodeExecuteArgs } from "@codemation/core";
 import { node } from "@codemation/core";
 
 import { Callback } from "./CallbackNodeFactory";
 import { CallbackResultNormalizer } from "./CallbackResultNormalizerFactory";
 
 @node({ packageName: "@codemation/core-nodes" })
-export class CallbackNode implements Node<Callback<any, any>> {
+export class CallbackNode implements RunnableNode<Callback<any, any>> {
   kind = "node" as const;
   outputPorts = ["main"] as const;
 
-  async execute(items: Items, ctx: NodeExecutionContext<Callback<any, any>>): Promise<NodeOutputs> {
-    const result = await ctx.config.callback(items, ctx);
-    return CallbackResultNormalizer.toNodeOutputs(result, items);
+  async execute(args: RunnableNodeExecuteArgs<Callback<any, any>>): Promise<unknown> {
+    const items = args.items ?? [];
+    const ctx = args.ctx;
+    const config = ctx.config;
+    if (config == null) {
+      throw new Error("CallbackNode: missing ctx.config (engine should always pass runnable config)");
+    }
+    if (items.length === 0) {
+      const result = await config.callback(items, ctx);
+      return CallbackResultNormalizer.toPortsEmission(result, items);
+    }
+    if (args.itemIndex !== items.length - 1) {
+      return [];
+    }
+    const result = await config.callback(items, ctx);
+    return CallbackResultNormalizer.toPortsEmission(result, items);
   }
 }

package/src/nodes/CallbackNodeFactory.ts

@@ -1,4 +1,12 @@
-import type { Items, NodeExecutionContext, RunnableNodeConfig, TypeToken } from "@codemation/core";
+import type {
+  Items,
+  NodeExecutionContext,
+  NodeErrorHandlerSpec,
+  PortsEmission,
+  RetryPolicySpec,
+  RunnableNodeConfig,
+  TypeToken,
+} from "@codemation/core";
 
 import { CallbackNode } from "./CallbackNode";
 
@@ -9,7 +17,14 @@ export type CallbackHandler<
 > = (
   items: Items<TInputJson>,
   ctx: NodeExecutionContext<TConfig>,
-) => Promise<Items<TOutputJson> | void> | Items<TOutputJson> | void;
+) => Promise<Items<TOutputJson> | PortsEmission | void> | Items<TOutputJson> | PortsEmission | void;
+
+export type CallbackOptions = Readonly<{
+  id?: string;
+  retryPolicy?: RetryPolicySpec;
+  nodeErrorHandler?: NodeErrorHandlerSpec;
+  declaredOutputPorts?: ReadonlyArray<string>;
+}>;
 
 export class Callback<TInputJson = unknown, TOutputJson = TInputJson> implements RunnableNodeConfig<
   TInputJson,
@@ -19,6 +34,11 @@ export class Callback<TInputJson = unknown, TOutputJson = TInputJson> implements
   readonly type: TypeToken<unknown> = CallbackNode;
   readonly execution = { hint: "local" } as const;
   readonly icon = "lucide:braces" as const;
+  readonly emptyBatchExecution = "runOnce" as const;
+  readonly id?: string;
+  readonly retryPolicy?: RetryPolicySpec;
+  readonly nodeErrorHandler?: NodeErrorHandlerSpec;
+  readonly declaredOutputPorts?: ReadonlyArray<string>;
 
   constructor(
     public readonly name: string = "Callback",
@@ -26,8 +46,15 @@ export class Callback<TInputJson = unknown, TOutputJson = TInputJson> implements
       TInputJson,
       TOutputJson
     >,
-    public readonly id?: string,
-  ) {}
+    idOrOptions?: string | CallbackOptions,
+    options?: CallbackOptions,
+  ) {
+    const resolvedOptions = typeof idOrOptions === "string" ? { ...options, id: idOrOptions } : idOrOptions;
+    this.id = resolvedOptions?.id;
+    this.retryPolicy = resolvedOptions?.retryPolicy;
+    this.nodeErrorHandler = resolvedOptions?.nodeErrorHandler;
+    this.declaredOutputPorts = resolvedOptions?.declaredOutputPorts;
+  }
 
   private static defaultCallback<TItemJson>(items: Items<TItemJson>): Items<TItemJson> {
     return items;

package/src/nodes/CallbackResultNormalizerFactory.ts

@@ -1,7 +1,11 @@
-import type { Items, NodeOutputs } from "@codemation/core";
+import type { Items, PortsEmission } from "@codemation/core";
+import { emitPorts, isPortsEmission } from "@codemation/core";
 
 export class CallbackResultNormalizer {
-  static toNodeOutputs(result: Items | void, items: Items): NodeOutputs {
-    return { main: result ?? items };
+  static toPortsEmission(result: Items | PortsEmission | void, items: Items): PortsEmission {
+    if (isPortsEmission(result)) {
+      return result;
+    }
+    return emitPorts({ main: result ?? items });
   }
 }

package/src/nodes/ConnectionCredentialNode.ts

@@ -1,4 +1,4 @@
-import type { Items, Node, NodeExecutionContext, NodeOutputs } from "@codemation/core";
+import type { RunnableNode, RunnableNodeExecuteArgs } from "@codemation/core";
 import { node } from "@codemation/core";
 
 import type { ConnectionCredentialNodeConfig } from "./ConnectionCredentialNodeConfig";
@@ -8,11 +8,11 @@ import type { ConnectionCredentialNodeConfig } from "./ConnectionCredentialNodeC
  * The engine does not schedule these; they exist for credentials, tokens, and UI identity.
  */
 @node({ packageName: "@codemation/core-nodes" })
-export class ConnectionCredentialNode implements Node<ConnectionCredentialNodeConfig> {
+export class ConnectionCredentialNode implements RunnableNode<ConnectionCredentialNodeConfig> {
   kind = "node" as const;
   outputPorts = ["main"] as const;
 
-  async execute(_items: Items, _ctx: NodeExecutionContext<ConnectionCredentialNodeConfig>): Promise<NodeOutputs> {
-    return { main: [] };
+  execute(_args: RunnableNodeExecuteArgs<ConnectionCredentialNodeConfig>): unknown {
+    return [];
   }
 }

package/src/nodes/FilterNode.ts

@@ -1,22 +1,18 @@
-import type { Item, Items, Node, NodeExecutionContext, NodeOutputs } from "@codemation/core";
+import type { Item, RunnableNode, RunnableNodeExecuteArgs } from "@codemation/core";
 
 import { node } from "@codemation/core";
 
 import type { Filter } from "./filter";
 
 @node({ packageName: "@codemation/core-nodes" })
-export class FilterNode implements Node<Filter<any>> {
+export class FilterNode implements RunnableNode<Filter<any>> {
   kind = "node" as const;
   outputPorts = ["main"] as const;
 
-  async execute(items: Items, ctx: NodeExecutionContext<Filter<any>>): Promise<NodeOutputs> {
-    const out: Item[] = [];
-    for (let i = 0; i < items.length; i++) {
-      const item = items[i] as Item;
-      if (ctx.config.predicate(item as Item, i, items as Items, ctx)) {
-        out.push(item);
-      }
+  execute(args: RunnableNodeExecuteArgs<Filter<any>>): unknown {
+    if (args.ctx.config.predicate(args.item as Item, args.itemIndex, args.items, args.ctx)) {
+      return args.item;
     }
-    return { main: out };
+    return [];
   }
 }

package/src/nodes/HttpRequestNodeFactory.ts

@@ -1,4 +1,4 @@
-import type { Item, Items, Node, NodeExecutionContext, NodeOutputs } from "@codemation/core";
+import type { Item, NodeExecutionContext, RunnableNode, RunnableNodeExecuteArgs } from "@codemation/core";
 
 import { node } from "@codemation/core";
 
@@ -6,16 +6,12 @@ import type { HttpRequestDownloadMode } from "./httpRequest";
 import { HttpRequest } from "./httpRequest";
 
 @node({ packageName: "@codemation/core-nodes" })
-export class HttpRequestNode implements Node<HttpRequest<any, any>> {
+export class HttpRequestNode implements RunnableNode<HttpRequest<any, any>> {
   readonly kind = "node" as const;
   readonly outputPorts = ["main"] as const;
 
-  async execute(items: Items, ctx: NodeExecutionContext<HttpRequest<any, any>>): Promise<NodeOutputs> {
-    const output: Item[] = [];
-    for (const item of items) {
-      output.push(await this.executeItem(item, ctx));
-    }
-    return { main: output };
+  async execute(args: RunnableNodeExecuteArgs<HttpRequest<any, any>>): Promise<unknown> {
+    return await this.executeItem(args.item, args.ctx);
   }
 
   private async executeItem(item: Item, ctx: NodeExecutionContext<HttpRequest<any, any>>): Promise<Item> {

package/src/nodes/IfNode.ts

@@ -1,35 +1,23 @@
-import type { Item, Items, Node, NodeExecutionContext, NodeOutputs } from "@codemation/core";
-
-import { node } from "@codemation/core";
+import type { RunnableNode, RunnableNodeExecuteArgs } from "@codemation/core";
+import { emitPorts, node } from "@codemation/core";
 
 import { If } from "./if";
+import { tagItemForRouterFanIn } from "./mergeExecutionUtils.types";
 
 @node({ packageName: "@codemation/core-nodes" })
-export class IfNode implements Node<If<any>> {
+export class IfNode implements RunnableNode<If<any>> {
   kind = "node" as const;
-  outputPorts = ["true", "false"] as const;
 
-  async execute(items: Items, ctx: NodeExecutionContext<If<any>>): Promise<NodeOutputs> {
-    const t: Item[] = [];
-    const f: Item[] = [];
-    for (let i = 0; i < items.length; i++) {
-      const item = items[i] as Item<unknown>;
-      const metaBase = (
-        item.meta && typeof item.meta === "object" ? (item.meta as Record<string, unknown>) : {}
-      ) as Record<string, unknown>;
-      const cmBase =
-        metaBase._cm && typeof metaBase._cm === "object"
-          ? (metaBase._cm as Record<string, unknown>)
-          : ({} as Record<string, unknown>);
-      const originIndex = typeof cmBase.originIndex === "number" ? (cmBase.originIndex as number) : i;
-      const tagged: Item = {
-        ...item,
-        meta: { ...metaBase, _cm: { ...cmBase, originIndex } },
-        paired: [{ nodeId: ctx.nodeId, output: "$in", itemIndex: originIndex }, ...(item.paired ?? [])],
-      };
-      const ok = ctx.config.predicate(item, i, items, ctx);
-      (ok ? t : f).push(tagged);
-    }
-    return { true: t, false: f };
+  execute(args: RunnableNodeExecuteArgs<If<any>>): unknown {
+    const tagged = tagItemForRouterFanIn({
+      item: args.item,
+      itemIndex: args.itemIndex,
+      nodeId: args.ctx.nodeId,
+    });
+    const ok = args.ctx.config.predicate(args.item, args.itemIndex, args.items, args.ctx);
+    return emitPorts({
+      true: ok ? [tagged] : [],
+      false: ok ? [] : [tagged],
+    });
   }
 }

package/src/nodes/MapDataNode.ts

@@ -1,4 +1,4 @@
-import type { Item, ItemNode, Items, NodeExecutionContext } from "@codemation/core";
+import type { RunnableNode, RunnableNodeExecuteArgs } from "@codemation/core";
 
 import { node } from "@codemation/core";
 import { z } from "zod";
@@ -6,18 +6,12 @@ import { z } from "zod";
 import { MapData } from "./mapData";
 
 @node({ packageName: "@codemation/core-nodes" })
-export class MapDataNode implements ItemNode<MapData<any, any>, unknown, unknown> {
+export class MapDataNode implements RunnableNode<MapData<any, any>> {
   kind = "node" as const;
   outputPorts = ["main"] as const;
   readonly inputSchema = z.unknown();
 
-  async executeOne(args: {
-    input: unknown;
-    item: Item;
-    itemIndex: number;
-    items: Items;
-    ctx: NodeExecutionContext<MapData<any, any>>;
-  }): Promise<unknown> {
+  async execute(args: RunnableNodeExecuteArgs<MapData<any, any>>): Promise<unknown> {
     return args.ctx.config.map(args.item, args.ctx);
   }
 }

package/src/nodes/NoOpNode.ts

@@ -1,15 +1,15 @@
-import type { Items, Node, NodeExecutionContext, NodeOutputs } from "@codemation/core";
+import type { RunnableNode, RunnableNodeExecuteArgs } from "@codemation/core";
 
 import { node } from "@codemation/core";
 
 import { NoOp } from "./noOp";
 
 @node({ packageName: "@codemation/core-nodes" })
-export class NoOpNode implements Node<NoOp<any>> {
+export class NoOpNode implements RunnableNode<NoOp<any>> {
   kind = "node" as const;
   outputPorts = ["main"] as const;
 
-  async execute(items: Items, _ctx: NodeExecutionContext<NoOp<any>>): Promise<NodeOutputs> {
-    return { main: items };
+  execute(args: RunnableNodeExecuteArgs<NoOp<any>>): unknown {
+    return args.item;
   }
 }

package/src/nodes/NodeBackedToolRuntime.ts

@@ -1,20 +1,27 @@
 import type {
   MultiInputNode,
-  Node,
   NodeExecutionContext,
   NodeOutputs,
   NodeResolver,
+  RunnableNode,
+  RunnableNodeConfig,
+  RunnableNodeExecuteArgs,
   NodeBackedToolConfig,
   ToolExecuteArgs,
   ZodSchemaAny,
 } from "@codemation/core";
-import { CoreTokens, inject, injectable } from "@codemation/core";
+import { CoreTokens, inject, injectable, ItemValueResolver, NodeOutputNormalizer } from "@codemation/core";
+import { z } from "zod";
 
 @injectable()
 export class NodeBackedToolRuntime {
   constructor(
     @inject(CoreTokens.NodeResolver)
     private readonly nodeResolver: NodeResolver,
+    @inject(ItemValueResolver)
+    private readonly itemValueResolver: ItemValueResolver,
+    @inject(NodeOutputNormalizer)
+    private readonly outputNormalizer: NodeOutputNormalizer,
   ) {}
 
   async execute(
@@ -32,7 +39,7 @@ export class NodeBackedToolRuntime {
     const nodeCtx = {
       ...args.ctx,
       config: config.node,
-    } as NodeExecutionContext<any>;
+    } as NodeExecutionContext<RunnableNodeConfig>;
     const resolvedNode = this.nodeResolver.resolve(config.node.type);
     const outputs = await this.executeResolvedNode(resolvedNode, nodeInput, nodeCtx);
     return config.toToolOutput({
@@ -49,19 +56,44 @@ export class NodeBackedToolRuntime {
   private async executeResolvedNode(
     resolvedNode: unknown,
     nodeInput: ToolExecuteArgs["item"],
-    ctx: NodeExecutionContext<any>,
+    ctx: NodeExecutionContext<RunnableNodeConfig>,
   ): Promise<NodeOutputs> {
     if (this.isMultiInputNode(resolvedNode)) {
       return await resolvedNode.executeMulti({ in: [nodeInput] }, ctx);
     }
-    if (this.isNode(resolvedNode)) {
-      return await resolvedNode.execute([nodeInput], ctx);
+    if (this.isRunnableNode(resolvedNode)) {
+      const runnable = resolvedNode;
+      const runnableConfig = ctx.config;
+      const carry = runnableConfig.lineageCarry ?? "emitOnly";
+      const inputSchema = runnable.inputSchema ?? runnableConfig.inputSchema ?? z.unknown();
+      const parsed = inputSchema.parse(nodeInput.json);
+      const items = [nodeInput];
+      const resolvedCtx = await this.itemValueResolver.resolveConfigForItem(ctx, nodeInput, 0, items);
+      const execArgs: RunnableNodeExecuteArgs = {
+        input: parsed,
+        item: nodeInput,
+        itemIndex: 0,
+        items,
+        ctx: resolvedCtx,
+      };
+      const raw = await Promise.resolve(runnable.execute(execArgs));
+      return this.outputNormalizer.normalizeExecuteResult({
+        baseItem: nodeInput,
+        raw,
+        carry,
+      });
     }
     throw new Error(`Node-backed tool expected a runnable node instance for "${ctx.config.name ?? ctx.nodeId}".`);
   }
 
-  private isNode(value: unknown): value is Node<any> {
-    return typeof value === "object" && value !== null && "execute" in value;
+  private isRunnableNode(value: unknown): value is RunnableNode {
+    return (
+      typeof value === "object" &&
+      value !== null &&
+      (value as { kind?: string }).kind === "node" &&
+      typeof (value as { execute?: unknown }).execute === "function" &&
+      typeof (value as { executeMulti?: unknown }).executeMulti !== "function"
+    );
   }
 
   private isMultiInputNode(value: unknown): value is MultiInputNode<any> {

package/src/nodes/SplitNode.ts

@@ -1,26 +1,16 @@
-import type { Item, Items, Node, NodeExecutionContext, NodeOutputs } from "@codemation/core";
+import type { Item, RunnableNode, RunnableNodeExecuteArgs } from "@codemation/core";
 
 import { node } from "@codemation/core";
 
 import type { Split } from "./split";
 
 @node({ packageName: "@codemation/core-nodes" })
-export class SplitNode implements Node<Split<any, any>> {
+export class SplitNode implements RunnableNode<Split<any, any>> {
   kind = "node" as const;
   outputPorts = ["main"] as const;
 
-  async execute(items: Items, ctx: NodeExecutionContext<Split<any, any>>): Promise<NodeOutputs> {
-    const out: Item[] = [];
-    for (let i = 0; i < items.length; i++) {
-      const item = items[i] as Item;
-      const elements = ctx.config.getElements(item, ctx);
-      for (let j = 0; j < elements.length; j++) {
-        out.push({
-          ...item,
-          json: elements[j],
-        });
-      }
-    }
-    return { main: out };
+  execute(args: RunnableNodeExecuteArgs<Split<any, any>>): unknown {
+    const elements = args.ctx.config.getElements(args.item as Item, args.ctx);
+    return elements;
   }
 }