@platforma-sdk/workflow-tengo 5.13.3 → 5.15.0

package/dist/index.cjs

@@ -31,12 +31,13 @@ module.exports = { Templates: {
   'pframes.parse-to-json': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.parse-to-json.plj.gz') },
   'exec.exec': { type: 'from-file', path: require.resolve('./tengo/tpl/exec.exec.plj.gz') },
   'pt.workflow-run': { type: 'from-file', path: require.resolve('./tengo/tpl/pt.workflow-run.plj.gz') },
-  'annotations.compute': { type: 'from-file', path: require.resolve('./tengo/tpl/annotations.compute.plj.gz') },
   'check_network.run_hello_world': { type: 'from-file', path: require.resolve('./tengo/tpl/check_network.run_hello_world.plj.gz') },
   'check_network.run_hello_world_py': { type: 'from-file', path: require.resolve('./tengo/tpl/check_network.run_hello_world_py.plj.gz') },
+  'pframes.build-table': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.build-table.plj.gz') },
   'pframes.xsv-export-pframe': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.xsv-export-pframe.plj.gz') },
   '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-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" | "annotations.compute" | "check_network.run_hello_world" | "check_network.run_hello_world_py" | "pframes.xsv-export-pframe" | "pframes.xsv-import-if-not-null" | "pframes.xsv-import-map" | "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.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 const Templates: Record<TplName, TemplateFromFile>;
 export { Templates };

package/dist/index.js

@@ -32,12 +32,13 @@ export const Templates = {
   'pframes.parse-to-json': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.parse-to-json.plj.gz') },
   'exec.exec': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/exec.exec.plj.gz') },
   'pt.workflow-run': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pt.workflow-run.plj.gz') },
-  'annotations.compute': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/annotations.compute.plj.gz') },
   'check_network.run_hello_world': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/check_network.run_hello_world.plj.gz') },
   'check_network.run_hello_world_py': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/check_network.run_hello_world_py.plj.gz') },
+  'pframes.build-table': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.build-table.plj.gz') },
   'pframes.xsv-export-pframe': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.xsv-export-pframe.plj.gz') },
   '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-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/exec.delayed-compute-allocation.lib.tengo

@@ -22,7 +22,7 @@ create := func(workdir, req) {
 		"queue": "string",
 		"cpu,?": "number",
 		"ram,?": ["or", "number", "string"],
-		"gpu,?": "number"
+		"gpuMemory,?": "string"
 	}, "request must be a valid request")
 
 	reqMap := { queue: req.queue }
@@ -32,8 +32,8 @@ create := func(workdir, req) {
 	if !is_undefined(req.ram) {
 		reqMap.ram = req.ram
 	}
-	if !is_undefined(req.gpu) && req.gpu > 0 {
-		reqMap.gpu = req.gpu
+	if !is_undefined(req.gpuMemory) {
+		reqMap.gpuMemory = req.gpuMemory
 	}
 
 	delayedComputeAllocation := render.createEphemeral(tpl, {

package/dist/tengo/lib/exec.lib.tengo

@@ -51,7 +51,7 @@ builder := func() {
 	queue := execConstants.HEAVY_QUEUE
 	cpuRequest := undefined
 	ramRequest := undefined
-	gpuCount := 0
+	gpuMemory := undefined
 
 	commandName := ""
 	cache := 0
@@ -443,10 +443,15 @@ builder := func() {
 
 
 
-		gpu: func(count) {
-			validation.assertType(count, "number", "exec.builder.gpu: count must be a number")
-			ll.assert(count > 0, "exec.builder.gpu: count must be greater than 0")
-			gpuCount = count
+
+		gpuMemory: func(...args) {
+			ll.assert(len(args) <= 1, "exec.builder.gpuMemory: accepts 0 or 1 argument")
+			if len(args) == 0 {
+				gpuMemory = "1GiB"
+			} else {
+				validation.assertType(args[0], "string", "exec.builder.gpuMemory: argument must be a size string like '16GiB'")
+				gpuMemory = args[0]
+			}
 			return self
 		},
 
@@ -1039,8 +1044,8 @@ builder := func() {
 				cpu: cpuRequest,
 				ram: ramRequest
 			}
-			if gpuCount > 0 {
-				quotaData.gpu = gpuCount
+			if !is_undefined(gpuMemory) {
+				quotaData.gpuMemory = gpuMemory
 			}
 			metaExecInputs := {
 				quota: smart.createJsonResource(quotaData)

package/dist/tengo/lib/exec.limits.lib.tengo

@@ -105,11 +105,16 @@ quotaBuilder := func() {
 
 
 
-		gpu: func(amount) {
-			validation.assertType(amount, ["or", "number", "null"], "exec.quota.builder.gpu: GPU amount should be a number")
-			ll.assert(is_undefined(amount) || amount > 0, "exec.quota.builder.gpu: amount should be greater than 0")
-			gpu_request = amount
 
+		gpuMemory: func(...args) {
+			if len(args) == 0 {
+				gpu_request = "1GiB"
+			} else if len(args) == 1 {
+				validation.assertType(args[0], "string", "exec.quota.builder.gpuMemory: argument must be a size string")
+				gpu_request = args[0]
+			} else {
+				ll.panic("exec.quota.builder.gpuMemory: accepts 0 or 1 argument")
+			}
 			return self
 		},
 
@@ -130,8 +135,8 @@ quotaBuilder := func() {
 			if !is_undefined(ram_request) {
 				data.memory = ram_request
 			}
-			if !is_undefined(gpu_request) && gpu_request > 0 {
-				data.gpu = gpu_request
+			if !is_undefined(gpu_request) {
+				data.gpuMemory = gpu_request
 			}
 
 			return smart.ephemeralBuilder(_RTYPE_QUOTA, json.encode(data)).lockAndBuild()

package/dist/tengo/lib/pframes.export-util.lib.tengo

@@ -0,0 +1,113 @@
+
+
+
+
+
+
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+slices := import("@platforma-sdk/workflow-tengo:slices")
+canonical := import("@platforma-sdk/workflow-tengo:canonical")
+pSpec := import("@platforma-sdk/workflow-tengo:pframes.spec")
+pt := import("@platforma-sdk/workflow-tengo:pt")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+buildExportSelectors := func(rawColumns, opts) {
+	axisLabel := opts.axisLabel
+	columnLabel := opts.columnLabel
+
+	ll.assert(is_callable(axisLabel), "opts.axisLabel must be callable")
+	ll.assert(is_callable(columnLabel), "opts.columnLabel must be callable")
+
+
+	labelOwners := {}
+	registerLabel := func(label, owner) {
+		prev := labelOwners[label]
+		ll.assert(is_undefined(prev),
+			"label '%s' is not unique (already used by %v, again by %v)",
+			label, prev, owner)
+		labelOwners[label] = owner
+	}
+
+
+
+	distiller := pSpec.createSpecDistiller(slices.map(rawColumns, func(c) {
+		return c.spec
+	}))
+
+
+
+
+	seenAxis := {}
+	uniqueAxes := []  // entries: { spec, label } — spec is distilled
+	for column in rawColumns {
+		for axis in column.spec.axesSpec {
+			distilled := distiller.distill(axis)
+			key := canonical.encode(distilled)
+			if is_undefined(seenAxis[key]) {
+				seenAxis[key] = true
+				label := axisLabel(axis)
+				registerLabel(label, axis.name)
+				uniqueAxes = append(uniqueAxes, {
+					spec: distilled,
+					label: label
+				})
+			}
+		}
+	}
+
+
+
+	sortSelectors := []
+	columnSelectors := []
+	for ua in uniqueAxes {
+		sortSelectors = append(sortSelectors, pt.axis(ua.spec))
+		columnSelectors = append(columnSelectors, pt.axis(ua.spec).alias(ua.label))
+	}
+	for column in rawColumns {
+		label := columnLabel(column)
+		registerLabel(label, column.spec.name)
+		columnSelectors = append(columnSelectors, pt.col(column.frameKey).alias(label))
+	}
+
+	return {
+		sortSelectors: sortSelectors,
+		columnSelectors: columnSelectors
+	}
+}
+
+export ll.toStrict({
+	buildExportSelectors: buildExportSelectors
+})

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

@@ -15,6 +15,7 @@ pSpec := import("@platforma-sdk/workflow-tengo:pframes.spec")
 validation := import("@platforma-sdk/workflow-tengo:validation")
 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")
 
 llProcessTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.process-pcolumn-data")
@@ -1110,5 +1111,6 @@ export ll.toStrict({
 	tsvFileBuilder: func() { return xsvBuilder.xsvFileBuilder("tsv") },
 	csvFileBuilder: func() { return xsvBuilder.xsvFileBuilder("csv") },
 	parquetFileBuilder: func() { return xsvBuilder.xsvFileBuilder("parquet") },
+	tableBuilder: tableBuilderMod.tableBuilder,
 	parseToJson: parseToJson
 })

package/dist/tengo/lib/pframes.table-builder.lib.tengo

@@ -0,0 +1,494 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+render := import("@platforma-sdk/workflow-tengo:render")
+assets := import("@platforma-sdk/workflow-tengo:assets")
+maps := import("@platforma-sdk/workflow-tengo:maps")
+pSpec := import("@platforma-sdk/workflow-tengo:pframes.spec")
+bquery := import("@platforma-sdk/workflow-tengo:workflow.bquery")
+
+buildTableTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.build-table")
+
+VALID_FORMATS := {
+	csv: true,
+	tsv: true,
+	ndjson: true,
+	parquet: true
+}
+
+
+
+isUnresolved := func(value) {
+	stack := [value]
+	si := 0
+	for si < len(stack) {
+		v := stack[si]
+		si += 1
+		if ll.isMap(v) {
+			for k, child in v {
+				if k == "__isRef" && child == true { return true }
+				stack = append(stack, child)
+			}
+		} else if is_array(v) {
+			for _, child in v {
+				stack = append(stack, child)
+			}
+		}
+	}
+	return false
+}
+
+
+isResolvedColumn := func(value) {
+	if !ll.isMap(value) { return false }
+	hasSpec := false
+	hasData := false
+	for k, _ in value {
+		if k == "spec" { hasSpec = true }
+		if k == "data" { hasData = true }
+	}
+	return hasSpec && hasData
+}
+
+
+isPrimaryRef := func(value) {
+	return ll.isMap(value) && value.__isPrimaryRef == "v1"
+}
+
+
+
+
+
+
+
+
+
+
+
+
+tableBuilder := func(format, ...ctxArg) {
+	ll.assert(!is_undefined(VALID_FORMATS[format]),
+		"format must be one of [tsv, csv, parquet, ndjson], got '%s'", format)
+
+	_ctx := undefined
+	if len(ctxArg) > 0 {
+		_ctx = ctxArg[0]
+	}
+
+	_primaries := []
+	_columns := []
+	_joinMode := "inner"
+	_axisHeaders := []
+	_cpu := undefined
+	_mem := undefined
+	_cacheInputs := undefined
+	_hasUnresolved := false
+
+	self := undefined
+	self = {
+
+
+
+
+
+
+
+
+
+		addPrimary: func(name, value, ...opts) {
+			ll.assert(is_string(name), "name must be a string")
+			header := undefined
+			if len(opts) > 0 && ll.isMap(opts[0]) {
+				header = opts[0].header
+			}
+
+			unresolved := isUnresolved(value)
+			if !unresolved {
+				ll.assert(
+					isResolvedColumn(value) ||
+						(isPrimaryRef(value) && isResolvedColumn(value.column)),
+					"value must be a resolved column {spec, data}, " +
+					"a resolved PrimaryRef, or a structure containing PlRefs; got: %v",
+					value)
+			}
+			if unresolved {
+				_hasUnresolved = true
+			}
+
+			_primaries = append(_primaries, {
+				name: name,
+				value: value,
+				header: header
+			})
+			return self
+		},
+
+
+
+
+
+
+
+
+
+		addColumn: func(query, ...opts) {
+			header := undefined
+			if len(opts) > 0 && ll.isMap(opts[0]) {
+				header = opts[0].header
+			}
+			if isUnresolved(query) {
+				_hasUnresolved = true
+			}
+			_columns = append(_columns, {
+				query: query,
+				header: header,
+				mode: "single"
+			})
+			return self
+		},
+
+
+
+
+
+
+
+
+
+		addColumns: func(query, ...opts) {
+			headerPrefix := undefined
+			headerSuffix := undefined
+			if len(opts) > 0 && ll.isMap(opts[0]) {
+				headerPrefix = opts[0].headerPrefix
+				headerSuffix = opts[0].headerSuffix
+			}
+
+
+			if is_array(query) {
+				for col in query {
+					ll.assert(isResolvedColumn(col),
+						"array elements must be resolved columns {spec, data}")
+					_columns = append(_columns, {
+						query: col,
+						headerPrefix: headerPrefix,
+						headerSuffix: headerSuffix,
+						mode: "multi"
+					})
+				}
+				return self
+			}
+
+			if isUnresolved(query) {
+				_hasUnresolved = true
+			}
+			_columns = append(_columns, {
+				query: query,
+				headerPrefix: headerPrefix,
+				headerSuffix: headerSuffix,
+				mode: "multi"
+			})
+			return self
+		},
+
+
+
+
+
+
+
+		setJoinMode: func(mode) {
+			ll.assert(mode == "inner" || mode == "full",
+				"mode must be 'inner' or 'full', got '%s'", mode)
+			_joinMode = mode
+			return self
+		},
+
+
+
+
+
+
+
+		setAxisHeader: func(matcher, header) {
+			ll.assert(is_string(header), "header must be a string")
+			processedMatcher := undefined
+			if is_string(matcher) {
+				processedMatcher = { name: matcher }
+			} else if ll.isMap(matcher) {
+				processedMatcher = pSpec.axisSpecToMatcher(matcher)
+			} else {
+				ll.panic("matcher must be a string or AxisSpec map")
+			}
+			_axisHeaders = append(_axisHeaders, [processedMatcher, header])
+			return self
+		},
+
+
+
+
+		cpu: func(cores) {
+			_cpu = cores
+			return self
+		},
+
+
+
+
+
+		mem: func(size) {
+			_mem = size
+			return self
+		},
+
+
+
+
+
+
+
+
+
+
+		cacheInputs: func(time) {
+			ll.assert(is_int(time),
+				"time must be an integer duration " +
+				"(did you forget to import the 'times' library?)")
+			_cacheInputs = time
+			return self
+		},
+
+
+
+
+
+
+		build: func() {
+			ll.assert(len(_primaries) > 0,
+				"at least one primary required")
+
+
+			hasQuerySpec := false
+			for _, c in _columns {
+				if !isUnresolved(c.query) && !isResolvedColumn(c.query) {
+					hasQuerySpec = true
+					break
+				}
+			}
+			if _hasUnresolved || hasQuerySpec {
+				ll.assert(!is_undefined(_ctx),
+					"unresolved inputs or column query specs require workflow context. " +
+					"Use wf.tableBuilder() or pass pre-resolved inputs.")
+			}
+
+
+			resolveColumn := func(value) {
+				if isUnresolved(value) {
+					r := bquery.resolve(value, _ctx)
+					return {
+						spec: r.getFutureInputField("spec"),
+						data: r.getFutureInputField("data")
+					}
+				}
+				return { spec: value.spec, data: value.data }
+			}
+
+
+
+
+
+
+
+			primaryEntries := []
+			primaryPlRefs := {}
+			for _, p in _primaries {
+				column := p.value
+				rawFilters := []
+				if isPrimaryRef(p.value) {
+					column = p.value.column
+					if !is_undefined(p.value.filter) {
+						rawFilters = append(rawFilters, p.value.filter)
+					}
+				}
+
+				resolvedCol := resolveColumn(column)
+				entry := {
+					name: p.name,
+					header: p.header,
+					spec: resolvedCol.spec,
+					data: resolvedCol.data,
+					filters: []
+				}
+				if isUnresolved(column) {
+					primaryPlRefs[p.name] = column
+				}
+
+				for _, rawFlt in rawFilters {
+					resolvedFlt := resolveColumn(rawFlt)
+					entry.filters = append(entry.filters, {
+						spec: resolvedFlt.spec,
+						data: resolvedFlt.data
+					})
+				}
+
+				primaryEntries = append(primaryEntries, entry)
+			}
+
+
+
+
+
+
+			singleQueryByIdx := {}
+			multiQueryResultByIdx := {}
+			qMap := {}
+			for idx, c in _columns {
+				if !isUnresolved(c.query) && !isResolvedColumn(c.query) {
+					strategy := "expectSingle"
+					if c.mode == "multi" { strategy = "expectMultiple" }
+					qMap["q" + string(idx)] = maps.deepMerge(c.query, {
+						matchStrategy: strategy
+					})
+				}
+			}
+			if len(qMap) > 0 {
+				ll.assert(len(primaryPlRefs) > 0,
+					"column query specs require at least one primary added as a PlRef " +
+					"or PrimaryRef (pre-resolved primaries cannot anchor column queries)")
+
+				qResult := bquery.anchoredQuery(_ctx, primaryPlRefs, qMap)
+				for idx, c in _columns {
+					if !isUnresolved(c.query) && !isResolvedColumn(c.query) {
+						r := qResult.getResult("q" + string(idx))
+						if c.mode == "multi" {
+
+
+							multiQueryResultByIdx[string(idx)] = r
+						} else {
+							singleQueryByIdx[string(idx)] = {
+								spec: r.getFutureInputField("spec"),
+								data: r.getFutureInputField("data")
+							}
+						}
+					}
+				}
+			}
+
+
+
+			columnEntries := []
+			for idx, c in _columns {
+				entry := {
+					mode: c.mode,
+					header: c.header,
+					headerPrefix: c.headerPrefix,
+					headerSuffix: c.headerSuffix
+				}
+				if isResolvedColumn(c.query) {
+					entry.spec = c.query.spec
+					entry.data = c.query.data
+				} else if isUnresolved(c.query) {
+					resolved := resolveColumn(c.query)
+					entry.spec = resolved.spec
+					entry.data = resolved.data
+				} else if c.mode == "multi" {
+					entry.multiResult = multiQueryResultByIdx[string(idx)]
+				} else {
+					qr := singleQueryByIdx[string(idx)]
+					entry.spec = qr.spec
+					entry.data = qr.data
+				}
+				columnEntries = append(columnEntries, entry)
+			}
+
+
+
+
+
+
+			primariesMap := {}
+			for idx, p in primaryEntries {
+				entry := {
+					__isPrimaryRef: "v1",
+					name: p.name,
+					column: { spec: p.spec, data: p.data }
+				}
+				if !is_undefined(p.header) { entry.header = p.header }
+
+				if len(p.filters) > 0 {
+					ll.assert(len(p.filters) == 1,
+						"v1 PrimaryRef supports at most one filter, got %d",
+						len(p.filters))
+					flt := p.filters[0]
+					entry.filter = { spec: flt.spec, data: flt.data }
+				}
+
+				primariesMap[string(idx)] = entry
+			}
+
+			columnsMap := {}
+			for idx, c in columnEntries {
+				entry := { mode: c.mode }
+				if !is_undefined(c.multiResult) {
+					entry.multiResult = c.multiResult
+				} else {
+					entry.spec = c.spec
+					entry.data = c.data
+				}
+				if !is_undefined(c.header) { entry.header = c.header }
+				if !is_undefined(c.headerPrefix) { entry.headerPrefix = c.headerPrefix }
+				if !is_undefined(c.headerSuffix) { entry.headerSuffix = c.headerSuffix }
+				columnsMap[string(idx)] = entry
+			}
+
+			tplInputs := {
+				format: format,
+				joinMode: _joinMode,
+				axisHeaders: _axisHeaders,
+				primaryCount: len(primaryEntries),
+				columnCount: len(columnEntries),
+				primaries: primariesMap,
+				columns: columnsMap
+			}
+
+			metaInputs := {}
+			if !is_undefined(_cpu) { metaInputs.cpu = _cpu }
+			if !is_undefined(_mem) { metaInputs.mem = _mem }
+			if !is_undefined(_cacheInputs) { metaInputs.cacheInputs = _cacheInputs }
+
+			run := render.createEphemeral(buildTableTpl, tplInputs, { metaInputs: metaInputs })
+			return run.output("result")
+		}
+	}
+	return ll.toStrict(self)
+}
+
+export ll.toStrict({
+	tableBuilder: tableBuilder
+})

package/dist/tengo/lib/tpl.base.lib.tengo

@@ -97,6 +97,15 @@ AWAIT_TEMPLATES := {
 		[{ wildcard: "*" }, "spec", "ResourceReady"],
 		[{ wildcard: "*" }, "data", "InputsLocked"],
 		[{ wildcard: "*" }, "data", { match: "^\\{.*\\}$" }, "InputsLocked"] // for multi-hit BQuery results; key is always ref
+	],
+
+
+
+
+
+	"PrimarySpecsReady": [
+		["column", "spec", "ResourceReady"],
+		[{ match: "^filter$" }, "spec", "ResourceReady"]
 	]
 }
 

package/dist/tengo/lib/workflow.lib.tengo

@@ -15,7 +15,9 @@ sets := import("@platforma-sdk/workflow-tengo:sets")
 oop := import("@platforma-sdk/workflow-tengo:oop")
 bobject := import("@platforma-sdk/workflow-tengo:workflow.bobject")
 bquery := import("@platforma-sdk/workflow-tengo:workflow.bquery")
+resolveUtil := import("@platforma-sdk/workflow-tengo:workflow.resolve-util")
 pBundle := import("@platforma-sdk/workflow-tengo:pframes.bundle")
+pTableBuilder := import("@platforma-sdk/workflow-tengo:pframes.table-builder")
 
 
 self := import("@platforma-sdk/workflow-tengo:tpl")
@@ -217,6 +219,13 @@ query := func(spec, ...options) {
 }
 
 
+_resolveOne := func(ref, ...options) {
+	r := bquery.resolve(ref, getParentBCtx(), options...)
+	return ll.toStrict(oop.inherit(r, {
+		spec: r.getFutureInputField("spec"),
+		data: r.getFutureInputField("data")
+	}))
+}
 
 
 
@@ -232,13 +241,38 @@ query := func(spec, ...options) {
 
 
 
-resolve := func(ref, ...options) {
-	r := bquery.resolve(ref, getParentBCtx(), options...)
 
-	return ll.toStrict(oop.inherit(r, {
-		spec: r.getFutureInputField("spec"),
-		data: r.getFutureInputField("data")
-	}))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+resolve := func(input, ...options) {
+
+
+
+	if ll.isMap(input) && (input.__isRef == true || (is_string(input.blockId) && is_string(input.name))) {
+		return _resolveOne(input, options...)
+	}
+
+
+	return resolveUtil.deepResolve(input, func(ref) {
+		return _resolveOne(ref, options...)
+	})
 }
 
 
@@ -367,6 +401,19 @@ createPBundleBuilder := func() {
 
 
 
+
+
+
+
+
+
+tableBuilder := func(format) {
+	return pTableBuilder.tableBuilder(format, getParentBCtx())
+}
+
+
+
+
 body := func(bodyFn) {
 
 	if _isProduction() {
@@ -411,5 +458,6 @@ export ll.toStrict({
 	blockId: blockId,
 	getBlockId: getBlockId,
 	validateArgs: validateArgs,
-	createPBundleBuilder: createPBundleBuilder
+	createPBundleBuilder: createPBundleBuilder,
+	tableBuilder: tableBuilder
 })

package/dist/tengo/lib/workflow.resolve-util.lib.tengo

@@ -0,0 +1,65 @@
+
+
+
+
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+
+
+
+
+
+
+
+
+
+
+
+
+
+deepResolve := func(value, resolveFn) {
+	root := { value: undefined }
+	queue := [{val: value, target: root, key: "value"}]
+	qi := 0
+	refCount := 0
+
+	for qi < len(queue) {
+		item := queue[qi]
+		qi = qi + 1
+		v := item.val
+
+		if ll.isMap(v) {
+			if v.__isRef == true {
+				refCount = refCount + 1
+				item.target[item.key] = resolveFn(v)
+			} else {
+				result := {}
+				item.target[item.key] = result
+				for k, child in v {
+					queue = append(queue, {val: child, target: result, key: k})
+				}
+			}
+		} else if is_array(v) {
+
+			result := []
+			for i := 0; i < len(v); i++ {
+				result = append(result, undefined)
+			}
+			item.target[item.key] = result
+			for idx, child in v {
+				queue = append(queue, {val: child, target: result, key: idx})
+			}
+		} else {
+			item.target[item.key] = v
+		}
+	}
+
+	ll.assert(refCount > 0,
+		"wf.resolve(): input contains no PlRef (__isRef: true)")
+
+	return root.value
+}
+
+export ll.toStrict({
+	deepResolve: deepResolve
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "5.13.3",
+  "version": "5.15.0",
   "description": "Tengo SDK library",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -18,11 +18,11 @@
   "dependencies": {
     "@milaboratories/software-pframes-conv": "2.2.9",
     "@platforma-open/milaboratories.software-small-binaries": "^2.0.3",
-    "@platforma-open/milaboratories.software-ptabler": "1.15.2",
-    "@platforma-open/milaboratories.software-ptexter": "1.2.2"
+    "@platforma-open/milaboratories.software-ptexter": "1.2.2",
+    "@platforma-open/milaboratories.software-ptabler": "1.15.2"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "2.5.8"
+    "@platforma-sdk/tengo-builder": "2.5.14"
   },
   "scripts": {
     "type-check": "pl-tengo check",