@codemation/core 0.5.0 → 0.6.0

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

@@ -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 {
@@ -1125,10 +1132,12 @@ var NodeExecutor = class {
 	fanInMerger = new FanInMergeByOriginMerger();
 	outputNormalizer = new NodeOutputNormalizer();
 	itemValueResolver;
-	constructor(nodeInstanceFactory, retryRunner, itemValueResolver) {
+	outputBehaviorResolver;
+	constructor(nodeInstanceFactory, retryRunner, itemValueResolver, outputBehaviorResolver) {
 		this.nodeInstanceFactory = nodeInstanceFactory;
 		this.retryRunner = retryRunner;
 		this.itemValueResolver = itemValueResolver ?? new ItemValueResolver();
+		this.outputBehaviorResolver = outputBehaviorResolver ?? new RunnableOutputBehaviorResolver();
 	}
 	async execute(request) {
 		const policy = request.ctx.config.retryPolicy;
@@ -1191,7 +1200,7 @@ 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") {
@@ -1210,7 +1219,7 @@ var NodeExecutor = class {
 			return this.outputNormalizer.normalizeExecuteResult({
 				baseItem: syntheticItem,
 				raw,
-				carry
+				behavior
 			});
 		}
 		const byPort = {};
@@ -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);
 	}
 };
 
@@ -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 () {
@@ -5271,4 +5279,4 @@ Object.defineProperty(exports, 'tool', {
     return tool;
   }
 });
-//# sourceMappingURL=runtime-feFn8OmG.cjs.map
+//# sourceMappingURL=runtime-DVBwxFvX.cjs.map