@codemation/core 0.2.3 → 0.4.0

package/dist/{runtime-Cy-3FTI_.js → runtime-BdH94eBR.js}

@@ -137,6 +137,74 @@ function chatModel(options = {}) {
 	return InjectableRuntimeDecoratorComposer.compose("chatModel", options, import.meta.url);
 }
 
+//#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
 /**
@@ -564,6 +632,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 {
@@ -579,45 +705,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.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.hasExecuteOne(nodeInstance)) return request;
+		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";
 	}
-	hasExecuteOne(nodeInstance) {
-		return typeof nodeInstance === "object" && nodeInstance !== null && typeof nodeInstance.executeOne === "function";
+	hasRunnableExecute(nodeInstance) {
+		return typeof nodeInstance === "object" && nodeInstance !== null && nodeInstance.kind === "node" && typeof nodeInstance.execute === "function";
+	}
+	hasExecuteMulti(nodeInstance) {
+		return typeof nodeInstance.executeMulti === "function";
 	}
 	resolveInputSchema(nodeInstance, config) {
 		const fromInstance = nodeInstance.inputSchema;
@@ -774,6 +913,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 {
@@ -813,6 +1033,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);
@@ -860,49 +1095,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 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";
 	}
 };
 
@@ -980,8 +1318,8 @@ var MissingRuntimeFallbacks = class {
 var MissingRuntimeNode = class {
 	kind = "node";
 	outputPorts = ["main"];
-	async execute(items) {
-		return { main: items };
+	execute(args) {
+		return args.item;
 	}
 };
 
@@ -1170,6 +1508,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;
@@ -1189,7 +1528,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;
 	}
 };
 
@@ -1566,19 +1908,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;
@@ -1588,21 +1917,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);
 		}
@@ -2108,6 +2467,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");
@@ -2117,11 +2481,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);
@@ -2156,11 +2517,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);
@@ -2211,10 +2569,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,
@@ -2245,7 +2599,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,
@@ -2533,7 +2886,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;
 	}
@@ -2551,13 +2904,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$2 of expectedInputs) received[input$2] = this.resolveInput(currentState, nodeId, input$2);
 			return [{
@@ -2571,7 +2924,7 @@ var CurrentStateFrontierPlanner = class CurrentStateFrontierPlanner {
 			}];
 		}
 		const input$1 = expectedInputs[0] ?? "in";
-		const incomingEdge = incomingEdges.find((edge) => edge.input === input$1);
+		const incomingEdge = incomingEdges.find((edge) => edge.collectKey === input$1);
 		return [{
 			nodeId,
 			input: this.resolveInput(currentState, nodeId, input$1),
@@ -2591,16 +2944,17 @@ var CurrentStateFrontierPlanner = class CurrentStateFrontierPlanner {
 	isNodeSatisfiedByOutputsOnly(currentState, nodeId) {
 		return this.hasOutputs(currentState, nodeId) && !this.hasCompletedSnapshot(currentState, nodeId);
 	}
-	isEdgeSatisfied(currentState, nodeId, input$1) {
-		const incomingEdge = (this.topology.incomingByNode.get(nodeId) ?? []).find((edge) => edge.input === input$1);
+	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$1) {
-		const incomingEdge = (this.topology.incomingByNode.get(nodeId) ?? []).find((edge) => edge.input === input$1);
+	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);
 	}
@@ -2611,17 +2965,13 @@ var CurrentStateFrontierPlanner = class CurrentStateFrontierPlanner {
 		const snapshot = currentState.nodeSnapshotsByNodeId[nodeId];
 		return snapshot?.status === "completed" || snapshot?.status === "skipped";
 	}
-	hasOutputPort(currentState, nodeId, output$1) {
-		const outputs = currentState.outputsByNode[nodeId];
-		if (!outputs) return false;
-		return Object.prototype.hasOwnProperty.call(outputs, output$1);
-	}
 	resolveOutputItems(currentState, nodeId, output$1) {
 		return currentState.outputsByNode[nodeId]?.[output$1] ?? [];
 	}
 	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);
@@ -3513,7 +3863,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,
@@ -3525,7 +3874,25 @@ 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,
+			parent: resolvedParent,
+			executionOptions: request.executionOptions ?? state.executionOptions,
+			base,
+			data,
+			definition: {
+				id: definition.id,
+				config: definition.config
+			},
+			batchId,
+			inputsByPort
+		}) : this.nodeActivationRequestComposer.createSingleFromDefinitionWithActivation({
 			activationId: request.activationId,
 			runId: request.runId,
 			workflowId: request.workflowId,
@@ -3537,8 +3904,8 @@ var NodeExecutionRequestHandlerService = class {
 				id: definition.id,
 				config: definition.config
 			},
-			batchId: pendingExecution.batchId ?? "batch_1",
-			input: persistedInput
+			batchId,
+			input: inputsByPort.in ?? request.input ?? []
 		});
 		await this.continuation.markNodeRunning({
 			runId: activationRequest.runId,
@@ -3623,7 +3990,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) {
@@ -3632,7 +3999,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"
@@ -3647,7 +4014,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
@@ -3729,29 +4096,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;
+	}
+	toEnqueueTarget(edge) {
+		return edge.to;
 	}
-	enqueueEdge(queue, args) {
+	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
 			});
@@ -3772,14 +4145,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,
@@ -3788,11 +4161,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 ?? [];
@@ -3824,7 +4203,7 @@ var RunQueuePlanner = class {
 	}
 	findSources(nodeId, input$1) {
 		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$1) 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$1) matches.push(this.formatNodeLabel(sourceNodeId));
 		return matches;
 	}
 	formatInputList(inputs) {
@@ -4499,5 +4878,5 @@ var WorkflowRepositoryWebhookTriggerMatcherFactory = class {
 };
 
 //#endregion
-export { injectAll as $, NodeExecutor as A, WorkflowExecutableNodeClassifier as B, RunPolicySnapshotFactory as C, PersistedWorkflowTokenRegistry as D, WorkflowSnapshotCodec as E, CredentialResolverFactory as F, tool as G, chatModel as H, DefaultExecutionBinaryService as I, StackTraceCallSitePathResolver as J, InjectableRuntimeDecoratorComposer as K, UnavailableBinaryStorage as L, InProcessRetryRunner as M, DefaultExecutionContextFactory as N, MissingRuntimeTriggerToken as O, DefaultAsyncSleeper as P, inject as Q, NodeEventPublisher as R, ConfigDrivenOffloadPolicy as S, NodeInstanceFactory as T, getPersistedRuntimeTypeMetadata as U, ConnectionNodeIdFactory as V, node as W, container$1 as X, PersistedRuntimeTypeNameResolver as Y, delay as Z, EngineExecutionLimitsPolicy as _, InMemoryLiveWorkflowRepository as a, singleton as at, HintOnlyOffloadPolicy as b, EngineFactory as c, InMemoryRunDataFactory as d, injectable as et, InMemoryBinaryStorage as f, ENGINE_EXECUTION_LIMITS_DEFAULTS as g, RunTerminalPersistenceCoordinator as h, RunIntentService as i, registry as it, InProcessRetryRunnerFactory as j, NodeExecutorFactory as k, Engine as l, WorkflowPolicyErrorServices as m, WorkflowRepositoryWebhookTriggerMatcher as n, instancePerContainerCachingFactory as nt, EngineWorkflowRunnerServiceFactory as o, CoreTokens as ot, WorkflowStoragePolicyEvaluator as p, PersistedRuntimeTypeMetadataStore as q, RunIntentServiceFactory as r, predicateAwareClassFactory as rt, EngineWorkflowRunnerService as s, WorkflowRepositoryWebhookTriggerMatcherFactory as t, instanceCachingFactory as tt, RunFinishedAtFactory as u, LocalOnlyScheduler as v, NodeInstanceFactoryFactory as w, DefaultDrivingScheduler as x, InlineDrivingScheduler as y, WorkflowExecutableNodeClassifierFactory as z };
-//# sourceMappingURL=runtime-Cy-3FTI_.js.map
+export { getPersistedRuntimeTypeMetadata as $, NodeExecutor as A, CredentialResolverFactory as B, RunPolicySnapshotFactory as C, PersistedWorkflowTokenRegistry as D, WorkflowSnapshotCodec as E, isUnbrandedPortsEmissionShape as F, WorkflowExecutableNodeClassifierFactory as G, DefaultExecutionBinaryService as H, ItemValueResolver as I, isItemValue as J, WorkflowExecutableNodeClassifier as K, InProcessRetryRunner as L, NodeOutputNormalizer as M, emitPorts as N, MissingRuntimeTriggerToken as O, isPortsEmission as P, chatModel as Q, DefaultExecutionContextFactory as R, ConfigDrivenOffloadPolicy as S, NodeInstanceFactory as T, UnavailableBinaryStorage as U, getOriginIndexFromItem as V, NodeEventPublisher as W, resolveItemValuesForExecution as X, itemValue as Y, resolveItemValuesInUnknown as Z, EngineExecutionLimitsPolicy as _, InMemoryLiveWorkflowRepository as a, PersistedRuntimeTypeNameResolver as at, HintOnlyOffloadPolicy as b, EngineFactory as c, inject as ct, InMemoryRunDataFactory as d, instanceCachingFactory as dt, node as et, InMemoryBinaryStorage as f, instancePerContainerCachingFactory as ft, ENGINE_EXECUTION_LIMITS_DEFAULTS as g, CoreTokens as gt, RunTerminalPersistenceCoordinator as h, singleton as ht, RunIntentService as i, StackTraceCallSitePathResolver as it, InProcessRetryRunnerFactory as j, NodeExecutorFactory as k, Engine as l, injectAll as lt, WorkflowPolicyErrorServices as m, registry as mt, WorkflowRepositoryWebhookTriggerMatcher as n, InjectableRuntimeDecoratorComposer as nt, EngineWorkflowRunnerServiceFactory as o, container$1 as ot, WorkflowStoragePolicyEvaluator as p, predicateAwareClassFactory as pt, ConnectionNodeIdFactory as q, RunIntentServiceFactory as r, PersistedRuntimeTypeMetadataStore as rt, EngineWorkflowRunnerService as s, delay as st, WorkflowRepositoryWebhookTriggerMatcherFactory as t, tool as tt, RunFinishedAtFactory as u, injectable as ut, LocalOnlyScheduler as v, NodeInstanceFactoryFactory as w, DefaultDrivingScheduler as x, InlineDrivingScheduler as y, DefaultAsyncSleeper as z };
+//# sourceMappingURL=runtime-BdH94eBR.js.map