@codemation/core 0.5.0 → 0.7.0

package/src/authoring/defineNode.types.ts

@@ -4,6 +4,7 @@ import type {
   CredentialRequirement,
   CredentialTypeId,
 } from "../contracts/credentialTypes";
+import type { ParamDeep } from "../contracts/params";
 import type { RunnableNode, RunnableNodeExecuteArgs, NodeExecutionContext } from "../contracts/runtimeTypes";
 import type { Item, Items, RunnableNodeConfig } from "../contracts/workflowTypes";
 import type { TypeToken } from "../di";
@@ -67,6 +68,11 @@ export type DefineNodeExecuteArgs<TConfig extends CredentialJsonRecord, TInputJs
   ctx: NodeExecutionContext<RunnableNodeConfig<TInputJson, unknown> & Readonly<{ config: TConfig }>>;
 }>;
 
+export type DefinedNodeConfigInput<TConfigResolved extends CredentialJsonRecord, TItemJson> = ParamDeep<
+  TConfigResolved,
+  TItemJson
+>;
+
 export interface DefinedNode<
   TKey extends string,
   TConfig extends CredentialJsonRecord,
@@ -78,7 +84,11 @@ export interface DefinedNode<
   readonly key: TKey;
   readonly title: string;
   readonly description?: string;
-  create(config: TConfig, name?: string, id?: string): RunnableNodeConfig<TInputJson, TOutputJson>;
+  create<TConfigItemJson = TInputJson>(
+    config: DefinedNodeConfigInput<TConfig, TConfigItemJson>,
+    name?: string,
+    id?: string,
+  ): RunnableNodeConfig<TInputJson, TOutputJson>;
   register(context: { registerNode<TValue>(token: TypeToken<TValue>, implementation?: TypeToken<TValue>): void }): void;
 }
 
@@ -108,6 +118,8 @@ export interface DefineNodeOptions<
    * Validates **`input`** (engine also accepts `inputSchema` on the node class).
    */
   readonly inputSchema?: ZodType<TInputJson>;
+  /** Preserve inbound `item.binary` when `execute` returns plain JSON or item-shaped results without `binary`. */
+  readonly keepBinaries?: boolean;
   execute(
     args: DefineNodeExecuteArgs<TConfig, TInputJson>,
     context: DefinedNodeRunContext<TConfig, TBindings>,
@@ -246,12 +258,17 @@ export function defineNode<
     readonly type: TypeToken<unknown> = DefinedNodeRuntime;
     readonly icon = options.icon;
     readonly inputSchema = options.inputSchema;
+    readonly keepBinaries = options.keepBinaries ?? false;
 
     constructor(
       public readonly name: string,
-      public readonly config: TConfig,
+      config: DefinedNodeConfigInput<TConfig, unknown>,
       public readonly id?: string,
-    ) {}
+    ) {
+      this.config = config as unknown as TConfig;
+    }
+
+    public readonly config: TConfig;
 
     getCredentialRequirements(): ReadonlyArray<CredentialRequirement> {
       return credentialRequirements;
@@ -263,8 +280,12 @@ export function defineNode<
     key: options.key,
     title: options.title,
     description: options.description,
-    create(config, name = options.title, id) {
-      return new DefinedRunnableNodeConfig(name, config, id);
+    create<TConfigItemJson = TInputJson>(
+      config: DefinedNodeConfigInput<TConfig, TConfigItemJson>,
+      name = options.title,
+      id?: string,
+    ) {
+      return new DefinedRunnableNodeConfig(name, config as DefinedNodeConfigInput<TConfig, unknown>, id);
     },
     register(context) {
       context.registerNode(DefinedNodeRuntime);
@@ -324,9 +345,13 @@ export function defineBatchNode<
 
     constructor(
       public readonly name: string,
-      public readonly config: TConfig,
+      config: DefinedNodeConfigInput<TConfig, unknown>,
       public readonly id?: string,
-    ) {}
+    ) {
+      this.config = config as unknown as TConfig;
+    }
+
+    public readonly config: TConfig;
 
     getCredentialRequirements(): ReadonlyArray<CredentialRequirement> {
       return credentialRequirements;
@@ -338,8 +363,12 @@ export function defineBatchNode<
     key: options.key,
     title: options.title,
     description: options.description,
-    create(config, name = options.title, id) {
-      return new DefinedRunnableNodeConfig(name, config, id);
+    create<TConfigItemJson = TInputJson>(
+      config: DefinedNodeConfigInput<TConfig, TConfigItemJson>,
+      name = options.title,
+      id?: string,
+    ) {
+      return new DefinedRunnableNodeConfig(name, config as DefinedNodeConfigInput<TConfig, unknown>, id);
     },
     register(context) {
       context.registerNode(DefinedNodeRuntime);

package/src/authoring/index.ts

@@ -1,6 +1,7 @@
 export { DefinedNodeRegistry } from "./DefinedNodeRegistry";
 export type {
   DefinedNode,
+  DefinedNodeConfigInput,
   DefinedNodeCredentialAccessors,
   DefinedNodeCredentialBinding,
   DefinedNodeCredentialBindings,
@@ -12,3 +13,4 @@ export type {
 export { defineBatchNode, defineNode } from "./defineNode.types";
 export type { DefineCredentialOptions } from "./defineCredential.types";
 export { defineCredential } from "./defineCredential.types";
+export { callableTool } from "./callableTool.types";

package/src/bootstrap/runtime/EngineRuntimeRegistrar.ts

@@ -4,11 +4,12 @@ import { EngineExecutionLimitsPolicyFactory } from "../../policies/executionLimi
 import {
   DefaultAsyncSleeper,
   InProcessRetryRunnerFactory,
-  ItemValueResolver,
+  ItemExprResolver,
   NodeExecutor,
   NodeExecutorFactory,
   NodeInstanceFactoryFactory,
   NodeOutputNormalizer,
+  RunnableOutputBehaviorResolver,
 } from "../../execution";
 import {
   EngineFactory,
@@ -40,12 +41,15 @@ export class EngineRuntimeRegistrar {
   }
 
   private registerSupportFactories(container: DependencyContainer): void {
-    if (!container.isRegistered(ItemValueResolver, true)) {
-      container.registerSingleton(ItemValueResolver, ItemValueResolver);
+    if (!container.isRegistered(ItemExprResolver, true)) {
+      container.registerSingleton(ItemExprResolver, ItemExprResolver);
     }
     if (!container.isRegistered(NodeOutputNormalizer, true)) {
       container.registerSingleton(NodeOutputNormalizer, NodeOutputNormalizer);
     }
+    if (!container.isRegistered(RunnableOutputBehaviorResolver, true)) {
+      container.registerSingleton(RunnableOutputBehaviorResolver, RunnableOutputBehaviorResolver);
+    }
     container.register(EngineExecutionLimitsPolicyFactory, { useClass: EngineExecutionLimitsPolicyFactory });
     container.register(NodeInstanceFactoryFactory, { useClass: NodeInstanceFactoryFactory });
     container.register(DefaultAsyncSleeper, { useClass: DefaultAsyncSleeper });
@@ -101,7 +105,11 @@ export class EngineRuntimeRegistrar {
           .create(dependencyContainer.resolve(DefaultAsyncSleeper));
         return dependencyContainer
           .resolve(NodeExecutorFactory)
-          .create(dependencyContainer.resolve(CoreTokens.WorkflowNodeInstanceFactory), retryRunner);
+          .create(
+            dependencyContainer.resolve(CoreTokens.WorkflowNodeInstanceFactory),
+            retryRunner,
+            dependencyContainer.resolve(RunnableOutputBehaviorResolver),
+          );
       }),
     });
   }

package/src/contracts/credentialTypes.ts

@@ -13,6 +13,12 @@ export type CredentialFieldSchema = Readonly<{
   type: "string" | "password" | "textarea" | "json" | "boolean";
   required?: true;
   order?: number;
+  /**
+   * Where this field appears in the credential dialog. Use `"advanced"` for optional or
+   * power-user fields; they render inside a collapsible section (see `CredentialTypeDefinition.advancedSection`).
+   * Defaults to `"default"` when omitted.
+   */
+  visibility?: "default" | "advanced";
   placeholder?: string;
   helpText?: string;
   /** When set, host resolves this field from process.env at runtime; env wins over stored values. */
@@ -89,12 +95,26 @@ export type CredentialOAuth2AuthDefinition = Readonly<
 
 export type CredentialAuthDefinition = CredentialOAuth2AuthDefinition;
 
+export type CredentialAdvancedSectionPresentation = Readonly<{
+  /** Collapsible section title (default: "Advanced"). */
+  title?: string;
+  /** Optional short helper text shown inside the section (above the fields). */
+  description?: string;
+  /** When true, the advanced section starts expanded. Default: false (collapsed). */
+  defaultOpen?: boolean;
+}>;
+
 export type CredentialTypeDefinition = Readonly<{
   typeId: CredentialTypeId;
   displayName: string;
   description?: string;
   publicFields?: ReadonlyArray<CredentialFieldSchema>;
   secretFields?: ReadonlyArray<CredentialFieldSchema>;
+  /**
+   * Optional labels for the collapsible block that contains every field with `visibility: "advanced"`.
+   * If omitted, the UI still shows that block with defaults (title "Advanced", collapsed).
+   */
+  advancedSection?: CredentialAdvancedSectionPresentation;
   supportedSourceKinds?: ReadonlyArray<CredentialMaterialSourceKind>;
   auth?: CredentialAuthDefinition;
 }>;

package/src/contracts/index.ts

@@ -2,7 +2,8 @@ export * from "./credentialTypes";
 export * from "./emitPorts";
 export * from "./executionPersistenceContracts";
 export * from "./itemMeta";
-export * from "./itemValue";
+export * from "./params";
+export * from "./itemExpr";
 export * from "./runtimeTypes";
 export * from "./runFinishedAtFactory";
 export * from "./runTypes";

package/src/contracts/{itemValue.ts → itemExpr.ts}

@@ -1,9 +1,9 @@
 import type { NodeExecutionContext } from "./runtimeTypes";
 import type { Item, Items, NodeActivationId, NodeId, RunDataSnapshot, RunId, WorkflowId } from "./workflowTypes";
 
-const ITEM_VALUE_BRAND = Symbol.for("codemation.itemValue");
+const ITEM_EXPR_BRAND = Symbol.for("codemation.itemExpr");
 
-export type ItemValueResolvedContext = Readonly<{
+export type ItemExprResolvedContext = Readonly<{
   runId: RunId;
   workflowId: WorkflowId;
   nodeId: NodeId;
@@ -14,52 +14,51 @@ export type ItemValueResolvedContext = Readonly<{
 /**
  * Context aligned with former {@link ItemInputMapperContext} — use **`data`** to read any completed upstream node.
  */
-export type ItemValueContext = ItemValueResolvedContext;
+export type ItemExprContext = ItemExprResolvedContext;
 
-export type ItemValueArgs<TItemJson = unknown> = Readonly<{
+export type ItemExprArgs<TItemJson = unknown> = Readonly<{
   item: Item<TItemJson>;
   itemIndex: number;
   items: Items<TItemJson>;
-  ctx: ItemValueContext;
+  ctx: ItemExprContext;
 }>;
 
-export type ItemValueCallback<T, TItemJson = unknown> = (args: ItemValueArgs<TItemJson>) => T | Promise<T>;
+export type ItemExprCallback<T, TItemJson = unknown> = (args: ItemExprArgs<TItemJson>) => T | Promise<T>;
 
-export type ItemValue<T, TItemJson = unknown> = Readonly<{
-  readonly [ITEM_VALUE_BRAND]: true;
-  readonly fn: ItemValueCallback<T, TItemJson>;
+export type ItemExpr<T, TItemJson = unknown> = Readonly<{
+  readonly [ITEM_EXPR_BRAND]: true;
+  readonly fn: ItemExprCallback<T, TItemJson>;
 }>;
 
-export function itemValue<T, TItemJson = unknown>(fn: ItemValueCallback<T, TItemJson>): ItemValue<T, TItemJson> {
-  return { [ITEM_VALUE_BRAND]: true, fn };
+export function itemExpr<T, TItemJson = unknown>(fn: ItemExprCallback<T, TItemJson>): ItemExpr<T, TItemJson> {
+  return { [ITEM_EXPR_BRAND]: true, fn };
 }
 
-export function isItemValue<T, TItemJson = unknown>(value: unknown): value is ItemValue<T, TItemJson> {
+export function isItemExpr<T, TItemJson = unknown>(value: unknown): value is ItemExpr<T, TItemJson> {
   if (typeof value !== "object" || value === null) {
     return false;
   }
   const v = value as Record<PropertyKey, unknown>;
-  if (v[ITEM_VALUE_BRAND] === true) {
+  if (v[ITEM_EXPR_BRAND] === true) {
     return true;
   }
-  // Support snapshot-hydrated itemValue wrappers where the symbol brand was lost but the callback survived.
+  // Support snapshot-hydrated itemExpr wrappers where the symbol brand was lost but the callback survived.
   // Workflow snapshot hydration currently restores function-valued fields (like `fn`) but may drop symbol-keyed brands.
-  // We treat the minimal `{ fn: Function }` shape as an itemValue wrapper to keep runnable configs working.
+  // We treat the minimal `{ fn: Function }` shape as an itemExpr wrapper to keep runnable configs working.
   const keys = Object.keys(v);
   if (keys.length === 1 && keys[0] === "fn" && typeof (v as { fn?: unknown }).fn === "function") {
     return true;
   }
-  // Support legacy module-local Symbol("codemation.itemValue") brands (e.g. duplicate module graphs).
   for (const sym of Object.getOwnPropertySymbols(v)) {
-    if (sym.description === "codemation.itemValue" && v[sym] === true) {
+    if (sym.description === "codemation.itemExpr" && v[sym] === true) {
       return true;
     }
   }
   return false;
 }
 
-function containsItemValueInUnknown(value: unknown, seen: WeakSet<object> = new WeakSet()): boolean {
-  if (isItemValue(value)) {
+function containsItemExprInUnknown(value: unknown, seen: WeakSet<object> = new WeakSet()): boolean {
+  if (isItemExpr(value)) {
     return true;
   }
   if (value === null || typeof value !== "object") {
@@ -70,10 +69,10 @@ function containsItemValueInUnknown(value: unknown, seen: WeakSet<object> = new
   }
   seen.add(value as object);
   if (Array.isArray(value)) {
-    return value.some((entry) => containsItemValueInUnknown(entry, seen));
+    return value.some((entry) => containsItemExprInUnknown(entry, seen));
   }
   for (const entry of Object.values(value as Record<string, unknown>)) {
-    if (containsItemValueInUnknown(entry, seen)) {
+    if (containsItemExprInUnknown(entry, seen)) {
       return true;
     }
   }
@@ -81,14 +80,14 @@ function containsItemValueInUnknown(value: unknown, seen: WeakSet<object> = new
 }
 
 /**
- * Deep-resolves {@link itemValue} leaves. Returns a new graph (does not mutate the original config object).
+ * Deep-resolves {@link itemExpr} leaves. Returns a new graph (does not mutate the original config object).
  */
-export async function resolveItemValuesInUnknown(
+export async function resolveItemExprsInUnknown(
   value: unknown,
-  args: ItemValueArgs,
+  args: ItemExprArgs,
   seen: WeakSet<object> = new WeakSet(),
 ): Promise<unknown> {
-  if (isItemValue(value)) {
+  if (isItemExpr(value)) {
     return await Promise.resolve(value.fn(args));
   }
   if (value === null || typeof value !== "object") {
@@ -101,7 +100,7 @@ export async function resolveItemValuesInUnknown(
   if (Array.isArray(value)) {
     const out: unknown[] = [];
     for (let i = 0; i < value.length; i++) {
-      out.push(await resolveItemValuesInUnknown(value[i], args, seen));
+      out.push(await resolveItemExprsInUnknown(value[i], args, seen));
     }
     return out;
   }
@@ -113,22 +112,22 @@ export async function resolveItemValuesInUnknown(
   }
   const out = Object.create(proto) as Record<string, unknown>;
   for (const [k, v] of entries) {
-    out[k] = await resolveItemValuesInUnknown(v, args, seen);
+    out[k] = await resolveItemExprsInUnknown(v, args, seen);
   }
   return out;
 }
 
 /**
- * Clones runnable config (best-effort) so per-item {@link itemValue} resolution never mutates shared instances.
+ * Clones runnable config (best-effort) so per-item {@link itemExpr} resolution never mutates shared instances.
  */
-export async function resolveItemValuesForExecution(
+export async function resolveItemExprsForExecution(
   config: unknown,
   nodeCtx: NodeExecutionContext,
   item: Item,
   itemIndex: number,
   items: Items,
 ): Promise<unknown | undefined> {
-  const ivArgs: ItemValueArgs = {
+  const exprArgs: ItemExprArgs = {
     item,
     itemIndex,
     items,
@@ -140,8 +139,8 @@ export async function resolveItemValuesForExecution(
       data: nodeCtx.data,
     },
   };
-  if (!containsItemValueInUnknown(config)) {
+  if (!containsItemExprInUnknown(config)) {
     return undefined;
   }
-  return await resolveItemValuesInUnknown(config, ivArgs);
+  return await resolveItemExprsInUnknown(config, exprArgs);
 }

package/src/contracts/params.ts

@@ -0,0 +1,10 @@
+import type { ItemExpr } from "./itemExpr";
+
+export type Expr<T, TItemJson = unknown> = ItemExpr<T, TItemJson>;
+
+export type Param<T, TItemJson = unknown> = T | Expr<T, TItemJson>;
+
+export type ParamDeep<T, TItemJson = unknown> =
+  | Expr<T, TItemJson>
+  | (T extends readonly (infer U)[] ? ReadonlyArray<ParamDeep<U, TItemJson>> : never)
+  | (T extends object ? { [K in keyof T]: ParamDeep<T[K], TItemJson> } : T);

package/src/contracts/runtimeTypes.ts

@@ -223,8 +223,10 @@ export interface EngineHost {
 }
 
 /**
- * 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).
+ * Per-item runnable node: return JSON, an array to fan-out on `main`, an explicit `Item`, 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). Transform helpers may opt into binary preservation, while routers and
+ * pass-through nodes should return explicit items when they need to preserve full item state.
  */
 export interface RunnableNodeExecuteArgs<
   TConfig extends RunnableNodeConfig<any, any> = RunnableNodeConfig<any, any>,

package/src/contracts/workflowTypes.ts

@@ -6,6 +6,7 @@ import type { RetryPolicySpec } from "./retryPolicySpec.types";
 
 export type WorkflowId = string;
 export type NodeId = string;
+export type NodeIdRef<TJson = unknown> = NodeId & Readonly<{ __codemationNodeJson?: TJson }>;
 export type OutputPortKey = string;
 export type InputPortKey = string;
 export type PersistedTokenId = string;
@@ -96,8 +97,6 @@ export declare const runnableNodeInputType: unique symbol;
 export declare const runnableNodeOutputType: unique symbol;
 export declare const triggerNodeOutputType: unique symbol;
 
-export type LineageCarryPolicy = "emitOnly" | "carryThrough";
-
 /**
  * Runnable node: **`TInputJson`** is what **`inputSchema`** validates on **`item.json`** (the wire payload).
  * **`TOutputJson`** is emitted `item.json` on outputs.
@@ -111,11 +110,6 @@ export interface RunnableNodeConfig<TInputJson = unknown, TOutputJson = unknown>
    * Resolution order: node instance `inputSchema`, then config `inputSchema`, then `z.unknown()`.
    */
   readonly inputSchema?: ZodType<TInputJson>;
-  /**
-   * 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).
@@ -161,6 +155,10 @@ export interface NodeRef {
   name?: string;
 }
 
+export function nodeRef<TJson>(nodeId: NodeId): NodeIdRef<TJson> {
+  return nodeId as NodeIdRef<TJson>;
+}
+
 export type PairedItemRef = Readonly<{ nodeId: NodeId; output: OutputPortKey; itemIndex: number }>;
 
 export type BinaryPreviewKind = "image" | "audio" | "video" | "download";
@@ -211,8 +209,12 @@ export interface ParentExecutionRef {
 
 export interface RunDataSnapshot {
   getOutputs(nodeId: NodeId): NodeOutputs | undefined;
-  getOutputItems(nodeId: NodeId, output?: OutputPortKey): Items;
-  getOutputItem(nodeId: NodeId, itemIndex: number, output?: OutputPortKey): Item | undefined;
+  getOutputItems<TJson = unknown>(nodeId: NodeId | NodeIdRef<TJson>, output?: OutputPortKey): Items<TJson>;
+  getOutputItem<TJson = unknown>(
+    nodeId: NodeId | NodeIdRef<TJson>,
+    itemIndex: number,
+    output?: OutputPortKey,
+  ): Item<TJson> | undefined;
 }
 
 export interface MutableRunData extends RunDataSnapshot {

package/src/execution/{ItemValueResolver.ts → ItemExprResolver.ts}

@@ -1,10 +1,10 @@
-import { resolveItemValuesForExecution } from "../contracts/itemValue";
+import { resolveItemExprsForExecution } from "../contracts/itemExpr";
 import type { Item, NodeExecutionContext, RunnableNodeConfig } from "../types";
 
 /**
- * Resolves {@link import("../contracts/itemValue").ItemValue} leaves on runnable config before {@link RunnableNode.execute}.
+ * Resolves {@link import("../contracts/itemExpr").ItemExpr} leaves on runnable config before {@link RunnableNode.execute}.
  */
-export class ItemValueResolver {
+export class ItemExprResolver {
   async resolveConfigForItem<TConfig extends RunnableNodeConfig<any, any>>(
     ctx: NodeExecutionContext<TConfig>,
     item: Item,
@@ -12,9 +12,9 @@ export class ItemValueResolver {
     items: ReadonlyArray<Item>,
   ): Promise<NodeExecutionContext<TConfig>> {
     if (!ctx) {
-      throw new Error("ItemValueResolver.resolveConfigForItem: ctx is required");
+      throw new Error("ItemExprResolver.resolveConfigForItem: ctx is required");
     }
-    const resolvedConfig = await resolveItemValuesForExecution(ctx.config, ctx, item, itemIndex, items);
+    const resolvedConfig = await resolveItemExprsForExecution(ctx.config, ctx, item, itemIndex, items);
     const merged = resolvedConfig !== undefined && resolvedConfig !== null ? resolvedConfig : ctx.config;
     if (merged === undefined || merged === null) {
       return ctx;

package/src/execution/NodeExecutor.ts

@@ -3,10 +3,8 @@ import { isPortsEmission, isUnbrandedPortsEmissionShape } from "../contracts/emi
 
 import type {
   Item,
-  LineageCarryPolicy,
   MultiInputNode,
   NodeActivationRequest,
-  NodeConfigBase,
   NodeExecutionContext,
   NodeOutputs,
   RunnableNode,
@@ -17,21 +15,25 @@ import type {
 } from "../types";
 
 import { FanInMergeByOriginMerger } from "./FanInMergeByOriginMerger";
-import { ItemValueResolver } from "./ItemValueResolver";
+import { ItemExprResolver } from "./ItemExprResolver";
 import { InProcessRetryRunner } from "./InProcessRetryRunner";
 import { NodeOutputNormalizer } from "./NodeOutputNormalizer";
+import { RunnableOutputBehaviorResolver } from "./RunnableOutputBehaviorResolver";
 
 export class NodeExecutor {
   private readonly fanInMerger = new FanInMergeByOriginMerger();
   private readonly outputNormalizer = new NodeOutputNormalizer();
-  private readonly itemValueResolver: ItemValueResolver;
+  private readonly itemExprResolver: ItemExprResolver;
+  private readonly outputBehaviorResolver: RunnableOutputBehaviorResolver;
 
   constructor(
     private readonly nodeInstanceFactory: WorkflowNodeInstanceFactory,
     private readonly retryRunner: InProcessRetryRunner,
-    itemValueResolver?: ItemValueResolver,
+    itemExprResolver?: ItemExprResolver,
+    outputBehaviorResolver?: RunnableOutputBehaviorResolver,
   ) {
-    this.itemValueResolver = itemValueResolver ?? new ItemValueResolver();
+    this.itemExprResolver = itemExprResolver ?? new ItemExprResolver();
+    this.outputBehaviorResolver = outputBehaviorResolver ?? new RunnableOutputBehaviorResolver();
   }
 
   async execute(request: NodeActivationRequest): Promise<NodeOutputs> {
@@ -126,14 +128,14 @@ export class NodeExecutor {
     node: RunnableNode,
   ): Promise<NodeOutputs> {
     const runnableConfig = request.ctx.config as RunnableNodeConfig;
-    const carry = this.resolveLineageCarry(node, runnableConfig);
+    const behavior = this.outputBehaviorResolver.resolve(runnableConfig);
     const inputSchema = this.resolveInputSchema(node, runnableConfig);
     const inputBatch = request.input ?? [];
     if (inputBatch.length === 0 && runnableConfig.emptyBatchExecution === "runOnce") {
       const syntheticItem: Item = { json: {} };
       const parsed = inputSchema.parse(syntheticItem.json);
       const runnableCtx = request.ctx as NodeExecutionContext<RunnableNodeConfig>;
-      const resolvedCtx = await this.itemValueResolver.resolveConfigForItem(runnableCtx, syntheticItem, 0, inputBatch);
+      const resolvedCtx = await this.itemExprResolver.resolveConfigForItem(runnableCtx, syntheticItem, 0, inputBatch);
       const ctx = this.pickExecutionContext(runnableCtx, resolvedCtx);
       const args: RunnableNodeExecuteArgs = {
         input: parsed,
@@ -146,7 +148,7 @@ export class NodeExecutor {
       return this.outputNormalizer.normalizeExecuteResult({
         baseItem: syntheticItem,
         raw,
-        carry,
+        behavior,
       }) as NodeOutputs;
     }
     const byPort: Partial<Record<string, Item[]>> = {};
@@ -155,7 +157,7 @@ export class NodeExecutor {
       this.assertItemJsonNotTopLevelArray(request.nodeId, item);
       const parsed = inputSchema.parse(item.json);
       const runnableCtx = request.ctx as NodeExecutionContext<RunnableNodeConfig>;
-      const resolvedCtx = await this.itemValueResolver.resolveConfigForItem(runnableCtx, item, i, inputBatch);
+      const resolvedCtx = await this.itemExprResolver.resolveConfigForItem(runnableCtx, item, i, inputBatch);
       const ctx = this.pickExecutionContext(runnableCtx, resolvedCtx);
       const args: RunnableNodeExecuteArgs = {
         input: parsed,
@@ -168,7 +170,7 @@ export class NodeExecutor {
       const normalized = this.outputNormalizer.normalizeExecuteResult({
         baseItem: item,
         raw,
-        carry,
+        behavior,
       });
       for (const [port, batch] of Object.entries(normalized)) {
         if (!batch || batch.length === 0) {
@@ -226,24 +228,4 @@ export class NodeExecutor {
       );
     }
   }
-
-  private resolveLineageCarry(node: unknown, config: RunnableNodeConfig): LineageCarryPolicy {
-    if (config.lineageCarry) {
-      return config.lineageCarry;
-    }
-
-    const base = config as NodeConfigBase;
-    const declared = base.declaredOutputPorts;
-    const ports =
-      declared && declared.length > 0
-        ? [...new Set([...(declared as readonly string[]), ...(base.nodeErrorHandler ? ["error"] : [])])]
-        : base.nodeErrorHandler
-          ? (["main", "error"] as const)
-          : (["main"] as const);
-
-    if (ports.length > 1) {
-      return "carryThrough";
-    }
-    return "emitOnly";
-  }
 }

package/src/execution/NodeExecutorFactory.ts

@@ -2,9 +2,14 @@ import type { WorkflowNodeInstanceFactory } from "../types";
 
 import { InProcessRetryRunner } from "./InProcessRetryRunner";
 import { NodeExecutor } from "./NodeExecutor";
+import { RunnableOutputBehaviorResolver } from "./RunnableOutputBehaviorResolver";
 
 export class NodeExecutorFactory {
-  create(workflowNodeInstanceFactory: WorkflowNodeInstanceFactory, retryRunner: InProcessRetryRunner): NodeExecutor {
-    return new NodeExecutor(workflowNodeInstanceFactory, retryRunner);
+  create(
+    workflowNodeInstanceFactory: WorkflowNodeInstanceFactory,
+    retryRunner: InProcessRetryRunner,
+    outputBehaviorResolver: RunnableOutputBehaviorResolver,
+  ): NodeExecutor {
+    return new NodeExecutor(workflowNodeInstanceFactory, retryRunner, undefined, outputBehaviorResolver);
   }
 }