@codemation/core 0.5.0 → 0.7.0

package/dist/{runtime-feFn8OmG.cjs → runtime-3YVDd2vY.cjs}

@@ -165,43 +165,43 @@ function chatModel(options = {}) {
 }
 
 //#endregion
-//#region src/contracts/itemValue.ts
-const ITEM_VALUE_BRAND = Symbol.for("codemation.itemValue");
-function itemValue(fn) {
+//#region src/contracts/itemExpr.ts
+const ITEM_EXPR_BRAND = Symbol.for("codemation.itemExpr");
+function itemExpr(fn) {
 	return {
-		[ITEM_VALUE_BRAND]: true,
+		[ITEM_EXPR_BRAND]: true,
 		fn
 	};
 }
-function isItemValue(value) {
+function isItemExpr(value) {
 	if (typeof value !== "object" || value === null) return false;
 	const v = value;
-	if (v[ITEM_VALUE_BRAND] === true) return true;
+	if (v[ITEM_EXPR_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;
+	for (const sym of Object.getOwnPropertySymbols(v)) if (sym.description === "codemation.itemExpr" && v[sym] === true) return true;
 	return false;
 }
-function containsItemValueInUnknown(value, seen = /* @__PURE__ */ new WeakSet()) {
-	if (isItemValue(value)) return true;
+function containsItemExprInUnknown(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (isItemExpr(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;
+	if (Array.isArray(value)) return value.some((entry) => containsItemExprInUnknown(entry, seen));
+	for (const entry of Object.values(value)) if (containsItemExprInUnknown(entry, seen)) return true;
 	return false;
 }
 /**
-* 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).
 */
-async function resolveItemValuesInUnknown(value, args, seen = /* @__PURE__ */ new WeakSet()) {
-	if (isItemValue(value)) return await Promise.resolve(value.fn(args));
+async function resolveItemExprsInUnknown(value, args, seen = /* @__PURE__ */ new WeakSet()) {
+	if (isItemExpr(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));
+		for (let i = 0; i < value.length; i++) out$1.push(await resolveItemExprsInUnknown(value[i], args, seen));
 		return out$1;
 	}
 	const rec = value;
@@ -209,14 +209,14 @@ async function resolveItemValuesInUnknown(value, args, seen = /* @__PURE__ */ ne
 	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);
+	for (const [k, v] of entries) 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.
 */
-async function resolveItemValuesForExecution(config, nodeCtx, item, itemIndex, items) {
-	const ivArgs = {
+async function resolveItemExprsForExecution(config, nodeCtx, item, itemIndex, items) {
+	const exprArgs = {
 		item,
 		itemIndex,
 		items,
@@ -228,8 +228,8 @@ async function resolveItemValuesForExecution(config, nodeCtx, item, itemIndex, i
 			data: nodeCtx.data
 		}
 	};
-	if (!containsItemValueInUnknown(config)) return;
-	return await resolveItemValuesInUnknown(config, ivArgs);
+	if (!containsItemExprInUnknown(config)) return;
+	return await resolveItemExprsInUnknown(config, exprArgs);
 }
 
 //#endregion
@@ -941,14 +941,14 @@ var InProcessRetryRunner = class InProcessRetryRunner {
 };
 
 //#endregion
-//#region src/execution/ItemValueResolver.ts
+//#region src/execution/ItemExprResolver.ts
 /**
-* 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}.
 */
-var ItemValueResolver = class {
+var ItemExprResolver = 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);
+		if (!ctx) throw new Error("ItemExprResolver.resolveConfigForItem: ctx is required");
+		const resolvedConfig = await resolveItemExprsForExecution(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 {
@@ -978,49 +978,56 @@ function isUnbrandedPortsEmissionShape(value) {
 //#region src/execution/NodeOutputNormalizer.ts
 var NodeOutputNormalizer = class {
 	normalizeExecuteResult(args) {
-		const { baseItem, raw, carry } = args;
-		if (isPortsEmission(raw)) return this.emitPortsToOutputs(baseItem, raw, carry);
+		const { baseItem, raw, behavior } = args;
+		if (isPortsEmission(raw)) return this.emitPortsToOutputs(baseItem, raw, behavior);
 		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)] };
+		if (Array.isArray(raw)) return this.arrayFanOutToMain(baseItem, raw, behavior);
+		if (this.isItemLike(raw)) return { main: [this.applyOutput(baseItem, raw, behavior)] };
+		return { main: [this.applyOutput(baseItem, { json: raw }, behavior)] };
 	}
-	arrayFanOutToMain(baseItem, raw, carry) {
+	arrayFanOutToMain(baseItem, raw, behavior) {
 		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)) };
+		return { main: raw.map((json) => this.applyOutput(baseItem, { json }, behavior)) };
 	}
-	emitPortsToOutputs(baseItem, emission, carry) {
+	emitPortsToOutputs(baseItem, emission, behavior) {
 		const out = {};
 		for (const [port, payload] of Object.entries(emission.ports)) {
 			if (payload === void 0) continue;
-			out[port] = this.normalizePortPayload(baseItem, payload, carry);
+			out[port] = this.normalizePortPayload(baseItem, payload, behavior);
 		}
 		return out;
 	}
-	normalizePortPayload(baseItem, payload, carry) {
+	normalizePortPayload(baseItem, payload, behavior) {
 		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));
+		if (this.isItemLike(el0)) return payload.map((it) => this.applyOutput(baseItem, it, behavior));
+		return payload.map((json) => this.applyOutput(baseItem, { json }, behavior));
 	}
 	isItemLike(value) {
 		return typeof value === "object" && value !== null && "json" in value;
 	}
-	applyLineage(baseItem, next, carry) {
-		if (carry === "carryThrough") return {
-			...baseItem,
-			...next,
-			json: next.json
-		};
+	applyOutput(baseItem, next, behavior) {
+		const explicitBinary = next.binary;
 		return {
 			json: next.json,
-			...next.binary ? { binary: next.binary } : {},
+			...explicitBinary !== void 0 ? { binary: explicitBinary } : behavior.keepBinaries && baseItem.binary ? { binary: baseItem.binary } : {},
 			...next.meta ? { meta: next.meta } : {},
 			...next.paired ? { paired: next.paired } : {}
 		};
 	}
 };
 
+//#endregion
+//#region src/execution/RunnableOutputBehaviorResolver.ts
+var RunnableOutputBehaviorResolver = class {
+	resolve(config) {
+		return { keepBinaries: this.isKeepBinariesEnabled(config) };
+	}
+	isKeepBinariesEnabled(config) {
+		return config.keepBinaries === true;
+	}
+};
+
 //#endregion
 //#region src/execution/InProcessRetryRunnerFactory.ts
 var InProcessRetryRunnerFactory = class {
@@ -1124,11 +1131,13 @@ var NodeActivationRequestComposer = class {
 var NodeExecutor = class {
 	fanInMerger = new FanInMergeByOriginMerger();
 	outputNormalizer = new NodeOutputNormalizer();
-	itemValueResolver;
-	constructor(nodeInstanceFactory, retryRunner, itemValueResolver) {
+	itemExprResolver;
+	outputBehaviorResolver;
+	constructor(nodeInstanceFactory, retryRunner, itemExprResolver, outputBehaviorResolver) {
 		this.nodeInstanceFactory = nodeInstanceFactory;
 		this.retryRunner = retryRunner;
-		this.itemValueResolver = itemValueResolver ?? new ItemValueResolver();
+		this.itemExprResolver = itemExprResolver ?? new ItemExprResolver();
+		this.outputBehaviorResolver = outputBehaviorResolver ?? new RunnableOutputBehaviorResolver();
 	}
 	async execute(request) {
 		const policy = request.ctx.config.retryPolicy;
@@ -1191,14 +1200,14 @@ var NodeExecutor = class {
 	}
 	async executeRunnableActivation(request, node$1) {
 		const runnableConfig = request.ctx.config;
-		const carry = this.resolveLineageCarry(node$1, runnableConfig);
+		const behavior = this.outputBehaviorResolver.resolve(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 resolvedCtx = await this.itemExprResolver.resolveConfigForItem(runnableCtx, syntheticItem, 0, inputBatch);
 			const args = {
 				input: parsed,
 				item: syntheticItem,
@@ -1210,7 +1219,7 @@ var NodeExecutor = class {
 			return this.outputNormalizer.normalizeExecuteResult({
 				baseItem: syntheticItem,
 				raw,
-				carry
+				behavior
 			});
 		}
 		const byPort = {};
@@ -1219,7 +1228,7 @@ var NodeExecutor = class {
 			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 resolvedCtx = await this.itemExprResolver.resolveConfigForItem(runnableCtx, item, i, inputBatch);
 			const ctx = this.pickExecutionContext(runnableCtx, resolvedCtx);
 			const args = {
 				input: parsed,
@@ -1232,7 +1241,7 @@ var NodeExecutor = class {
 			const normalized = this.outputNormalizer.normalizeExecuteResult({
 				baseItem: item,
 				raw,
-				carry
+				behavior
 			});
 			for (const [port, batch] of Object.entries(normalized)) {
 				if (!batch || batch.length === 0) continue;
@@ -1262,20 +1271,13 @@ var NodeExecutor = class {
 		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";
-	}
 };
 
 //#endregion
 //#region src/execution/NodeExecutorFactory.ts
 var NodeExecutorFactory = class {
-	create(workflowNodeInstanceFactory, retryRunner) {
-		return new NodeExecutor(workflowNodeInstanceFactory, retryRunner);
+	create(workflowNodeInstanceFactory, retryRunner, outputBehaviorResolver) {
+		return new NodeExecutor(workflowNodeInstanceFactory, retryRunner, void 0, outputBehaviorResolver);
 	}
 };
 
@@ -5037,10 +5039,10 @@ Object.defineProperty(exports, 'InlineDrivingScheduler', {
     return InlineDrivingScheduler;
   }
 });
-Object.defineProperty(exports, 'ItemValueResolver', {
+Object.defineProperty(exports, 'ItemExprResolver', {
   enumerable: true,
   get: function () {
-    return ItemValueResolver;
+    return ItemExprResolver;
   }
 });
 Object.defineProperty(exports, 'LocalOnlyScheduler', {
@@ -5139,6 +5141,12 @@ Object.defineProperty(exports, 'RunTerminalPersistenceCoordinator', {
     return RunTerminalPersistenceCoordinator;
   }
 });
+Object.defineProperty(exports, 'RunnableOutputBehaviorResolver', {
+  enumerable: true,
+  get: function () {
+    return RunnableOutputBehaviorResolver;
+  }
+});
 Object.defineProperty(exports, 'StackTraceCallSitePathResolver', {
   enumerable: true,
   get: function () {
@@ -5223,10 +5231,10 @@ Object.defineProperty(exports, 'getPersistedRuntimeTypeMetadata', {
     return getPersistedRuntimeTypeMetadata;
   }
 });
-Object.defineProperty(exports, 'isItemValue', {
+Object.defineProperty(exports, 'isItemExpr', {
   enumerable: true,
   get: function () {
-    return isItemValue;
+    return isItemExpr;
   }
 });
 Object.defineProperty(exports, 'isPortsEmission', {
@@ -5241,10 +5249,10 @@ Object.defineProperty(exports, 'isUnbrandedPortsEmissionShape', {
     return isUnbrandedPortsEmissionShape;
   }
 });
-Object.defineProperty(exports, 'itemValue', {
+Object.defineProperty(exports, 'itemExpr', {
   enumerable: true,
   get: function () {
-    return itemValue;
+    return itemExpr;
   }
 });
 Object.defineProperty(exports, 'node', {
@@ -5253,16 +5261,16 @@ Object.defineProperty(exports, 'node', {
     return node;
   }
 });
-Object.defineProperty(exports, 'resolveItemValuesForExecution', {
+Object.defineProperty(exports, 'resolveItemExprsForExecution', {
   enumerable: true,
   get: function () {
-    return resolveItemValuesForExecution;
+    return resolveItemExprsForExecution;
   }
 });
-Object.defineProperty(exports, 'resolveItemValuesInUnknown', {
+Object.defineProperty(exports, 'resolveItemExprsInUnknown', {
   enumerable: true,
   get: function () {
-    return resolveItemValuesInUnknown;
+    return resolveItemExprsInUnknown;
   }
 });
 Object.defineProperty(exports, 'tool', {
@@ -5271,4 +5279,4 @@ Object.defineProperty(exports, 'tool', {
     return tool;
   }
 });
-//# sourceMappingURL=runtime-feFn8OmG.cjs.map
+//# sourceMappingURL=runtime-3YVDd2vY.cjs.map