@codemation/core 0.3.0 → 0.5.0

package/dist/{runtime-ZJUpWmPH.cjs → runtime-feFn8OmG.cjs}

@@ -164,6 +164,74 @@ function chatModel(options = {}) {
 	return InjectableRuntimeDecoratorComposer.compose("chatModel", options, require("url").pathToFileURL(__filename).href);
 }
 
+//#endregion
+//#region src/contracts/itemValue.ts
+const ITEM_VALUE_BRAND = Symbol.for("codemation.itemValue");
+function itemValue(fn) {
+	return {
+		[ITEM_VALUE_BRAND]: true,
+		fn
+	};
+}
+function isItemValue(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const v = value;
+	if (v[ITEM_VALUE_BRAND] === true) return true;
+	const keys = Object.keys(v);
+	if (keys.length === 1 && keys[0] === "fn" && typeof v.fn === "function") return true;
+	for (const sym of Object.getOwnPropertySymbols(v)) if (sym.description === "codemation.itemValue" && v[sym] === true) return true;
+	return false;
+}
+function containsItemValueInUnknown(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (isItemValue(value)) return true;
+	if (value === null || typeof value !== "object") return false;
+	if (seen.has(value)) return false;
+	seen.add(value);
+	if (Array.isArray(value)) return value.some((entry) => containsItemValueInUnknown(entry, seen));
+	for (const entry of Object.values(value)) if (containsItemValueInUnknown(entry, seen)) return true;
+	return false;
+}
+/**
+* Deep-resolves {@link itemValue} leaves. Returns a new graph (does not mutate the original config object).
+*/
+async function resolveItemValuesInUnknown(value, args, seen = /* @__PURE__ */ new WeakSet()) {
+	if (isItemValue(value)) return await Promise.resolve(value.fn(args));
+	if (value === null || typeof value !== "object") return value;
+	if (seen.has(value)) return value;
+	seen.add(value);
+	if (Array.isArray(value)) {
+		const out$1 = [];
+		for (let i = 0; i < value.length; i++) out$1.push(await resolveItemValuesInUnknown(value[i], args, seen));
+		return out$1;
+	}
+	const rec = value;
+	const entries = Object.entries(rec);
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null && entries.length === 0) return value;
+	const out = Object.create(proto);
+	for (const [k, v] of entries) out[k] = await resolveItemValuesInUnknown(v, args, seen);
+	return out;
+}
+/**
+* Clones runnable config (best-effort) so per-item {@link itemValue} resolution never mutates shared instances.
+*/
+async function resolveItemValuesForExecution(config, nodeCtx, item, itemIndex, items) {
+	const ivArgs = {
+		item,
+		itemIndex,
+		items,
+		ctx: {
+			runId: nodeCtx.runId,
+			workflowId: nodeCtx.workflowId,
+			nodeId: nodeCtx.nodeId,
+			activationId: nodeCtx.activationId,
+			data: nodeCtx.data
+		}
+	};
+	if (!containsItemValueInUnknown(config)) return;
+	return await resolveItemValuesInUnknown(config, ivArgs);
+}
+
 //#endregion
 //#region src/workflow/definition/ConnectionNodeIdFactory.ts
 /**
@@ -591,6 +659,64 @@ var ActivationEnqueueService = class {
 	}
 };
 
+//#endregion
+//#region src/contracts/itemMeta.ts
+/**
+* Reads `meta._cm.originIndex` when present (used for fan-in merge-by-origin and Merge routing).
+*/
+function getOriginIndexFromItem(item) {
+	const v = (item.meta?._cm)?.originIndex;
+	return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+
+//#endregion
+//#region src/execution/FanInMergeByOriginMerger.ts
+/**
+* Default fan-in: combine multi-port {@link NodeInputsByPort} into one {@link Items} batch for per-item nodes.
+*
+* This is used when a single-input per-item node has multiple inbound edges (for example, branch reconverge
+* after an `If` / `Switch`). The default behavior is **append / union** (preserving item payloads) with a
+* deterministic order:
+*
+* - When router origin metadata exists (`meta._cm.originIndex`), items are sorted by origin index so the
+*   downstream batch preserves original ordering across branches.
+* - Otherwise, items are appended by port-key order, preserving each port's local order.
+*/
+var FanInMergeByOriginMerger = class {
+	merge(inputsByPort) {
+		const portKeys = Object.keys(inputsByPort).sort();
+		if (portKeys.length === 0) return [];
+		if (portKeys.length === 1) return [...inputsByPort[portKeys[0]] ?? []];
+		const entries = [];
+		let anyOrigin = false;
+		for (let p = 0; p < portKeys.length; p++) {
+			const portKey = portKeys[p];
+			const items = inputsByPort[portKey] ?? [];
+			for (let i = 0; i < items.length; i++) {
+				const item = items[i];
+				const originIndex = getOriginIndexFromItem(item);
+				if (originIndex !== void 0) anyOrigin = true;
+				entries.push({
+					portKey,
+					portIndex: i,
+					item,
+					originIndex
+				});
+			}
+		}
+		if (!anyOrigin) return entries.map((e) => e.item);
+		const missingOriginRank = Number.MAX_SAFE_INTEGER;
+		return entries.slice().sort((a, b) => {
+			const ao = a.originIndex ?? missingOriginRank;
+			const bo = b.originIndex ?? missingOriginRank;
+			if (ao !== bo) return ao - bo;
+			const pk = a.portKey.localeCompare(b.portKey);
+			if (pk !== 0) return pk;
+			return a.portIndex - b.portIndex;
+		}).map((e) => e.item);
+	}
+};
+
 //#endregion
 //#region src/execution/NodeInputContractError.ts
 var NodeInputContractError = class extends Error {
@@ -606,45 +732,58 @@ var NodeInputContractError = class extends Error {
 //#endregion
 //#region src/execution/NodeActivationRequestInputPreparer.ts
 /**
-* Maps and validates per-item inputs for {@link ItemNode} before enqueue persistence.
+* Validates per-item inputs for {@link RunnableNode} before enqueue persistence (Zod on `item.json`).
+* Does not rewrite `item.json` (wire stays as emitted upstream; engine passes parsed input via `execute` args).
+* Converts multi-input activations into a single-input batch when the node is per-item only (engine fan-in).
 */
 var NodeActivationRequestInputPreparer = class {
+	fanInMerger = new FanInMergeByOriginMerger();
 	constructor(workflowNodeInstanceFactory) {
 		this.workflowNodeInstanceFactory = workflowNodeInstanceFactory;
 	}
 	async prepare(request) {
-		if (request.kind !== "single") return request;
+		if (request.kind === "multi") return await this.prepareMulti(request);
+		return await this.prepareSingle(request);
+	}
+	async prepareMulti(request) {
 		const nodeInstance = this.workflowNodeInstanceFactory.createByType(request.ctx.config.type);
-		if (!this.hasExecuteOne(nodeInstance)) return request;
+		if (!this.hasRunnableExecute(nodeInstance) || this.hasExecuteMulti(nodeInstance) || this.isTriggerNode(nodeInstance)) return request;
+		const merged = this.fanInMerger.merge(request.inputsByPort);
+		const single = {
+			...request,
+			kind: "single",
+			input: merged
+		};
+		return await this.prepareSingle(single);
+	}
+	async prepareSingle(request) {
+		const nodeInstance = this.workflowNodeInstanceFactory.createByType(request.ctx.config.type);
+		if (!this.hasRunnableExecute(nodeInstance) || this.isTriggerNode(nodeInstance)) return request;
 		const inputSchema = this.resolveInputSchema(nodeInstance, request.ctx.config);
-		const config = request.ctx.config;
-		const mappedItems = [];
-		for (let i = 0; i < request.input.length; i++) {
-			const item = request.input[i];
+		const inputBatch = request.input ?? [];
+		for (let i = 0; i < inputBatch.length; i++) {
+			const item = inputBatch[i];
 			try {
-				const mappedRaw = config.mapInput ? await Promise.resolve(config.mapInput({
-					item,
-					itemIndex: i,
-					items: request.input,
-					ctx: request.ctx
-				})) : item.json;
-				const parsed = inputSchema.parse(mappedRaw);
-				mappedItems.push({
-					...item,
-					json: parsed
-				});
+				if (Array.isArray(item.json)) throw new Error("Item JSON must not be a top-level array");
+				inputSchema.parse(item.json);
 			} catch (cause) {
 				const message = this.formatContractFailure(cause);
 				throw new NodeInputContractError(`Node ${request.nodeId} activation ${request.activationId}: input contract failed: ${message}`, request.nodeId, request.activationId, cause);
 			}
 		}
-		return {
+		return request.input === void 0 ? {
 			...request,
-			input: mappedItems
-		};
+			input: inputBatch
+		} : request;
+	}
+	isTriggerNode(nodeInstance) {
+		return typeof nodeInstance === "object" && nodeInstance !== null && nodeInstance.kind === "trigger";
+	}
+	hasRunnableExecute(nodeInstance) {
+		return typeof nodeInstance === "object" && nodeInstance !== null && nodeInstance.kind === "node" && typeof nodeInstance.execute === "function";
 	}
-	hasExecuteOne(nodeInstance) {
-		return typeof nodeInstance === "object" && nodeInstance !== null && typeof nodeInstance.executeOne === "function";
+	hasExecuteMulti(nodeInstance) {
+		return typeof nodeInstance.executeMulti === "function";
 	}
 	resolveInputSchema(nodeInstance, config) {
 		const fromInstance = nodeInstance.inputSchema;
@@ -801,6 +940,87 @@ var InProcessRetryRunner = class InProcessRetryRunner {
 	}
 };
 
+//#endregion
+//#region src/execution/ItemValueResolver.ts
+/**
+* Resolves {@link import("../contracts/itemValue").ItemValue} leaves on runnable config before {@link RunnableNode.execute}.
+*/
+var ItemValueResolver = class {
+	async resolveConfigForItem(ctx, item, itemIndex, items) {
+		if (!ctx) throw new Error("ItemValueResolver.resolveConfigForItem: ctx is required");
+		const resolvedConfig = await resolveItemValuesForExecution(ctx.config, ctx, item, itemIndex, items);
+		const merged = resolvedConfig !== void 0 && resolvedConfig !== null ? resolvedConfig : ctx.config;
+		if (merged === void 0 || merged === null) return ctx;
+		return {
+			...ctx,
+			config: merged
+		};
+	}
+};
+
+//#endregion
+//#region src/contracts/emitPorts.ts
+const EMIT_PORTS_BRAND = Symbol.for("codemation.emitPorts");
+function emitPorts(ports) {
+	return {
+		[EMIT_PORTS_BRAND]: true,
+		ports
+	};
+}
+function isPortsEmission(value) {
+	return typeof value === "object" && value !== null && EMIT_PORTS_BRAND in value && value[EMIT_PORTS_BRAND] === true;
+}
+function isUnbrandedPortsEmissionShape(value) {
+	return typeof value === "object" && value !== null && "ports" in value && !isPortsEmission(value);
+}
+
+//#endregion
+//#region src/execution/NodeOutputNormalizer.ts
+var NodeOutputNormalizer = class {
+	normalizeExecuteResult(args) {
+		const { baseItem, raw, carry } = args;
+		if (isPortsEmission(raw)) return this.emitPortsToOutputs(baseItem, raw, carry);
+		if (isUnbrandedPortsEmissionShape(raw)) throw new Error("execute() returned an unbranded `{ ports: ... }` object. Use emitPorts(...) for multi-port runnable outputs.");
+		if (Array.isArray(raw)) return this.arrayFanOutToMain(baseItem, raw, carry);
+		if (this.isItemLike(raw)) return { main: [this.applyLineage(baseItem, raw, carry)] };
+		return { main: [this.applyLineage(baseItem, { json: raw }, carry)] };
+	}
+	arrayFanOutToMain(baseItem, raw, carry) {
+		for (const el of raw) if (Array.isArray(el)) throw new Error("execute() fan-out arrays must contain only non-array JSON elements (nested arrays belong inside objects).");
+		return { main: raw.map((json) => this.applyLineage(baseItem, { json }, carry)) };
+	}
+	emitPortsToOutputs(baseItem, emission, carry) {
+		const out = {};
+		for (const [port, payload] of Object.entries(emission.ports)) {
+			if (payload === void 0) continue;
+			out[port] = this.normalizePortPayload(baseItem, payload, carry);
+		}
+		return out;
+	}
+	normalizePortPayload(baseItem, payload, carry) {
+		if (payload.length === 0) return [];
+		const el0 = payload[0];
+		if (this.isItemLike(el0)) return payload.map((it) => this.applyLineage(baseItem, it, carry));
+		return payload.map((json) => this.applyLineage(baseItem, { json }, carry));
+	}
+	isItemLike(value) {
+		return typeof value === "object" && value !== null && "json" in value;
+	}
+	applyLineage(baseItem, next, carry) {
+		if (carry === "carryThrough") return {
+			...baseItem,
+			...next,
+			json: next.json
+		};
+		return {
+			json: next.json,
+			...next.binary ? { binary: next.binary } : {},
+			...next.meta ? { meta: next.meta } : {},
+			...next.paired ? { paired: next.paired } : {}
+		};
+	}
+};
+
 //#endregion
 //#region src/execution/InProcessRetryRunnerFactory.ts
 var InProcessRetryRunnerFactory = class {
@@ -840,6 +1060,21 @@ var NodeActivationRequestComposer = class {
 			ctx
 		};
 	}
+	createMultiFromDefinitionWithActivation(args) {
+		const ctx = this.createNodeExecutionContext(args, args.definition, args.activationId);
+		return {
+			kind: "multi",
+			runId: args.runId,
+			activationId: args.activationId,
+			workflowId: args.workflowId,
+			nodeId: args.definition.id,
+			parent: args.parent,
+			executionOptions: args.executionOptions,
+			batchId: args.batchId,
+			inputsByPort: args.inputsByPort,
+			ctx
+		};
+	}
 	createFromPlannedActivation(args) {
 		const activationId = this.activationIdFactory.makeActivationId();
 		const ctx = this.createNodeExecutionContext(args, args.nodeDefinition, activationId);
@@ -887,49 +1122,152 @@ var NodeActivationRequestComposer = class {
 //#endregion
 //#region src/execution/NodeExecutor.ts
 var NodeExecutor = class {
-	constructor(nodeInstanceFactory, retryRunner) {
+	fanInMerger = new FanInMergeByOriginMerger();
+	outputNormalizer = new NodeOutputNormalizer();
+	itemValueResolver;
+	constructor(nodeInstanceFactory, retryRunner, itemValueResolver) {
 		this.nodeInstanceFactory = nodeInstanceFactory;
 		this.retryRunner = retryRunner;
+		this.itemValueResolver = itemValueResolver ?? new ItemValueResolver();
 	}
 	async execute(request) {
 		const policy = request.ctx.config.retryPolicy;
 		return await this.retryRunner.run(policy, async () => {
 			const nodeInstance = this.nodeInstanceFactory.createByType(request.ctx.config.type);
-			if (request.kind === "multi") return await this.executeMultiInputNode(request, nodeInstance);
+			if (request.kind === "multi") return await this.executeMultiInputActivation(request, nodeInstance);
 			return await this.executeSingleInputNode(request, nodeInstance);
 		});
 	}
-	async executeMultiInputNode(request, node$1) {
+	async executeMultiInputActivation(request, node$1) {
 		const multiInputNode = node$1;
-		if (typeof multiInputNode.executeMulti !== "function") throw new Error(`Node ${request.nodeId} does not support executeMulti but received multi-input activation`);
-		return await multiInputNode.executeMulti(request.inputsByPort, request.ctx);
+		if (typeof multiInputNode.executeMulti === "function") {
+			const raw = await multiInputNode.executeMulti(request.inputsByPort, request.ctx);
+			this.assertNoPortEnvelopeBypass(request.nodeId, raw, "executeMulti()");
+			return raw;
+		}
+		if (this.isRunnableNode(node$1)) {
+			const merged = this.fanInMerger.merge(request.inputsByPort);
+			const single = {
+				...request,
+				kind: "single",
+				input: merged
+			};
+			return await this.executeRunnableActivation(single, node$1);
+		}
+		throw new Error(`Node ${request.nodeId} does not support executeMulti or RunnableNode.execute but received multi-input activation`);
 	}
 	async executeSingleInputNode(request, node$1) {
-		if (this.hasExecuteOne(node$1)) return await this.executeItemNode(request, node$1);
-		const singleInputNode = node$1;
-		if (typeof singleInputNode.execute !== "function") throw new Error(`Node ${request.nodeId} does not support execute but received single-input activation`);
-		return await singleInputNode.execute(request.input, request.ctx);
+		if (this.isTriggerNode(node$1)) {
+			const raw = await node$1.execute(request.input, request.ctx);
+			this.assertNoPortEnvelopeBypass(request.nodeId, raw, "trigger execute()");
+			return raw;
+		}
+		if (this.isRunnableNode(node$1)) return await this.executeRunnableActivation(request, node$1);
+		if (this.hasExecuteMulti(node$1)) return await this.executeMultiInputActivation(this.asMultiFromSingleActivation(request), node$1);
+		throw new Error(`Node ${request.nodeId} does not support trigger or RunnableNode execution`);
 	}
-	hasExecuteOne(node$1) {
-		return typeof node$1 === "object" && node$1 !== null && typeof node$1.executeOne === "function";
+	isTriggerNode(node$1) {
+		return typeof node$1 === "object" && node$1 !== null && node$1.kind === "trigger";
 	}
-	async executeItemNode(request, node$1) {
-		const out = [];
-		for (let i = 0; i < request.input.length; i++) {
-			const item = request.input[i];
-			const outputJson = await Promise.resolve(node$1.executeOne({
-				input: item.json,
+	isRunnableNode(node$1) {
+		return typeof node$1 === "object" && node$1 !== null && node$1.kind === "node" && typeof node$1.execute === "function";
+	}
+	hasExecuteMulti(node$1) {
+		return typeof node$1?.executeMulti === "function";
+	}
+	asMultiFromSingleActivation(request) {
+		return {
+			kind: "multi",
+			runId: request.runId,
+			activationId: request.activationId,
+			workflowId: request.workflowId,
+			nodeId: request.nodeId,
+			parent: request.parent,
+			executionOptions: request.executionOptions,
+			batchId: request.batchId,
+			ctx: request.ctx,
+			inputsByPort: { in: request.input ?? [] }
+		};
+	}
+	async executeRunnableActivation(request, node$1) {
+		const runnableConfig = request.ctx.config;
+		const carry = this.resolveLineageCarry(node$1, runnableConfig);
+		const inputSchema = this.resolveInputSchema(node$1, runnableConfig);
+		const inputBatch = request.input ?? [];
+		if (inputBatch.length === 0 && runnableConfig.emptyBatchExecution === "runOnce") {
+			const syntheticItem = { json: {} };
+			const parsed = inputSchema.parse(syntheticItem.json);
+			const runnableCtx = request.ctx;
+			const resolvedCtx = await this.itemValueResolver.resolveConfigForItem(runnableCtx, syntheticItem, 0, inputBatch);
+			const args = {
+				input: parsed,
+				item: syntheticItem,
+				itemIndex: 0,
+				items: inputBatch,
+				ctx: this.pickExecutionContext(runnableCtx, resolvedCtx)
+			};
+			const raw = await Promise.resolve(node$1.execute(args));
+			return this.outputNormalizer.normalizeExecuteResult({
+				baseItem: syntheticItem,
+				raw,
+				carry
+			});
+		}
+		const byPort = {};
+		for (let i = 0; i < inputBatch.length; i++) {
+			const item = inputBatch[i];
+			this.assertItemJsonNotTopLevelArray(request.nodeId, item);
+			const parsed = inputSchema.parse(item.json);
+			const runnableCtx = request.ctx;
+			const resolvedCtx = await this.itemValueResolver.resolveConfigForItem(runnableCtx, item, i, inputBatch);
+			const ctx = this.pickExecutionContext(runnableCtx, resolvedCtx);
+			const args = {
+				input: parsed,
 				item,
 				itemIndex: i,
-				items: request.input,
-				ctx: request.ctx
-			}));
-			out.push({
-				...item,
-				json: outputJson
+				items: inputBatch,
+				ctx
+			};
+			const raw = await Promise.resolve(node$1.execute(args));
+			const normalized = this.outputNormalizer.normalizeExecuteResult({
+				baseItem: item,
+				raw,
+				carry
 			});
+			for (const [port, batch] of Object.entries(normalized)) {
+				if (!batch || batch.length === 0) continue;
+				const list = byPort[port] ?? [];
+				list.push(...batch);
+				byPort[port] = list;
+			}
 		}
-		return { main: out };
+		return byPort;
+	}
+	/** Use resolver ctx only when {@link NodeExecutionContext.config} is non-nullish. */
+	pickExecutionContext(runnableCtx, resolvedCtx) {
+		if (resolvedCtx != null && resolvedCtx.config != null) return resolvedCtx;
+		return runnableCtx;
+	}
+	resolveInputSchema(nodeInstance, config) {
+		const fromInstance = nodeInstance.inputSchema;
+		if (fromInstance && typeof fromInstance.parse === "function") return fromInstance;
+		const fromConfig = config.inputSchema;
+		if (fromConfig && typeof fromConfig.parse === "function") return fromConfig;
+		return zod.z.unknown();
+	}
+	assertItemJsonNotTopLevelArray(nodeId, item) {
+		if (Array.isArray(item.json)) throw new Error(`Node ${nodeId}: item.json must not be a top-level JSON array`);
+	}
+	assertNoPortEnvelopeBypass(nodeId, value, methodName) {
+		if (isPortsEmission(value)) throw new Error(`Node ${nodeId}: ${methodName} must return NodeOutputs, not emitPorts(...).`);
+		if (isUnbrandedPortsEmissionShape(value)) throw new Error(`Node ${nodeId}: ${methodName} returned an unbranded \`{ ports: ... }\` object. Return NodeOutputs instead.`);
+	}
+	resolveLineageCarry(node$1, config) {
+		if (config.lineageCarry) return config.lineageCarry;
+		const base = config;
+		const declared = base.declaredOutputPorts;
+		if ((declared && declared.length > 0 ? [...new Set([...declared, ...base.nodeErrorHandler ? ["error"] : []])] : base.nodeErrorHandler ? ["main", "error"] : ["main"]).length > 1) return "carryThrough";
+		return "emitOnly";
 	}
 };
 
@@ -1007,8 +1345,8 @@ var MissingRuntimeFallbacks = class {
 var MissingRuntimeNode = class {
 	kind = "node";
 	outputPorts = ["main"];
-	async execute(items) {
-		return { main: items };
+	execute(args) {
+		return args.item;
 	}
 };
 
@@ -1197,6 +1535,7 @@ var WorkflowSnapshotCodec = class {
 	}
 	restoreNonSerializableProperties(liveRecord, hydrated) {
 		for (const [key, value] of Object.entries(liveRecord)) if (typeof value === "function" || typeof value === "symbol") hydrated[key] = value;
+		for (const sym of Object.getOwnPropertySymbols(liveRecord)) hydrated[sym] = liveRecord[sym];
 	}
 	restoreTypeProperty(record) {
 		const tokenId = typeof record.tokenId === "string" ? record.tokenId : void 0;
@@ -1216,7 +1555,10 @@ var WorkflowSnapshotCodec = class {
 	}
 	asRecord(value) {
 		if (!value || typeof value !== "object" || Array.isArray(value)) return {};
-		return { ...value };
+		const record = value;
+		const out = { ...record };
+		for (const sym of Object.getOwnPropertySymbols(value)) out[sym] = record[sym];
+		return out;
 	}
 };
 
@@ -1593,19 +1935,6 @@ var WorkflowTopology = class WorkflowTopology {
 		const classifier = WorkflowExecutableNodeClassifierFactory.create(wf);
 		const defs = /* @__PURE__ */ new Map();
 		for (const n of wf.nodes) if (classifier.isExecutableNodeId(n.id)) defs.set(n.id, n);
-		const outgoing = /* @__PURE__ */ new Map();
-		for (const e of wf.edges) {
-			if (!classifier.isExecutableNodeId(e.from.nodeId) || !classifier.isExecutableNodeId(e.to.nodeId)) continue;
-			const list = outgoing.get(e.from.nodeId) ?? [];
-			list.push({
-				output: e.from.output,
-				to: {
-					nodeId: e.to.nodeId,
-					input: e.to.input
-				}
-			});
-			outgoing.set(e.from.nodeId, list);
-		}
 		const incomingByNode = /* @__PURE__ */ new Map();
 		for (const e of wf.edges) {
 			if (!classifier.isExecutableNodeId(e.from.nodeId) || !classifier.isExecutableNodeId(e.to.nodeId)) continue;
@@ -1615,21 +1944,51 @@ var WorkflowTopology = class WorkflowTopology {
 					nodeId: e.from.nodeId,
 					output: e.from.output
 				},
-				input: e.to.input
+				input: e.to.input,
+				collectKey: e.to.input
 			});
 			incomingByNode.set(e.to.nodeId, list);
 		}
-		const expected = /* @__PURE__ */ new Map();
-		for (const [toNodeId, inputs] of incomingByNode.entries()) {
+		const duplicateInputCounts = /* @__PURE__ */ new Map();
+		for (const [toNodeId, edges] of incomingByNode.entries()) {
 			const counts = /* @__PURE__ */ new Map();
-			for (const edge of inputs) counts.set(edge.input, (counts.get(edge.input) ?? 0) + 1);
-			for (const [k, n] of counts.entries()) if (n > 1) throw new Error(`Node ${toNodeId} has multiple edges into input '${k}'. Use a Merge node upstream.`);
+			for (const edge of edges) counts.set(edge.input, (counts.get(edge.input) ?? 0) + 1);
+			duplicateInputCounts.set(toNodeId, counts);
+		}
+		for (const [toNodeId, edges] of incomingByNode.entries()) {
+			const counts = duplicateInputCounts.get(toNodeId) ?? /* @__PURE__ */ new Map();
+			for (let i = 0; i < edges.length; i++) {
+				const edge = edges[i];
+				const collectKey = (counts.get(edge.input) ?? 0) > 1 ? `${edge.from.nodeId}:${edge.from.output}` : edge.input;
+				edges[i] = {
+					...edge,
+					collectKey
+				};
+			}
+		}
+		const outgoing = /* @__PURE__ */ new Map();
+		for (const e of wf.edges) {
+			if (!classifier.isExecutableNodeId(e.from.nodeId) || !classifier.isExecutableNodeId(e.to.nodeId)) continue;
+			const collectKey = ((duplicateInputCounts.get(e.to.nodeId) ?? /* @__PURE__ */ new Map()).get(e.to.input) ?? 0) > 1 ? `${e.from.nodeId}:${e.from.output}` : e.to.input;
+			const list = outgoing.get(e.from.nodeId) ?? [];
+			list.push({
+				output: e.from.output,
+				to: {
+					nodeId: e.to.nodeId,
+					input: e.to.input,
+					collectKey
+				}
+			});
+			outgoing.set(e.from.nodeId, list);
+		}
+		const expected = /* @__PURE__ */ new Map();
+		for (const [toNodeId, edges] of incomingByNode.entries()) {
 			const order = [];
 			const seen = /* @__PURE__ */ new Set();
-			for (const edge of inputs) {
-				if (seen.has(edge.input)) continue;
-				seen.add(edge.input);
-				order.push(edge.input);
+			for (const edge of edges) {
+				if (seen.has(edge.collectKey)) continue;
+				seen.add(edge.collectKey);
+				order.push(edge.collectKey);
 			}
 			expected.set(toNodeId, order);
 		}
@@ -2135,6 +2494,11 @@ var RunContinuationService = class {
 			batchId
 		});
 		const next = planner.nextActivation(queue);
+		const finishedAt = completedSnapshot.finishedAt ?? completedSnapshot.updatedAt;
+		const mergedSnapshots = {
+			...args.state.nodeSnapshotsByNodeId ?? {},
+			[args.args.nodeId]: completedSnapshot
+		};
 		if (!next) {
 			const lastNodeId = WorkflowExecutableNodeClassifierFactory.create(args.workflow).lastExecutableNodeIdInDefinitionOrder(args.workflow);
 			const outputs = data.getOutputItems(lastNodeId, "main");
@@ -2144,11 +2508,8 @@ var RunContinuationService = class {
 				status: "completed",
 				queue: [],
 				outputsByNode: data.dump(),
-				nodeSnapshotsByNodeId: {
-					...args.state.nodeSnapshotsByNodeId ?? {},
-					[args.args.nodeId]: completedSnapshot
-				},
-				finishedAtIso: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
+				nodeSnapshotsByNodeId: mergedSnapshots,
+				finishedAtIso: finishedAt
 			});
 			await this.workflowExecutionRepository.save(completedState);
 			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
@@ -2183,11 +2544,8 @@ var RunContinuationService = class {
 				status: "failed",
 				queue: queue.map((q) => ({ ...q })),
 				outputsByNode: data.dump(),
-				nodeSnapshotsByNodeId: {
-					...args.state.nodeSnapshotsByNodeId ?? {},
-					[args.args.nodeId]: completedSnapshot
-				},
-				finishedAtIso: completedSnapshot.finishedAt ?? completedSnapshot.updatedAt
+				nodeSnapshotsByNodeId: mergedSnapshots,
+				finishedAtIso: finishedAt
 			});
 			await this.workflowExecutionRepository.save(failedState);
 			await this.nodeEventPublisher.publish("nodeCompleted", completedSnapshot);
@@ -2238,10 +2596,6 @@ var RunContinuationService = class {
 			executionOptions: args.state.executionOptions,
 			nodeDefinition: nextDefinition
 		});
-		const mergedSnapshots = {
-			...args.state.nodeSnapshotsByNodeId ?? {},
-			[args.args.nodeId]: completedSnapshot
-		};
 		try {
 			const { queuedSnapshot, result } = await this.activationEnqueueService.enqueueActivationWithSnapshot({
 				runId: args.state.runId,
@@ -2272,7 +2626,6 @@ var RunContinuationService = class {
 			return result;
 		} catch (cause) {
 			const error = cause instanceof Error ? cause : new Error(String(cause));
-			const finishedAt = completedSnapshot.finishedAt ?? completedSnapshot.updatedAt;
 			const result = await this.terminateRunAfterActivationEnqueueRejected({
 				wf: args.workflow,
 				state: args.state,
@@ -2560,7 +2913,7 @@ var CurrentStateFrontierPlanner = class CurrentStateFrontierPlanner {
 		const frontierNodeIds = [];
 		for (const nodeId of this.topology.defsById.keys()) {
 			if (!requiredNodeIds.has(nodeId) || this.isNodeSatisfied(currentState, nodeId)) continue;
-			if ((this.topology.incomingByNode.get(nodeId) ?? []).every((edge) => this.isEdgeSatisfied(currentState, nodeId, edge.input))) frontierNodeIds.push(nodeId);
+			if ((this.topology.incomingByNode.get(nodeId) ?? []).every((edge) => this.isEdgeSatisfied(currentState, nodeId, edge.collectKey))) frontierNodeIds.push(nodeId);
 		}
 		return frontierNodeIds;
 	}
@@ -2578,13 +2931,13 @@ var CurrentStateFrontierPlanner = class CurrentStateFrontierPlanner {
 		if (requiredNodeIds.has(nodeId)) return;
 		if (this.isNodeSatisfied(currentState, nodeId) && !this.isNodeSatisfiedByOutputsOnly(currentState, nodeId)) return;
 		requiredNodeIds.add(nodeId);
-		for (const edge of this.topology.incomingByNode.get(nodeId) ?? []) if (!this.isEdgeSatisfied(currentState, nodeId, edge.input) || this.isNodeSatisfiedByOutputsOnly(currentState, edge.from.nodeId)) this.collectRequiredNode(requiredNodeIds, currentState, edge.from.nodeId);
+		for (const edge of this.topology.incomingByNode.get(nodeId) ?? []) if (!this.isEdgeSatisfied(currentState, nodeId, edge.collectKey) || this.isNodeSatisfiedByOutputsOnly(currentState, edge.from.nodeId)) this.collectRequiredNode(requiredNodeIds, currentState, edge.from.nodeId);
 	}
 	buildFrontierQueue(nodeId, currentState) {
 		const incomingEdges = this.topology.incomingByNode.get(nodeId) ?? [];
 		if (incomingEdges.length === 0) return [];
 		const expectedInputs = this.topology.expectedInputsByNode.get(nodeId) ?? [];
-		if (expectedInputs.length !== 1 || expectedInputs[0] !== "in") {
+		if (this.usesCollect(nodeId)) {
 			const received = {};
 			for (const input$1 of expectedInputs) received[input$1] = this.resolveInput(currentState, nodeId, input$1);
 			return [{
@@ -2598,7 +2951,7 @@ var CurrentStateFrontierPlanner = class CurrentStateFrontierPlanner {
 			}];
 		}
 		const input = expectedInputs[0] ?? "in";
-		const incomingEdge = incomingEdges.find((edge) => edge.input === input);
+		const incomingEdge = incomingEdges.find((edge) => edge.collectKey === input);
 		return [{
 			nodeId,
 			input: this.resolveInput(currentState, nodeId, input),
@@ -2618,16 +2971,17 @@ var CurrentStateFrontierPlanner = class CurrentStateFrontierPlanner {
 	isNodeSatisfiedByOutputsOnly(currentState, nodeId) {
 		return this.hasOutputs(currentState, nodeId) && !this.hasCompletedSnapshot(currentState, nodeId);
 	}
-	isEdgeSatisfied(currentState, nodeId, input) {
-		const incomingEdge = (this.topology.incomingByNode.get(nodeId) ?? []).find((edge) => edge.input === input);
+	isEdgeSatisfied(currentState, nodeId, collectKey) {
+		const incomingEdge = (this.topology.incomingByNode.get(nodeId) ?? []).find((edge) => edge.collectKey === collectKey);
 		if (!incomingEdge) return false;
-		if (!this.hasOutputPort(currentState, incomingEdge.from.nodeId, incomingEdge.from.output)) return false;
+		const fromNodeId = incomingEdge.from.nodeId;
+		if (!this.isNodeSatisfied(currentState, fromNodeId)) return false;
 		if (this.usesCollect(nodeId)) return true;
-		if (this.resolveOutputItems(currentState, incomingEdge.from.nodeId, incomingEdge.from.output).length > 0) return true;
-		return this.shouldContinueAfterEmptyOutputFromSource(incomingEdge.from.nodeId);
+		if (this.resolveOutputItems(currentState, fromNodeId, incomingEdge.from.output).length > 0) return true;
+		return this.shouldContinueAfterEmptyOutputFromSource(fromNodeId);
 	}
-	resolveInput(currentState, nodeId, input) {
-		const incomingEdge = (this.topology.incomingByNode.get(nodeId) ?? []).find((edge) => edge.input === input);
+	resolveInput(currentState, nodeId, collectKey) {
+		const incomingEdge = (this.topology.incomingByNode.get(nodeId) ?? []).find((edge) => edge.collectKey === collectKey);
 		if (!incomingEdge) return [];
 		return this.resolveOutputItems(currentState, incomingEdge.from.nodeId, incomingEdge.from.output);
 	}
@@ -2638,17 +2992,13 @@ var CurrentStateFrontierPlanner = class CurrentStateFrontierPlanner {
 		const snapshot = currentState.nodeSnapshotsByNodeId[nodeId];
 		return snapshot?.status === "completed" || snapshot?.status === "skipped";
 	}
-	hasOutputPort(currentState, nodeId, output) {
-		const outputs = currentState.outputsByNode[nodeId];
-		if (!outputs) return false;
-		return Object.prototype.hasOwnProperty.call(outputs, output);
-	}
 	resolveOutputItems(currentState, nodeId, output) {
 		return currentState.outputsByNode[nodeId]?.[output] ?? [];
 	}
 	usesCollect(nodeId) {
 		const expectedInputs = this.topology.expectedInputsByNode.get(nodeId) ?? [];
-		return expectedInputs.length !== 1 || expectedInputs[0] !== "in";
+		if (expectedInputs.length !== 1 || expectedInputs[0] !== "in") return true;
+		return (this.topology.incomingByNode.get(nodeId) ?? []).length > 1;
 	}
 	shouldContinueAfterEmptyOutputFromSource(nodeId) {
 		const definition = this.topology.defsById.get(nodeId);
@@ -3540,7 +3890,6 @@ var NodeExecutionRequestHandlerService = class {
 		const resolvedParent = request.parent ?? state.parent;
 		const data = this.runDataFactory.create(state.outputsByNode);
 		const limits = this.resolveEngineLimitsFromState(state);
-		const persistedInput = pendingExecution.inputsByPort.in ?? request.input;
 		const base = this.runExecutionContextFactory.create({
 			runId: state.runId,
 			workflowId: state.workflowId,
@@ -3552,7 +3901,11 @@ var NodeExecutionRequestHandlerService = class {
 			data,
 			nodeState: this.nodeStatePublisherFactory.create(state.runId, state.workflowId, resolvedParent)
 		});
-		const activationRequest = this.nodeActivationRequestComposer.createSingleFromDefinitionWithActivation({
+		const inputsByPort = pendingExecution.inputsByPort;
+		const portKeys = Object.keys(inputsByPort);
+		const kind = portKeys.length === 1 && portKeys[0] === "in" ? "single" : "multi";
+		const batchId = pendingExecution.batchId ?? "batch_1";
+		const activationRequest = kind === "multi" ? this.nodeActivationRequestComposer.createMultiFromDefinitionWithActivation({
 			activationId: request.activationId,
 			runId: request.runId,
 			workflowId: request.workflowId,
@@ -3564,8 +3917,22 @@ var NodeExecutionRequestHandlerService = class {
 				id: definition.id,
 				config: definition.config
 			},
-			batchId: pendingExecution.batchId ?? "batch_1",
-			input: persistedInput
+			batchId,
+			inputsByPort
+		}) : this.nodeActivationRequestComposer.createSingleFromDefinitionWithActivation({
+			activationId: request.activationId,
+			runId: request.runId,
+			workflowId: request.workflowId,
+			parent: resolvedParent,
+			executionOptions: request.executionOptions ?? state.executionOptions,
+			base,
+			data,
+			definition: {
+				id: definition.id,
+				config: definition.config
+			},
+			batchId,
+			input: inputsByPort.in ?? request.input ?? []
 		});
 		await this.continuation.markNodeRunning({
 			runId: activationRequest.runId,
@@ -3650,7 +4017,7 @@ var RunQueuePlanner = class {
 				continue;
 			}
 			const inst = this.nodeInstances.get(toNodeId);
-			if (!this.isMultiInputNode(inst)) throw new Error(`Node ${toNodeId} has ${inputs.length} inbound edges. Insert a Merge node to combine branches.`);
+			if (!this.isMultiInputNode(inst) && !this.supportsEngineFanInMerge(inst)) throw new Error(`Node ${toNodeId} has ${inputs.length} inbound edges but does not support multi-input execution.`);
 		}
 	}
 	seedFromTrigger(args) {
@@ -3659,7 +4026,7 @@ var RunQueuePlanner = class {
 			if (e.output !== "main") continue;
 			this.enqueueEdge(queue, {
 				batchId: args.batchId,
-				to: e.to,
+				to: this.toEnqueueTarget(e),
 				from: {
 					nodeId: args.startNodeId,
 					output: "main"
@@ -3674,7 +4041,7 @@ var RunQueuePlanner = class {
 			const outItems = args.outputs[e.output] ?? [];
 			this.enqueueEdge(queue, {
 				batchId: args.batchId,
-				to: e.to,
+				to: this.toEnqueueTarget(e),
 				from: {
 					nodeId: args.fromNodeId,
 					output: e.output
@@ -3756,29 +4123,35 @@ var RunQueuePlanner = class {
 	*/
 	usesTopologyCollectMerge(toNodeId) {
 		const expectedInputs = this.topology.expectedInputsByNode.get(toNodeId) ?? [];
-		return expectedInputs.length !== 1 || expectedInputs[0] !== "in";
+		if (expectedInputs.length !== 1 || expectedInputs[0] !== "in") return true;
+		return (this.topology.incomingByNode.get(toNodeId) ?? []).length > 1;
 	}
-	enqueueEdge(queue, args) {
+	toEnqueueTarget(edge) {
+		return edge.to;
+	}
+	enqueueEdge(queue, args, emptyPathSourceNodeId) {
 		const target = this.nodeInstances.get(args.to.nodeId);
 		if (!(this.usesTopologyCollectMerge(args.to.nodeId) || this.isMultiInputNode(target))) {
 			if (args.items.length === 0) {
-				if (this.shouldContinueAfterEmptyOutputFromSource(args.from.nodeId)) {
+				const continueSourceNodeId = emptyPathSourceNodeId ?? args.from.nodeId;
+				if (this.shouldContinueAfterEmptyOutputFromSource(continueSourceNodeId)) {
 					queue.push({
 						nodeId: args.to.nodeId,
 						input: args.items,
-						toInput: args.to.input,
+						toInput: args.to.collectKey,
 						batchId: args.batchId,
 						from: args.from
 					});
 					return;
 				}
-				this.propagateEmptyPath(queue, args.to.nodeId, args.batchId);
+				const source = emptyPathSourceNodeId ?? args.from.nodeId;
+				this.propagateEmptyPath(queue, args.to.nodeId, args.batchId, source);
 				return;
 			}
 			queue.push({
 				nodeId: args.to.nodeId,
 				input: args.items,
-				toInput: args.to.input,
+				toInput: args.to.collectKey,
 				batchId: args.batchId,
 				from: args.from
 			});
@@ -3799,14 +4172,14 @@ var RunQueuePlanner = class {
 			queue.push(collect);
 		}
 		const received = collect.collect.received;
-		received[args.to.input] = args.items;
+		received[args.to.collectKey] = args.items;
 	}
 	shouldContinueAfterEmptyOutputFromSource(fromNodeId) {
 		const def = this.topology.defsById.get(fromNodeId);
 		if (!def) return false;
 		return def.config.continueWhenEmptyOutput === true;
 	}
-	propagateEmptyPath(queue, nodeId, batchId) {
+	propagateEmptyPath(queue, nodeId, batchId, emptyPathSourceNodeId) {
 		for (const edge of this.topology.outgoingByNode.get(nodeId) ?? []) this.enqueueEdge(queue, {
 			batchId,
 			to: edge.to,
@@ -3815,11 +4188,17 @@ var RunQueuePlanner = class {
 				output: edge.output
 			},
 			items: []
-		});
+		}, emptyPathSourceNodeId);
 	}
 	isMultiInputNode(n) {
 		return typeof n?.executeMulti === "function";
 	}
+	hasRunnableExecute(n) {
+		return typeof n === "object" && n !== null && n.kind === "node" && typeof n.execute === "function";
+	}
+	supportsEngineFanInMerge(n) {
+		return this.hasRunnableExecute(n) && !this.isMultiInputNode(n);
+	}
 	describeUnsatisfiedCollect(queueEntry) {
 		const batchId = queueEntry.batchId ?? "batch_1";
 		const expectedInputs = queueEntry.collect?.expectedInputs ?? [];
@@ -3851,7 +4230,7 @@ var RunQueuePlanner = class {
 	}
 	findSources(nodeId, input) {
 		const matches = [];
-		for (const [sourceNodeId, edges] of this.topology.outgoingByNode.entries()) for (const edge of edges) if (edge.to.nodeId === nodeId && edge.to.input === input) matches.push(this.formatNodeLabel(sourceNodeId));
+		for (const [sourceNodeId, edges] of this.topology.outgoingByNode.entries()) for (const edge of edges) if (edge.to.nodeId === nodeId && edge.to.collectKey === input) matches.push(this.formatNodeLabel(sourceNodeId));
 		return matches;
 	}
 	formatInputList(inputs) {
@@ -4658,6 +5037,12 @@ Object.defineProperty(exports, 'InlineDrivingScheduler', {
     return InlineDrivingScheduler;
   }
 });
+Object.defineProperty(exports, 'ItemValueResolver', {
+  enumerable: true,
+  get: function () {
+    return ItemValueResolver;
+  }
+});
 Object.defineProperty(exports, 'LocalOnlyScheduler', {
   enumerable: true,
   get: function () {
@@ -4700,6 +5085,12 @@ Object.defineProperty(exports, 'NodeInstanceFactoryFactory', {
     return NodeInstanceFactoryFactory;
   }
 });
+Object.defineProperty(exports, 'NodeOutputNormalizer', {
+  enumerable: true,
+  get: function () {
+    return NodeOutputNormalizer;
+  }
+});
 Object.defineProperty(exports, 'PersistedRuntimeTypeMetadataStore', {
   enumerable: true,
   get: function () {
@@ -4814,22 +5205,70 @@ Object.defineProperty(exports, 'chatModel', {
     return chatModel;
   }
 });
+Object.defineProperty(exports, 'emitPorts', {
+  enumerable: true,
+  get: function () {
+    return emitPorts;
+  }
+});
+Object.defineProperty(exports, 'getOriginIndexFromItem', {
+  enumerable: true,
+  get: function () {
+    return getOriginIndexFromItem;
+  }
+});
 Object.defineProperty(exports, 'getPersistedRuntimeTypeMetadata', {
   enumerable: true,
   get: function () {
     return getPersistedRuntimeTypeMetadata;
   }
 });
+Object.defineProperty(exports, 'isItemValue', {
+  enumerable: true,
+  get: function () {
+    return isItemValue;
+  }
+});
+Object.defineProperty(exports, 'isPortsEmission', {
+  enumerable: true,
+  get: function () {
+    return isPortsEmission;
+  }
+});
+Object.defineProperty(exports, 'isUnbrandedPortsEmissionShape', {
+  enumerable: true,
+  get: function () {
+    return isUnbrandedPortsEmissionShape;
+  }
+});
+Object.defineProperty(exports, 'itemValue', {
+  enumerable: true,
+  get: function () {
+    return itemValue;
+  }
+});
 Object.defineProperty(exports, 'node', {
   enumerable: true,
   get: function () {
     return node;
   }
 });
+Object.defineProperty(exports, 'resolveItemValuesForExecution', {
+  enumerable: true,
+  get: function () {
+    return resolveItemValuesForExecution;
+  }
+});
+Object.defineProperty(exports, 'resolveItemValuesInUnknown', {
+  enumerable: true,
+  get: function () {
+    return resolveItemValuesInUnknown;
+  }
+});
 Object.defineProperty(exports, 'tool', {
   enumerable: true,
   get: function () {
     return tool;
   }
 });
-//# sourceMappingURL=runtime-ZJUpWmPH.cjs.map
+//# sourceMappingURL=runtime-feFn8OmG.cjs.map