@platforma-sdk/workflow-tengo 6.6.4 → 6.7.0

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

@@ -27,6 +27,7 @@ RUNNER_EXECUTOR := "executor" // local binary execution
 
 META_INPUT_MEM_FORMULA := "__memFormula__"
 META_INPUT_CPU_FORMULA := "__cpuFormula__"
+META_INPUT_GPU_FORMULA := "__gpuFormula__"
 REGULAR_INPUT_LINE_COUNT := "__metric_lineCount__"
 
 export ll.toStrict({
@@ -47,5 +48,6 @@ export ll.toStrict({
 
 	META_INPUT_MEM_FORMULA: META_INPUT_MEM_FORMULA,
 	META_INPUT_CPU_FORMULA: META_INPUT_CPU_FORMULA,
+	META_INPUT_GPU_FORMULA: META_INPUT_GPU_FORMULA,
 	REGULAR_INPUT_LINE_COUNT: REGULAR_INPUT_LINE_COUNT
 })

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

@@ -18,6 +18,20 @@
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -51,19 +65,30 @@ units := import("@platforma-sdk/workflow-tengo:units")
 
 
 
+
+
+
 _KNOWN_OPS := sets.fromSlice([
 	"const", "metric", "metricSum",
-	"add", "sub", "mul", "div", "divCeil",
-	"max", "min", "clamp",
+	"plus", "minus", "times", "dividedBy", "dividedByFloor",
+	"atLeast", "atMost", "between",
 	"gt", "gte", "lt", "lte", "and", "or", "not",
-	"if"
+	"when"
 ])
 
 
 
 _BOOL_OPS := sets.fromSlice(["gt", "gte", "lt", "lte", "and", "or", "not"])
 
+
+
+
+_unwrap := func(x) {
+	return is_map(x) && !is_undefined(x.__isFormula__) ? x.__ast__ : x
+}
+
 _wrap := func(x) {
+	x = _unwrap(x)
 	if is_map(x) && !is_undefined(x.op) {
 		ll.assert(sets.hasElement(_KNOWN_OPS, x.op), "exec.formula: not a valid expression node (unknown op %v)", x.op)
 		return x
@@ -92,8 +117,22 @@ _metric := func(metricName, args) {
 	return node
 }
 
+
+
+
+_staticValue := func(v) {
+	if is_map(v) && !is_undefined(v.__isFormula__) {
+		a := v.__ast__
+		ll.assert(is_map(a) && a.op == "const",
+			"exec.formula.staticFallback: expected a constant (a number, a size string, or a pure unit like f.gib(64)), got a formula")
+		return a.value
+	}
+	return v
+}
+
 evaluate := undefined
 evaluate = func(node, resolver) {
+	node = _unwrap(node)
 	op := node.op
 	if op == "const" { return node.value }
 	if op == "metricSum" {
@@ -102,15 +141,17 @@ evaluate = func(node, resolver) {
 		return fn(node.files)
 	}
 
-	if op == "add" { return evaluate(node.a, resolver) + evaluate(node.b, resolver) }
-	if op == "sub" { return evaluate(node.a, resolver) - evaluate(node.b, resolver) }
-	if op == "mul" { return evaluate(node.a, resolver) * evaluate(node.b, resolver) }
-	if op == "div" {
+	if op == "plus"  { return evaluate(node.a, resolver) + evaluate(node.b, resolver) }
+	if op == "minus" { return evaluate(node.a, resolver) - evaluate(node.b, resolver) }
+	if op == "times" { return evaluate(node.a, resolver) * evaluate(node.b, resolver) }
+	if op == "dividedByFloor" {
 		b := evaluate(node.b, resolver)
 		ll.assert(b != 0, "exec.formula.evaluate: division by zero")
+
+
 		return evaluate(node.a, resolver) / b
 	}
-	if op == "divCeil" {
+	if op == "dividedBy" {
 		b := evaluate(node.b, resolver)
 		ll.assert(b != 0, "exec.formula.evaluate: division by zero")
 		a := evaluate(node.a, resolver)
@@ -118,13 +159,13 @@ evaluate = func(node, resolver) {
 		return (a + b - 1) / b
 	}
 
-	if op == "max" { a := evaluate(node.a, resolver); b := evaluate(node.b, resolver); return a > b ? a : b }
-	if op == "min" { a := evaluate(node.a, resolver); b := evaluate(node.b, resolver); return a < b ? a : b }
-	if op == "clamp" {
+	if op == "atLeast" { a := evaluate(node.a, resolver); b := evaluate(node.b, resolver); return a > b ? a : b }
+	if op == "atMost"  { a := evaluate(node.a, resolver); b := evaluate(node.b, resolver); return a < b ? a : b }
+	if op == "between" {
 		v := evaluate(node.value, resolver)
 		lo := evaluate(node.lo, resolver)
 		hi := evaluate(node.hi, resolver)
-		ll.assert(lo <= hi, "exec.formula.clamp: lo (%v) must be <= hi (%v) — inverted bounds collapse every input to hi", lo, hi)
+		ll.assert(lo <= hi, "exec.formula.between: lo (%v) must be <= hi (%v) — inverted bounds collapse every input to hi", lo, hi)
 		if v < lo { v = lo }
 		if v > hi { v = hi }
 		return v
@@ -138,7 +179,7 @@ evaluate = func(node, resolver) {
 	if op == "or"  { return evaluate(node.a, resolver) || evaluate(node.b, resolver) }
 	if op == "not" { return !evaluate(node.a, resolver) }
 
-	if op == "if" { return evaluate(node.cond, resolver) ? evaluate(node.then, resolver) : evaluate(node["else"], resolver) }
+	if op == "when" { return evaluate(node.cond, resolver) ? evaluate(node.then, resolver) : evaluate(node["else"], resolver) }
 
 	ll.panic("exec.formula.evaluate: unknown op %q", op)
 }
@@ -153,12 +194,13 @@ evaluate = func(node, resolver) {
 
 
 evaluateResource := func(node, resolver, label) {
+	node = _unwrap(node)
 	ll.assert(!sets.hasElement(_BOOL_OPS, node.op),
-		"exec resource formula (%s) must compute a number, but its top-level op is %q (a comparison/logic op). Use comparisons and logic only inside f.if(...).",
+		"exec resource formula (%s) must compute a number, but its top-level op is %q (a comparison/logic op). Use comparisons and logic only inside f.when(...).",
 		label, node.op)
 	v := evaluate(node, resolver)
 	ll.assert(is_int(v) && v > 0,
-		"exec resource formula (%s) must evaluate to a positive integer, got %v. If a metric can be zero or a subtraction can underflow, floor it with f.max(...) or f.clamp(...).",
+		"exec resource formula (%s) must evaluate to a positive integer, got %v. If a metric can be zero or a subtraction can underflow, floor it with .atLeast(...) or .between(...).",
 		label, v)
 	return v
 }
@@ -192,6 +234,7 @@ _assertMetricCompatible := func(metric, fileName) {
 
 resolveAst := undefined
 resolveAst = func(node, tagMap, allFiles) {
+	node = _unwrap(node)
 	op := node.op
 	if op == "metric" {
 		files := is_undefined(node.tag) ? allFiles : (is_undefined(tagMap[node.tag]) ? [] : tagMap[node.tag])
@@ -221,6 +264,7 @@ resolveAst = func(node, tagMap, allFiles) {
 }
 
 referencedMetricFiles := func(resolvedNode) {
+	resolvedNode = _unwrap(resolvedNode)
 	acc := {}
 	walk := undefined
 	walk = func(n) {
@@ -255,63 +299,135 @@ referencedMetricFiles := func(resolvedNode) {
 
 
 
+
+
 applyFormulaFallback := func(dims) {
-	res := { ram: dims.ram.static, cpu: dims.cpu.static, err: undefined }
-	if !is_undefined(dims.ram.ast) && is_undefined(res.ram) {
+	gpu := is_undefined(dims.gpu) ? {} : dims.gpu
+	res := { ram: dims.ram.static, cpu: dims.cpu.static, gpu: gpu.static, err: undefined }
+	if !is_undefined(_unwrap(dims.ram.ast)) && is_undefined(res.ram) {
 		if is_undefined(dims.ram.fallback) {
-			res.err = "exec.builder: memFormula needs a static fallback on backends that can't evaluate resource formulas at run time. Provide { fallback: ... } on memFormula, set a static .mem(), or upgrade the backend."
+			res.err = "exec.builder: the RAM formula needs a static fallback on backends that can't evaluate resource formulas at run time. Provide .staticFallback(...) on the RAM formula, set a static ram, or upgrade the backend."
 			return res
 		}
 		res.ram = dims.ram.fallback
 	}
-	if !is_undefined(dims.cpu.ast) && is_undefined(res.cpu) {
+	if !is_undefined(_unwrap(dims.cpu.ast)) && is_undefined(res.cpu) {
 		if is_undefined(dims.cpu.fallback) {
-			res.err = "exec.builder: cpuFormula needs a static fallback on backends that can't evaluate resource formulas at run time. Provide { fallback: ... } on cpuFormula, set a static .cpu(), or upgrade the backend."
+			res.err = "exec.builder: the CPU formula needs a static fallback on backends that can't evaluate resource formulas at run time. Provide .staticFallback(...) on the CPU formula, set a static cpu, or upgrade the backend."
 			return res
 		}
 		res.cpu = dims.cpu.fallback
 	}
+	if !is_undefined(_unwrap(gpu.ast)) && is_undefined(res.gpu) {
+		if is_undefined(gpu.fallback) {
+			res.err = "exec.builder: the VRAM formula needs a static fallback on backends that can't evaluate resource formulas at run time. Provide .staticFallback(...) on the vram formula, set a static vram, or upgrade the backend."
+			return res
+		}
+		res.gpu = gpu.fallback
+	}
 	return res
 }
 
+
+
+
+
+
+
+
+
+
+
+_node := undefined
+_node = func(ast, fallback) {
+	self := {
+		__isFormula__: true,
+		__ast__:       ast,
+		__fallback__:  fallback
+	}
+	self.plus      = func(x) { return _node(_bin("plus", ast, x), fallback) }
+	self.minus     = func(x) { return _node(_bin("minus", ast, x), fallback) }
+	self.times     = func(x) { return _node(_bin("times", ast, x), fallback) }
+	self.dividedBy      = func(x) { return _node(_bin("dividedBy", ast, x), fallback) }
+	self.dividedByFloor = func(x) { return _node(_bin("dividedByFloor", ast, x), fallback) }
+	self.atLeast   = func(x) { return _node(_bin("atLeast", ast, x), fallback) }
+	self.atMost    = func(x) { return _node(_bin("atMost", ast, x), fallback) }
+	self.between   = func(lo, hi) { return _node({ op: "between", value: _wrap(ast), lo: _wrap(lo), hi: _wrap(hi) }, fallback) }
+	self.gt        = func(x) { return _node(_bin("gt", ast, x), fallback) }
+	self.gte       = func(x) { return _node(_bin("gte", ast, x), fallback) }
+	self.lt        = func(x) { return _node(_bin("lt", ast, x), fallback) }
+	self.lte       = func(x) { return _node(_bin("lte", ast, x), fallback) }
+	self.and       = func(x) { return _node(_bin("and", ast, x), fallback) }
+	self.or        = func(x) { return _node(_bin("or", ast, x), fallback) }
+	self.not       = func() { return _node({ op: "not", a: _wrap(ast) }, fallback) }
+	self.staticFallback = func(v) { return _node(ast, _staticValue(v)) }
+	return self
+}
+
+
+
+
+
+_condBuilder := undefined
+_condBuilder = func(branches) {
+	self := {}
+	self.when = func(cond, value) {
+
+
+		next := []
+		for br in branches { next = append(next, br) }
+		next = append(next, { cond: _wrap(cond), value: _wrap(value) })
+		return _condBuilder(next)
+	}
+	self.otherwise = func(dflt) {
+		node := _wrap(dflt)
+		i := len(branches) - 1
+		for i >= 0 {
+			b := branches[i]
+			node = { op: "when", cond: b.cond, then: b.value, "else": node }
+			i = i - 1
+		}
+		return _node(node, undefined)
+	}
+	return self
+}
+
+_const := func(n) { ll.assert(is_int(n), "exec.formula: unit amount must be an integer"); return _node({ op: "const", value: n }, undefined) }
+
 export {
 
 
 
 
 
-	size:      func(...args) { return _metric("size", args) },
-	lineCount: func(...args) { return _metric("lineCount", args) },
+	size:      func(...args) { return _node(_metric("size", args), undefined) },
+	lineCount: func(...args) { return _node(_metric("lineCount", args), undefined) },
+
+	gib: func(n) { return _const(n * units.GiB) },
+	mib: func(n) { return _const(n * units.MiB) },
+	kib: func(n) { return _const(n * units.KiB) },
+	gb:  func(n) { return _const(n * units.GB) },
+	mb:  func(n) { return _const(n * units.MB) },
+	kb:  func(n) { return _const(n * units.KB) },
+
+
+
+	const: func(n) { return _const(n) },
+
+
+
 
-	gib: func(n) { ll.assert(is_int(n), "exec.formula.gib: n must be an integer"); return { op: "const", value: n * units.GiB } },
-	mib: func(n) { ll.assert(is_int(n), "exec.formula.mib: n must be an integer"); return { op: "const", value: n * units.MiB } },
-	kib: func(n) { ll.assert(is_int(n), "exec.formula.kib: n must be an integer"); return { op: "const", value: n * units.KiB } },
-	gb:  func(n) { ll.assert(is_int(n), "exec.formula.gb: n must be an integer");  return { op: "const", value: n * units.GB } },
-	mb:  func(n) { ll.assert(is_int(n), "exec.formula.mb: n must be an integer");  return { op: "const", value: n * units.MB } },
-	kb:  func(n) { ll.assert(is_int(n), "exec.formula.kb: n must be an integer");  return { op: "const", value: n * units.KB } },
 
-	add:     func(a, b) { return _bin("add", a, b) },
-	sub:     func(a, b) { return _bin("sub", a, b) },
-	mul:     func(a, b) { return _bin("mul", a, b) },
-	div:     func(a, b) { return _bin("div", a, b) },
+	when: func(cond, value) { return _condBuilder([]).when(cond, value) },
 
 
 
-	divCeil: func(a, b) { return _bin("divCeil", a, b) },
 
-	max:   func(a, b) { return _bin("max", a, b) },
-	min:   func(a, b) { return _bin("min", a, b) },
-	clamp: func(value, lo, hi) { return { op: "clamp", value: _wrap(value), lo: _wrap(lo), hi: _wrap(hi) } },
 
-	gt:  func(a, b) { return _bin("gt", a, b) },
-	gte: func(a, b) { return _bin("gte", a, b) },
-	lt:  func(a, b) { return _bin("lt", a, b) },
-	lte: func(a, b) { return _bin("lte", a, b) },
-	and: func(a, b) { return _bin("and", a, b) },
-	or:  func(a, b) { return _bin("or", a, b) },
-	not: func(a) { return { op: "not", a: _wrap(a) } },
 
-	"if": func(cond, then, els) { return { op: "if", cond: _wrap(cond), then: _wrap(then), "else": _wrap(els) } },
+	astOf:      func(x) { return _unwrap(x) },
+	fallbackOf: func(x) { return is_map(x) && !is_undefined(x.__isFormula__) ? x.__fallback__ : undefined },
+	isFormula:  func(x) { return is_map(x) && (!is_undefined(x.__isFormula__) || !is_undefined(x.op)) },
 
 	evaluateResource:      evaluateResource,
 	resolveAst:            resolveAst,

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

@@ -42,6 +42,7 @@ _lineCountResource := undefined
 
 
 
+
 _assertValidCpuRequest := func(amount, ctx) {
 	validation.assertType(amount, "number", ctx + ": amount of cores must be a number")
 	ll.assert(amount > 0, ctx + ": amount of cores should be greater than 0")
@@ -54,6 +55,14 @@ _assertValidMemRequest := func(amount, ctx) {
 
 
 
+_assertValidGpuRequest := func(amount, ctx) {
+	validation.assertType(amount, ["or", "number", "string"], ctx + ": VRAM amount must be a number of bytes or a size string like '16GiB'")
+	ll.assert(is_string(amount) || amount >= 16 * units.MiB, ctx + ": VRAM amount in bytes should be at least 16MiB (did you pass bytes instead of GiB?)")
+}
+
+
+
+
 
 
 builder := func() {
@@ -85,10 +94,15 @@ builder := func() {
 	gpuMemory := undefined
 
 
+
+
+
 	memFormulaAst := undefined
 	memFormulaFallback := undefined
 	cpuFormulaAst := undefined
 	cpuFormulaFallback := undefined
+	gpuFormulaAst := undefined
+	gpuFormulaFallback := undefined
 	fileTags := {}   // fileName -> tag (for f.size("tag") / f.lineCount("tag") aggregation)
 
 	commandName := ""
@@ -503,20 +517,6 @@ builder := func() {
 
 
 
-		memFormula: func(ast, ...opts) {
-			ll.assert(is_map(ast) && !is_undefined(ast.op), "exec.builder.memFormula: expected a formula node from exec.formula")
-			memFormulaAst = ast
-			if len(opts) > 0 && ll.isMap(opts[0]) {
-				for k, _ in opts[0] {
-					ll.assert(k == "fallback", "exec.builder.memFormula: unknown option %q (only { fallback } is supported)", k)
-				}
-				if !is_undefined(opts[0].fallback) {
-					_assertValidMemRequest(opts[0].fallback, "exec.builder.memFormula fallback")
-					memFormulaFallback = opts[0].fallback
-				}
-			}
-			return self
-		},
 
 
 
@@ -541,21 +541,116 @@ builder := func() {
 
 
 
+		resources: func(spec) {
+			ll.assert(ll.isMap(spec), "exec.builder.resources: expected a config map")
+			allowed := { queue: true, onCPU: true, onGPU: true }
+			for k, _ in spec {
+				ll.assert(!is_undefined(allowed[k]), "exec.builder.resources: unknown key %q (allowed: queue, onCPU, onGPU)", k)
+			}
+			hasCPU := !is_undefined(spec.onCPU)
+			hasGPU := !is_undefined(spec.onGPU)
+			ll.assert(hasCPU || hasGPU, "exec.builder.resources: provide onCPU and/or onGPU")
+
+			if !is_undefined(spec.queue) {
+				validation.assertType(spec.queue, "string", "exec.builder.resources: queue must be a string")
+				queue = spec.queue
+			}
 
 
 
-		cpuFormula: func(ast, ...opts) {
-			ll.assert(is_map(ast) && !is_undefined(ast.op), "exec.builder.cpuFormula: expected a formula node from exec.formula")
-			cpuFormulaAst = ast
-			if len(opts) > 0 && ll.isMap(opts[0]) {
-				for k, _ in opts[0] {
-					ll.assert(k == "fallback", "exec.builder.cpuFormula: unknown option %q (only { fallback } is supported)", k)
+
+
+
+
+
+
+			setCpu := func(v, ctx) {
+				if execFormula.isFormula(v) {
+					cpuFormulaAst = execFormula.astOf(v)
+					cpuFormulaFallback = undefined
+					fb := execFormula.fallbackOf(v)
+					if !is_undefined(fb) { _assertValidCpuRequest(fb, ctx + " cpu fallback"); cpuFormulaFallback = fb }
+					cpuRequest = undefined
+				} else {
+					_assertValidCpuRequest(v, ctx + " cpu")
+					cpuRequest = v
+					cpuFormulaAst = undefined
+					cpuFormulaFallback = undefined
 				}
-				if !is_undefined(opts[0].fallback) {
-					_assertValidCpuRequest(opts[0].fallback, "exec.builder.cpuFormula fallback")
-					cpuFormulaFallback = opts[0].fallback
+			}
+			setRam := func(v, ctx) {
+				if execFormula.isFormula(v) {
+					memFormulaAst = execFormula.astOf(v)
+					memFormulaFallback = undefined
+					fb := execFormula.fallbackOf(v)
+					if !is_undefined(fb) { _assertValidMemRequest(fb, ctx + " ram fallback"); memFormulaFallback = fb }
+					ramRequest = undefined
+				} else {
+					_assertValidMemRequest(v, ctx + " ram")
+					ramRequest = v
+					memFormulaAst = undefined
+					memFormulaFallback = undefined
 				}
 			}
+			setVram := func(v, ctx) {
+				if execFormula.isFormula(v) {
+					gpuFormulaAst = execFormula.astOf(v)
+					gpuFormulaFallback = undefined
+					fb := execFormula.fallbackOf(v)
+					if !is_undefined(fb) { _assertValidGpuRequest(fb, ctx + " vram fallback"); gpuFormulaFallback = fb }
+					gpuMemory = undefined
+				} else {
+					_assertValidGpuRequest(v, ctx + " vram")
+					gpuMemory = v
+					gpuFormulaAst = undefined
+					gpuFormulaFallback = undefined
+				}
+			}
+
+			assertKeys := func(block, name, allowVram) {
+				ll.assert(ll.isMap(block), "exec.builder.resources.%s: expected a map", name)
+				for k, _ in block {
+					ok := k == "cpu" || k == "ram" || (allowVram && k == "vram")
+					ll.assert(ok, "exec.builder.resources.%s: unknown key %q (allowed: %s)", name, k, allowVram ? "cpu, ram, vram" : "cpu, ram")
+				}
+				ll.assert(!is_undefined(block.cpu) && !is_undefined(block.ram),
+					"exec.builder.resources.%s: cpu and ram are required", name)
+				if allowVram {
+					ll.assert(!is_undefined(block.vram),
+						"exec.builder.resources.%s: vram is required (it is what makes this a GPU allocation)", name)
+				}
+			}
+
+			if hasCPU { assertKeys(spec.onCPU, "onCPU", false) }
+			if hasGPU { assertKeys(spec.onGPU, "onGPU", true) }
+
+
+
+
+
+
+
+			useGPU := hasGPU && (!hasCPU || feats.hasGpu)
+			if hasGPU && !hasCPU {
+				ll.assert(feats.hasGpu,
+					"exec.builder.resources: onGPU was set without onCPU (GPU required), but this backend has no GPU support (exec.hasGpu is false). Add an onCPU block for an adaptive CPU fallback, or run on a GPU-enabled backend.")
+			}
+
+			if useGPU {
+				g := spec.onGPU
+				setCpu(g.cpu, "resources.onGPU")
+				setRam(g.ram, "resources.onGPU")
+				setVram(g.vram, "resources.onGPU")
+			} else {
+				c := spec.onCPU
+				setCpu(c.cpu, "resources.onCPU")
+				setRam(c.ram, "resources.onCPU")
+
+
+				gpuMemory = undefined
+				gpuFormulaAst = undefined
+				gpuFormulaFallback = undefined
+			}
 			return self
 		},
 
@@ -567,6 +662,9 @@ builder := func() {
 
 
 
+
+
+
 		gpuMemory: func(...args) {
 			ll.assert(len(args) <= 1, "exec.builder.gpuMemory: accepts 0 or 1 argument")
 			if len(args) == 0 {
@@ -1235,9 +1333,10 @@ builder := func() {
 
 
 
-			hasFormula := !is_undefined(memFormulaAst) || !is_undefined(cpuFormulaAst)
+			hasFormula := !is_undefined(memFormulaAst) || !is_undefined(cpuFormulaAst) || !is_undefined(gpuFormulaAst)
 			resolvedMem := undefined
 			resolvedCpu := undefined
+			resolvedGpu := undefined
 			lineCountMapResource := undefined
 
 			if hasFormula {
@@ -1258,12 +1357,15 @@ builder := func() {
 
 					fb := execFormula.applyFormulaFallback({
 						ram: { ast: memFormulaAst, fallback: memFormulaFallback, static: ramRequest },
-						cpu: { ast: cpuFormulaAst, fallback: cpuFormulaFallback, static: cpuRequest }
+						cpu: { ast: cpuFormulaAst, fallback: cpuFormulaFallback, static: cpuRequest },
+						gpu: { ast: gpuFormulaAst, fallback: gpuFormulaFallback, static: gpuMemory }
 					})
 					ll.assert(is_undefined(fb.err), fb.err)
 					ramRequest = fb.ram
 					cpuRequest = fb.cpu
+					gpuMemory = fb.gpu
 					if is_int(ramRequest) { ramRequest = string(ramRequest) + "b" }
+					if is_int(gpuMemory) { gpuMemory = string(gpuMemory) + "b" }
 				} else {
 					tagMap := {}
 					for fileName, tag in fileTags {
@@ -1283,6 +1385,11 @@ builder := func() {
 						refs := execFormula.referencedMetricFiles(resolvedCpu)
 						if !is_undefined(refs.lineCount) { sets.add(neededLineCount, refs.lineCount...) }
 					}
+					if !is_undefined(gpuFormulaAst) {
+						resolvedGpu = execFormula.resolveAst(gpuFormulaAst, tagMap, allFiles)
+						refs := execFormula.referencedMetricFiles(resolvedGpu)
+						if !is_undefined(refs.lineCount) { sets.add(neededLineCount, refs.lineCount...) }
+					}
 
 					if len(neededLineCount) > 0 {
 						perFile := {}
@@ -1299,16 +1406,18 @@ builder := func() {
 				cpu: cpuRequest,
 				ram: ramRequest
 			}
-			if !is_undefined(gpuMemory) {
+			if !is_undefined(gpuMemory) || !is_undefined(gpuFormulaAst) {
 
 
 
 
 
 
-				ll.assert(!is_undefined(cpuRequest) || !is_undefined(cpuFormulaAst), "exec.builder: cpu() or cpuFormula() is required when gpuMemory() is set. GPU nodes vary in CPU capacity and cost; please provide an explicit CPU request.")
-				ll.assert(!is_undefined(ramRequest) || !is_undefined(memFormulaAst), "exec.builder: mem() or memFormula() is required when gpuMemory() is set. GPU nodes vary in RAM capacity and cost; please provide an explicit RAM request.")
-				quotaData.gpuMemory = gpuMemory
+				ll.assert(!is_undefined(cpuRequest) || !is_undefined(cpuFormulaAst), "exec.builder: a cpu request is required when a GPU is requested. GPU nodes vary in CPU capacity and cost; please provide an explicit CPU request.")
+				ll.assert(!is_undefined(ramRequest) || !is_undefined(memFormulaAst), "exec.builder: a ram request is required when a GPU is requested. GPU nodes vary in RAM capacity and cost; please provide an explicit RAM request.")
+
+
+				if !is_undefined(gpuMemory) { quotaData.gpuMemory = gpuMemory }
 			}
 			metaExecInputs := {
 				quota: smart.createJsonResource(quotaData)
@@ -1332,6 +1441,7 @@ builder := func() {
 
 			if !is_undefined(resolvedMem) { metaExecInputs[execConstants.META_INPUT_MEM_FORMULA] = smart.createJsonResource(resolvedMem) }
 			if !is_undefined(resolvedCpu) { metaExecInputs[execConstants.META_INPUT_CPU_FORMULA] = smart.createJsonResource(resolvedCpu) }
+			if !is_undefined(resolvedGpu) { metaExecInputs[execConstants.META_INPUT_GPU_FORMULA] = smart.createJsonResource(resolvedGpu) }
 			if !is_undefined(lineCountMapResource) { pureExecInputs[execConstants.REGULAR_INPUT_LINE_COUNT] = lineCountMapResource }
 
 
@@ -1528,6 +1638,7 @@ export ll.toStrict({
 
 
 
+
 	hasGpu: feats.hasGpu,
 	formula: execFormula
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "6.6.4",
+  "version": "6.7.0",
   "description": "Tengo SDK library",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -19,11 +19,11 @@
     "@milaboratories/pframes-rs-wasip2": "1.1.52",
     "@milaboratories/software-pframes-conv": "2.2.9",
     "@platforma-open/milaboratories.software-small-binaries": "^2.1.1",
-    "@platforma-open/milaboratories.software-ptexter": "1.2.2",
-    "@platforma-open/milaboratories.software-ptabler": "2.1.2"
+    "@platforma-open/milaboratories.software-ptabler": "2.1.4",
+    "@platforma-open/milaboratories.software-ptexter": "1.2.3"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "4.0.9"
+    "@platforma-sdk/tengo-builder": "4.0.15"
   },
   "scripts": {
     "type-check": "pl-tengo check",