@platforma-sdk/workflow-tengo 5.20.0 → 5.21.0

package/dist/index.cjs

@@ -3,6 +3,7 @@ module.exports = { Templates: {
   'pframes.export-parquet-pcolumn-chunk': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.export-parquet-pcolumn-chunk.plj.gz') },
   'pframes.export-single-pcolumn': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.export-single-pcolumn.plj.gz') },
   'pframes.import-dir': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.import-dir.plj.gz') },
+  'pframes.merge-resource-maps': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.merge-resource-maps.plj.gz') },
   'pframes.remove-nulls': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.remove-nulls.plj.gz') },
   'pt.import-dir': { type: 'from-file', path: require.resolve('./tengo/tpl/pt.import-dir.plj.gz') },
   'waiter.waiter': { type: 'from-file', path: require.resolve('./tengo/tpl/waiter.waiter.plj.gz') },
@@ -38,6 +39,8 @@ module.exports = { Templates: {
   'pframes.xsv-import-if-not-null': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.xsv-import-if-not-null.plj.gz') },
   'pframes.xsv-import-map': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.xsv-import-map.plj.gz') },
   'annotations.compute': { type: 'from-file', path: require.resolve('./tengo/tpl/annotations.compute.plj.gz') },
+  'pframes.process-pcolumn-batch-split': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.process-pcolumn-batch-split.plj.gz') },
+  'pframes.process-pcolumn-batch': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.process-pcolumn-batch.plj.gz') },
   'pframes.process-pcolumn-data': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.process-pcolumn-data.plj.gz') },
   'pframes.export-pframe': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.export-pframe.plj.gz') },
   'pframes.export-pframe-for-ui': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.export-pframe-for-ui.plj.gz') }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 declare type TemplateFromFile = { readonly type: "from-file"; readonly path: string; };
-declare type TplName = "ll.get-field" | "pframes.export-parquet-pcolumn-chunk" | "pframes.export-single-pcolumn" | "pframes.import-dir" | "pframes.remove-nulls" | "pt.import-dir" | "waiter.waiter" | "workdir.save" | "workflow.build-ctx" | "workflow.query-context-filter" | "anonymize.deanonymize" | "anonymize.impl" | "check_network.workdir_type_name_extractor" | "exec.delayed-compute-allocation.impl" | "exec.monetization_to_json" | "exec.python.install-deps" | "exec.python.venv-bin-path" | "pframes.export-multiple-pcolumns" | "workflow.query-anchored" | "check_network.create_workdir_from_storage" | "exec.conda.create-env" | "exec.exec-impl" | "exec.monetization_info" | "exec.python.create-venv" | "pframes.slice-data" | "check_network.download_blob" | "check_network.upload_blob" | "check_network.upload_template" | "exec.load-software.impl" | "pframes.parse-to-json" | "exec.exec" | "pt.workflow-run" | "check_network.run_hello_world" | "check_network.run_hello_world_py" | "pframes.build-table" | "pframes.xsv-export-pframe" | "pframes.xsv-import-if-not-null" | "pframes.xsv-import-map" | "annotations.compute" | "pframes.process-pcolumn-data" | "pframes.export-pframe" | "pframes.export-pframe-for-ui";
+declare type TplName = "ll.get-field" | "pframes.export-parquet-pcolumn-chunk" | "pframes.export-single-pcolumn" | "pframes.import-dir" | "pframes.merge-resource-maps" | "pframes.remove-nulls" | "pt.import-dir" | "waiter.waiter" | "workdir.save" | "workflow.build-ctx" | "workflow.query-context-filter" | "anonymize.deanonymize" | "anonymize.impl" | "check_network.workdir_type_name_extractor" | "exec.delayed-compute-allocation.impl" | "exec.monetization_to_json" | "exec.python.install-deps" | "exec.python.venv-bin-path" | "pframes.export-multiple-pcolumns" | "workflow.query-anchored" | "check_network.create_workdir_from_storage" | "exec.conda.create-env" | "exec.exec-impl" | "exec.monetization_info" | "exec.python.create-venv" | "pframes.slice-data" | "check_network.download_blob" | "check_network.upload_blob" | "check_network.upload_template" | "exec.load-software.impl" | "pframes.parse-to-json" | "exec.exec" | "pt.workflow-run" | "check_network.run_hello_world" | "check_network.run_hello_world_py" | "pframes.build-table" | "pframes.xsv-export-pframe" | "pframes.xsv-import-if-not-null" | "pframes.xsv-import-map" | "annotations.compute" | "pframes.process-pcolumn-batch-split" | "pframes.process-pcolumn-batch" | "pframes.process-pcolumn-data" | "pframes.export-pframe" | "pframes.export-pframe-for-ui";
 declare const Templates: Record<TplName, TemplateFromFile>;
 export { Templates };

package/dist/index.js

@@ -4,6 +4,7 @@ export const Templates = {
   'pframes.export-parquet-pcolumn-chunk': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.export-parquet-pcolumn-chunk.plj.gz') },
   'pframes.export-single-pcolumn': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.export-single-pcolumn.plj.gz') },
   'pframes.import-dir': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.import-dir.plj.gz') },
+  'pframes.merge-resource-maps': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.merge-resource-maps.plj.gz') },
   'pframes.remove-nulls': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.remove-nulls.plj.gz') },
   'pt.import-dir': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pt.import-dir.plj.gz') },
   'waiter.waiter': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/waiter.waiter.plj.gz') },
@@ -39,6 +40,8 @@ export const Templates = {
   'pframes.xsv-import-if-not-null': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.xsv-import-if-not-null.plj.gz') },
   'pframes.xsv-import-map': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.xsv-import-map.plj.gz') },
   'annotations.compute': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/annotations.compute.plj.gz') },
+  'pframes.process-pcolumn-batch-split': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.process-pcolumn-batch-split.plj.gz') },
+  'pframes.process-pcolumn-batch': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.process-pcolumn-batch.plj.gz') },
   'pframes.process-pcolumn-data': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.process-pcolumn-data.plj.gz') },
   'pframes.export-pframe': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.export-pframe.plj.gz') },
   'pframes.export-pframe-for-ui': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.export-pframe-for-ui.plj.gz') }

package/dist/tengo/lib/pframes.lib.tengo

@@ -17,6 +17,8 @@ constants := import("@platforma-sdk/workflow-tengo:pframes.constants")
 xsvBuilder := import("@platforma-sdk/workflow-tengo:pframes.xsv-builder")
 tableBuilderMod := import("@platforma-sdk/workflow-tengo:pframes.table-builder")
 pColumnData := import("@platforma-sdk/workflow-tengo:pframes.data")
+pCommon := import("@platforma-sdk/workflow-tengo:pframes.process-column-common")
+pColumnBatch := import("@platforma-sdk/workflow-tengo:pframes.process-column-batch")
 
 llProcessTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.process-pcolumn-data")
 
@@ -587,6 +589,13 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 		ll.panic("too many arguments")
 	}
 
+
+	isBatchMode := is_map(input) && !is_undefined(input.primary)
+	if isBatchMode {
+		return pColumnBatch.processColumnBatch(input, bodyTpl, outputs, opts)
+	}
+
+
 	if is_undefined(input.spec) {
 		ll.panic("no input spec provided")
 	}
@@ -621,26 +630,6 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 		ll.panic("can't use passAggregationAxesSpec, passAggregationAxesNames or passDistilledAggregationSpec without aggregate")
 	}
 
-	createOutputTrace := func(output) {
-		hasOutputTrace := !is_undefined(output.traceSteps)
-		hasGlobalTrace := !is_undefined(opts.traceSteps)
-		hasInputTrace := !is_undefined(input.spec.annotations[pSpec.A_TRACE])
-
-		outputTraceSteps := slices.normalize(opts.traceSteps) + slices.normalize(output.traceSteps)
-
-		trace := undefined
-		if len(outputTraceSteps) > 0 || hasInputTrace {
-			trace = pSpec.makeTrace(input.spec, outputTraceSteps...)
-		}
-
-		outputOverrideTrace := output.overrideTrace
-		if is_undefined(outputOverrideTrace) {
-			outputOverrideTrace = hasOutputTrace || hasGlobalTrace
-		}
-
-		return { trace: trace, overrideTrace: outputOverrideTrace }
-	}
-
 	processTemplateParams := {
 		eph: opts.isEphemeral,
 		passKey: opts.passKey
@@ -761,7 +750,7 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 	for output in outputs {
 
 		outputsMap[output.name] = output
-		traceInfo := createOutputTrace(output)
+		traceInfo := pCommon.buildOutputTrace(opts, output, input.spec)
 		if output.type == "Resource" || output.type == "BinaryPartitioned" || output.type == "JsonPartitioned" {
 			spec := maps.merge(output.spec, { axesSpec: copy(iterationAxesSpec) + slices.normalize(output.spec.axesSpec) })
 			if !is_undefined(traceInfo.trace) {
@@ -851,256 +840,10 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 	}
 
 	renderResult := render.createEphemeral(llProcessTpl, renderInputs)
-
-	self := undefined
-	self = ll.toStrict({
-		renderResult: renderResult,
-
-
-
-
-
-
-
-
-
-
-
-
-		outputSpec: func(name, ...column) {
-			output := outputsMap[name]
-			if is_undefined(output) {
-				ll.panic("unknown output: " + name)
-			}
-
-			spec := outputSpecs[name]
-			if output.type == "Xsv" || output.type == "TsvContent" {
-				if len(column) != 1 {
-					ll.panic("column name must be provided for " + output.type + " output")
-				}
-				columnName := column[0]
-				spec = spec[columnName]
-				if is_undefined(spec) {
-					ll.panic("unknown column: " + columnName)
-				}
-				return spec
-			} else {
-				if len(column) > 0 {
-					ll.panic("column name should not be provided for non-Xsv/TsvContent output")
-				}
-				return spec
-			}
-		},
-
-
-
-
-
-
-
-
-
-
-
-
-		outputData: func(name, ...column) {
-			output := outputsMap[name]
-			if is_undefined(output) {
-				ll.panic("unknown output: " + name)
-			}
-
-			if output.type == "Xsv" || output.type == "TsvContent" {
-				if len(column) != 1 {
-					ll.panic("column name must be provided for " + output.type + " output")
-				}
-				return renderResult.output(name + "/" + column[0])
-			} else {
-				if len(column) > 0 {
-					ll.panic("column name should not be provided for non-Xsv/TsvContent output")
-				}
-				return renderResult.output(name)
-			}
-		},
-
-
-
-
-
-
-
-
-
-
-
-
-		output: func(name, ...column) {
-			output := outputsMap[name]
-			if is_undefined(output) {
-				ll.panic("unknown output: " + name)
-			}
-
-			if output.type == "Xsv" || output.type == "TsvContent" {
-				if len(column) != 1 {
-					ll.panic("column name must be provided for " + output.type + " output")
-				}
-				columnName := column[0]
-				spec := outputSpecs[name][columnName]
-				if is_undefined(spec) {
-					ll.panic("unknown column: " + columnName)
-				}
-				return {
-					data: renderResult.output(name + "/" + columnName),
-					spec: spec
-				}
-			} else {
-				if len(column) > 0 {
-					ll.panic("column name should not be provided for non-Xsv/TsvContent output")
-				}
-				return {
-					data: renderResult.output(name),
-					spec: outputSpecs[name]
-				}
-			}
-		},
-
-
-
-
-
-
-
-		xsvOutputFrame: func(name) {
-			output := outputsMap[name]
-			if is_undefined(output) {
-				ll.panic("unknown output: " + name)
-			}
-
-			if output.type != "Xsv" && output.type != "TsvContent" {
-				ll.panic("outputFrame can only be used with Xsv or TsvContent outputs")
-			}
-
-			builder := builder.pFrameBuilder()
-			for columnName, spec in outputSpecs[name] {
-				builder.add(columnName, spec, renderResult.output(name + "/" + columnName))
-			}
-			return builder.build()
-		},
-
-
-
-
-
-
-
-
-		addAllOutputsToBuilder: func(builder, ...separator) {
-			sep := "."
-			if len(separator) > 0 {
-				sep = separator[0]
-			}
-
-			maps.forEach(outputsMap, func(name, output) {
-				if output.type == "Xsv" || output.type == "TsvContent" {
-
-					for columnName, spec in outputSpecs[name] {
-						builder.add(
-							name + sep + columnName,
-							spec,
-							renderResult.output(name + "/" + columnName)
-						)
-					}
-				} else {
-
-					builder.add(
-						name,
-						outputSpecs[name],
-						renderResult.output(name)
-					)
-				}
-			})
-
-			return builder
-		},
-
-
-
-
-
-
-
-		allOutputsFrame: func(...xsvNameSeparator) {
-			builder := builder.pFrameBuilder()
-			self.addAllOutputsToBuilder(builder, xsvNameSeparator...)
-			return builder.build()
-		},
-
-
-
-
-
-
-		listOutputs: func() {
-			return maps.getKeys(outputsMap)
-		},
-
-
-
-
-
-
-
-		isXsvOutput: func(name) {
-			output := outputsMap[name]
-			if is_undefined(output) {
-				ll.panic("unknown output: " + name)
-			}
-			return output.type == "Xsv"
-		},
-
-
-
-
-
-
-
-		listXsvColumns: func(name) {
-			output := outputsMap[name]
-			if is_undefined(output) {
-				ll.panic("unknown output: " + name)
-			}
-			if output.type != "Xsv" && output.type != "TsvContent" {
-				ll.panic("output is not Xsv or TsvContent: " + name)
-			}
-
-			return maps.getKeys(outputSpecs[name])
-		},
-
-
-
-
-
-
-
-
-
-		addXsvOutputToBuilder: func(builder, outputName, prefix) {
-			for columnName in self.listXsvColumns(outputName) {
-				builder.add(
-					prefix + columnName,
-					self.outputSpec(outputName, columnName),
-					self.outputData(outputName, columnName)
-				)
-			}
-
-			return builder
-		}
-
-
-	})
-
-	return self
+	return pCommon.createProcessColumnResult(renderResult, outputsMap, outputSpecs)
 }
 
+
 export ll.toStrict({
 	parseData: pColumnData.parseData,
 	processColumn: processColumn,

package/dist/tengo/lib/pframes.process-column-batch.lib.tengo

@@ -0,0 +1,343 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+maps := import("@platforma-sdk/workflow-tengo:maps")
+sets := import("@platforma-sdk/workflow-tengo:sets")
+slices := import("@platforma-sdk/workflow-tengo:slices")
+smart := import("@platforma-sdk/workflow-tengo:smart")
+render := import("@platforma-sdk/workflow-tengo:render")
+assets := import("@platforma-sdk/workflow-tengo:assets")
+pSpec := import("@platforma-sdk/workflow-tengo:pframes.spec")
+pUtil := import("@platforma-sdk/workflow-tengo:pframes.util")
+pCommon := import("@platforma-sdk/workflow-tengo:pframes.process-column-common")
+
+llBatchProcessTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.process-pcolumn-batch")
+
+__PRIMITIVE_VALUE_TYPES := sets.fromSlice(["Int", "Long", "Float", "Double", "String", "Bytes"])
+__VALID_BATCH_FORMATS := sets.fromSlice(["tsv", "csv", "ndjson", "parquet"])
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+processColumnBatch := func(input, bodyTpl, outputs, opts) {
+	ll.assert(!is_undefined(opts.batch),
+		"processColumn: batch option is required when input uses the primary+columns form; " +
+			"set opts.batch or use the single-input form")
+	ll.assert(is_undefined(opts.aggregate),
+		"processColumn: aggregate and batch options are mutually exclusive; remove one of them")
+
+	batch := opts.batch
+	ll.assert(is_int(batch.size) && batch.size > 0,
+		"batch.size must be a positive integer (records per batch); got %v", batch.size)
+
+
+
+
+	ll.assert(is_array(batch.keyColumns) && len(batch.keyColumns) > 0,
+		"batch.keyColumns is required and must be a non-empty array of axis names to batch over; got %v",
+		batch.keyColumns)
+
+	if is_undefined(batch.format) {
+		batch.format = "tsv"
+	}
+	ll.assert(sets.hasElement(__VALID_BATCH_FORMATS, batch.format),
+		"batch.format must be one of \"tsv\", \"csv\", \"ndjson\", \"parquet\"; got %v", batch.format)
+
+	if is_undefined(batch.passContent) {
+		batch.passContent = false
+	}
+
+
+	ll.assert(!(batch.passContent && batch.format == "parquet"),
+		"batch.passContent=true is not applicable to batch.format=\"parquet\" (binary format has no text payload); " +
+			"set passContent=false or choose a text format (tsv, csv, ndjson)")
+
+
+
+	if is_undefined(batch.maxBatches) {
+		batch.maxBatches = 10000
+	}
+	ll.assert(is_int(batch.maxBatches) && batch.maxBatches > 0,
+		"batch.maxBatches must be a positive integer (soft cap on total batch count); got %v", batch.maxBatches)
+
+	primaryJoin := input.primaryJoin
+	if is_undefined(primaryJoin) {
+		primaryJoin = "full"
+	}
+	ll.assert(primaryJoin == "full" || primaryJoin == "inner",
+		"input.primaryJoin must be \"full\" or \"inner\"; got %v", primaryJoin)
+
+	isEph := false
+	if !is_undefined(opts.isEphemeral) {
+		isEph = opts.isEphemeral
+	}
+
+
+	primaryEntries := pCommon.normalizeColumnEntries(input.primary)
+	secondaryEntries := pCommon.normalizeColumnEntries(input.columns)
+	ll.assert(len(primaryEntries) > 0,
+		"input.primary must contain at least one column")
+
+
+
+
+	_assertPrimitive := func(role, header, spec) {
+		ll.assert(sets.hasElement(__PRIMITIVE_VALUE_TYPES, spec.valueType),
+			"batch mode %s column %q has non-primitive valueType %q; " +
+				"use one of Int, Long, Float, Double, String, Bytes",
+			role, header, spec.valueType)
+	}
+	for entry in primaryEntries {
+		_assertPrimitive("primary", entry.header, entry.src.spec)
+	}
+	for entry in secondaryEntries {
+		_assertPrimitive("non-primary", entry.header, entry.src.spec)
+	}
+
+
+	allAxesSpec := primaryEntries[0].src.spec.axesSpec
+	ll.assert(!is_undefined(allAxesSpec),
+		"primary column %q is missing axesSpec; every input PColumn spec must define axesSpec",
+		primaryEntries[0].header)
+
+
+	batchKeyIndices := pSpec.matchAxes(allAxesSpec, batch.keyColumns)
+	isolationIndices := pUtil.calculateGroupAxesIndices(len(allAxesSpec), batchKeyIndices)
+
+	isolationAxesSpec := []
+	for i in isolationIndices {
+		isolationAxesSpec = append(isolationAxesSpec, allAxesSpec[i])
+	}
+
+	batchKeyAxesSpec := []
+	for i in batchKeyIndices {
+		batchKeyAxesSpec = append(batchKeyAxesSpec, allAxesSpec[i])
+	}
+
+
+
+
+
+	reservedNames := {}
+	_claimName := func(kind, name) {
+		prior := reservedNames[name]
+		ll.assert(is_undefined(prior),
+			"%s header %q collides with %s of the same name; rename one of them so every column and batch-key axis has a unique header",
+			kind, name, prior)
+		reservedNames[name] = kind
+	}
+	for axSpec in batchKeyAxesSpec {
+		_claimName("batch-key axis", axSpec.name)
+	}
+	for entry in primaryEntries {
+		_claimName("primary column", entry.header)
+	}
+	for entry in secondaryEntries {
+		_claimName("non-primary column", entry.header)
+	}
+
+
+	iterationAxesSpec := copy(isolationAxesSpec)
+
+
+
+	batchKeyAxisByName := {}
+	for axSpec in batchKeyAxesSpec {
+		batchKeyAxisByName[axSpec.name] = axSpec
+	}
+
+
+	processedOutputs := []
+	outputSpecs := {}
+	outputsMap := {}
+
+
+
+	batchTraceInputSpec := primaryEntries[0].src.spec
+
+	for output in outputs {
+		outputsMap[output.name] = output
+		traceInfo := pCommon.buildOutputTrace(opts, output, batchTraceInputSpec)
+		_maybeInjectTrace := func(spec) {
+			if !is_undefined(traceInfo.trace) {
+				return traceInfo.trace.inject(spec, { override: traceInfo.overrideTrace })
+			}
+			return spec
+		}
+
+		ll.assert(output.type != "Resource",
+			"output %q: Resource output type is not supported in batch mode; use ResourceMap or Xsv instead",
+			output.name)
+		ll.assert(output.type == "ResourceMap" || output.type == "Xsv",
+			"output %q has unsupported output type %q in batch mode; use ResourceMap or Xsv instead",
+			output.name, output.type)
+
+		if output.type == "ResourceMap" {
+			spec := maps.merge(output.spec, {
+				axesSpec: copy(iterationAxesSpec) + copy(batchKeyAxesSpec) + slices.normalize(output.spec.axesSpec)
+			})
+			outputSpecs[output.name] = _maybeInjectTrace(spec)
+			processedOutputs = append(processedOutputs, maps.merge(output, {
+				keyLength: len(output.spec.axesSpec),
+				spec: undefined,
+				traceSteps: undefined,
+				overrideTrace: undefined
+			}))
+		} else { // output.type == "Xsv"
+			ll.assert(!is_undefined(output.settings),
+				"Xsv output %q is missing `settings` (required: an xsv import config)", output.name)
+
+
+
+
+
+
+			if is_undefined(output.xsvType) {
+				ll.assert(batch.format != "ndjson",
+					"Xsv output %q requires explicit xsvType when batch.format=\"ndjson\" — " +
+						"set xsvType to csv, tsv, or parquet (xsv.importFile cannot read ndjson)",
+					output.name)
+			} else {
+				pUtil.validateXsvType(output.xsvType)
+			}
+
+
+
+			batchKeyColumnsNames := output.settings.batchKeyColumns
+			ll.assert(!is_undefined(batchKeyColumnsNames),
+				"Xsv output %q is missing settings.batchKeyColumns (required in batch mode; list the axis names emitted by the body)",
+				output.name)
+			ll.assert(is_undefined(output.settings.axes),
+				"Xsv output %q cannot set both batchKeyColumns and axes in settings; these are mutually exclusive — keep batchKeyColumns only",
+				output.name)
+
+			batchAxes := slices.map(batchKeyColumnsNames, func(colName) {
+				axSpec := batchKeyAxisByName[colName]
+				ll.assert(!is_undefined(axSpec),
+					"Xsv output %q: settings.batchKeyColumns entry %q does not match any batch.keyColumns axis",
+					output.name, colName)
+				return { column: colName, spec: axSpec }
+			})
+
+
+
+
+
+			modifiedSettings := maps.merge(output.settings, {
+				axes: batchAxes,
+				batchKeyColumns: undefined,
+				partitionKeyLength: 0
+			})
+			decomposition := pUtil.decomposePfconvImportCfg(modifiedSettings, {
+				additionalAxesSpec: iterationAxesSpec
+			})
+			columnsSpec := decomposition.columnsSpec
+			for columnName, spec in columnsSpec {
+				columnsSpec[columnName] = _maybeInjectTrace(spec)
+			}
+			outputSpecs[output.name] = columnsSpec
+			processedOutputs = append(processedOutputs, maps.merge(output, {
+				settings: decomposition.purifiedCfg,
+				flattenWithDelimiter: "/",
+				traceSteps: undefined,
+				overrideTrace: undefined
+			}))
+		}
+	}
+
+	primaryHeaders := slices.map(primaryEntries, func(e) { return e.header })
+	secondaryHeaders := slices.map(secondaryEntries, func(e) { return e.header })
+
+
+
+	batchTemplateParams := {
+		batchSize: batch.size,
+		maxBatches: batch.maxBatches,
+		batchFormat: batch.format,
+		passContent: batch.passContent,
+		batchKeyIndices: batchKeyIndices,
+		isolationIndices: isolationIndices,
+		primaryJoin: primaryJoin,
+		eph: isEph,
+		outputs: processedOutputs,
+		primaryColumnCount: len(primaryEntries),
+		secondaryColumnCount: len(secondaryEntries),
+		primaryHeaders: primaryHeaders,
+		secondaryHeaders: secondaryHeaders
+	}
+
+	renderInputs := {
+		params: smart.createJsonResource(batchTemplateParams),
+		body: bodyTpl
+	}
+	for i, entry in primaryEntries {
+		renderInputs["__col_primary_" + string(i) + "_data"] = entry.src.data
+		renderInputs["__col_primary_" + string(i) + "_spec"] = smart.createJsonResource(entry.src.spec)
+		if !is_undefined(entry.filter) {
+			renderInputs["__col_primary_" + string(i) + "_filter_data"] = entry.filter.data
+			renderInputs["__col_primary_" + string(i) + "_filter_spec"] = smart.createJsonResource(entry.filter.spec)
+		}
+	}
+	for i, entry in secondaryEntries {
+		renderInputs["__col_secondary_" + string(i) + "_data"] = entry.src.data
+		renderInputs["__col_secondary_" + string(i) + "_spec"] = smart.createJsonResource(entry.src.spec)
+	}
+
+	extra := opts.extra
+	if !is_undefined(extra) {
+		for k, v in extra {
+			renderInputs["__extra_" + k] = v
+		}
+	}
+	metaExtra := opts.metaExtra
+	if !is_undefined(metaExtra) {
+		for k, v in metaExtra {
+			renderInputs["__meta_" + k] = v
+		}
+	}
+
+
+
+	renderMetaInputs := {
+		globalCpu: opts.cpu,
+		globalMem: opts.mem,
+		globalQueue: opts.queue,
+		stepCache: opts.stepCache,
+		cacheInputs: opts.cacheInputs
+	}
+
+	renderResult := render.createEphemeral(llBatchProcessTpl, renderInputs, { metaInputs: renderMetaInputs })
+	return pCommon.createProcessColumnResult(renderResult, outputsMap, outputSpecs)
+}
+
+export ll.toStrict({
+	processColumnBatch: processColumnBatch
+})