@platforma-sdk/workflow-tengo 6.3.3 → 6.5.0

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

@@ -16,6 +16,19 @@ UI_TASKS_QUEUE := "ui-tasks"
 RUNNER_BATCH    := "batch"    // batch system execution (k8s jobs, etc.)
 RUNNER_EXECUTOR := "executor" // local binary execution
 
+
+
+
+
+
+
+
+
+
+META_INPUT_MEM_FORMULA := "__memFormula__"
+META_INPUT_CPU_FORMULA := "__cpuFormula__"
+REGULAR_INPUT_LINE_COUNT := "__metric_lineCount__"
+
 export ll.toStrict({
 	ARG_TYPE_STRING: ARG_TYPE_STRING,
 	ARG_TYPE_EXPRESSION: ARG_TYPE_EXPRESSION,
@@ -30,5 +43,9 @@ export ll.toStrict({
 	HEAVY_QUEUE: HEAVY_QUEUE,
 
 	RUNNER_BATCH: RUNNER_BATCH,
-	RUNNER_EXECUTOR: RUNNER_EXECUTOR
+	RUNNER_EXECUTOR: RUNNER_EXECUTOR,
+
+	META_INPUT_MEM_FORMULA: META_INPUT_MEM_FORMULA,
+	META_INPUT_CPU_FORMULA: META_INPUT_CPU_FORMULA,
+	REGULAR_INPUT_LINE_COUNT: REGULAR_INPUT_LINE_COUNT
 })

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

@@ -0,0 +1,327 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+text := import("text")
+slices := import("@platforma-sdk/workflow-tengo:slices")
+maps := import("@platforma-sdk/workflow-tengo:maps")
+sets := import("@platforma-sdk/workflow-tengo:sets")
+units := import("@platforma-sdk/workflow-tengo:units")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+_KNOWN_OPS := sets.fromSlice([
+	"const", "metric", "metricSum",
+	"add", "sub", "mul", "div", "divCeil",
+	"max", "min", "clamp",
+	"gt", "gte", "lt", "lte", "and", "or", "not",
+	"if"
+])
+
+
+
+_BOOL_OPS := sets.fromSlice(["gt", "gte", "lt", "lte", "and", "or", "not"])
+
+_wrap := func(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
+	}
+	ll.assert(is_int(x), "exec.formula: expected an expression node or an integer, got %v", x)
+	return { op: "const", value: x }
+}
+
+_bin := func(op, a, b) { return { op: op, a: _wrap(a), b: _wrap(b) } }
+
+
+_metric := func(metricName, args) {
+	node := { op: "metric", metric: metricName }
+	for arg in args {
+		if is_string(arg) {
+			ll.assert(is_undefined(node.tag), "exec.formula.%s: tag specified more than once", metricName)
+			node.tag = arg
+		} else if is_map(arg) && !is_undefined(arg.default) {
+			ll.assert(is_undefined(node.default), "exec.formula.%s: default specified more than once", metricName)
+			ll.assert(is_int(arg.default), "exec.formula.%s: default must be an integer", metricName)
+			node.default = arg.default
+		} else {
+			ll.panic("exec.formula.%s: unexpected argument %v", metricName, arg)
+		}
+	}
+	return node
+}
+
+evaluate := undefined
+evaluate = func(node, resolver) {
+	op := node.op
+	if op == "const" { return node.value }
+	if op == "metricSum" {
+		fn := resolver[node.metric]
+		ll.assert(!is_undefined(fn), "exec.formula.evaluate: no resolver for metric %q", node.metric)
+		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" {
+		b := evaluate(node.b, resolver)
+		ll.assert(b != 0, "exec.formula.evaluate: division by zero")
+		return evaluate(node.a, resolver) / b
+	}
+	if op == "divCeil" {
+		b := evaluate(node.b, resolver)
+		ll.assert(b != 0, "exec.formula.evaluate: division by zero")
+		a := evaluate(node.a, 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" {
+		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)
+		if v < lo { v = lo }
+		if v > hi { v = hi }
+		return v
+	}
+
+	if op == "gt"  { return evaluate(node.a, resolver) > evaluate(node.b, resolver) }
+	if op == "gte" { return evaluate(node.a, resolver) >= evaluate(node.b, resolver) }
+	if op == "lt"  { return evaluate(node.a, resolver) < evaluate(node.b, resolver) }
+	if op == "lte" { return evaluate(node.a, resolver) <= evaluate(node.b, resolver) }
+	if op == "and" { return evaluate(node.a, resolver) && evaluate(node.b, 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) }
+
+	ll.panic("exec.formula.evaluate: unknown op %q", op)
+}
+
+
+
+
+
+
+
+
+
+
+evaluateResource := func(node, resolver, label) {
+	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(...).",
+		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(...).",
+		label, v)
+	return v
+}
+
+
+
+
+
+
+
+_LINECOUNT_OK := sets.fromSlice(["csv", "tsv", "txt", "fastq", "fq", "fasta", "fa", "tab"])
+_COMPRESSION_EXT := sets.fromSlice(["gz", "bz2", "zst"])
+
+_assertMetricCompatible := func(metric, fileName) {
+	if metric == "lineCount" {
+
+
+
+
+
+		parts := text.split(fileName, ".")
+		if len(parts) >= 2 && sets.hasElement(_COMPRESSION_EXT, text.to_lower(parts[len(parts)-1])) {
+			parts = parts[0:len(parts)-1]
+		}
+		ext := len(parts) >= 2 ? parts[len(parts)-1] : ""
+		ll.assert(sets.hasElement(_LINECOUNT_OK, text.to_lower(ext)),
+			"exec.formula: lineCount is not supported for file %q (extension %q is not a line-oriented text format)", fileName, ext)
+	}
+
+}
+
+resolveAst := undefined
+resolveAst = func(node, tagMap, allFiles) {
+	op := node.op
+	if op == "metric" {
+		files := is_undefined(node.tag) ? allFiles : (is_undefined(tagMap[node.tag]) ? [] : tagMap[node.tag])
+		if len(files) == 0 {
+			if is_undefined(node.tag) {
+				ll.assert(!is_undefined(node.default),
+					"exec.formula: f.%s() references all input files but the exec has none, and no { default: ... } was given", node.metric)
+			} else {
+				ll.assert(!is_undefined(node.default),
+					"exec.formula: tag %q has no files and no { default: ... } was given", node.tag)
+			}
+			return { op: "const", value: node.default }
+		}
+		for fn in files { _assertMetricCompatible(node.metric, fn) }
+		files = slices.quickSort(files)
+
+
+
+
+		return { op: "metricSum", metric: node.metric, files: files }
+	}
+
+
+	return maps.mapValues(node, func(v) {
+		return is_map(v) && !is_undefined(v.op) ? resolveAst(v, tagMap, allFiles) : v
+	})
+}
+
+referencedMetricFiles := func(resolvedNode) {
+	acc := {}
+	walk := undefined
+	walk = func(n) {
+		if n.op == "metricSum" {
+			if n.metric != "size" {
+				existing := is_undefined(acc[n.metric]) ? [] : acc[n.metric]
+				for fn in n.files { existing = append(existing, fn) }
+
+
+
+				acc[n.metric] = slices.unique(existing)
+			}
+			return
+		}
+		for k, v in n {
+			if is_map(v) && !is_undefined(v.op) { walk(v) }
+		}
+	}
+	walk(resolvedNode)
+	return acc
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+applyFormulaFallback := func(dims) {
+	res := { ram: dims.ram.static, cpu: dims.cpu.static, err: undefined }
+	if !is_undefined(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."
+			return res
+		}
+		res.ram = dims.ram.fallback
+	}
+	if !is_undefined(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."
+			return res
+		}
+		res.cpu = dims.cpu.fallback
+	}
+	return res
+}
+
+export {
+
+
+
+
+
+	size:      func(...args) { return _metric("size", args) },
+	lineCount: func(...args) { return _metric("lineCount", args) },
+
+	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) },
+
+
+
+	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) } },
+
+	evaluateResource:      evaluateResource,
+	resolveAst:            resolveAst,
+	referencedMetricFiles: referencedMetricFiles,
+	applyFormulaFallback:  applyFormulaFallback,
+
+
+
+
+
+
+	_internal: { evaluate: evaluate }
+}

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

@@ -19,6 +19,7 @@ constants := import("@platforma-sdk/workflow-tengo:constants")
 canonical := import("@platforma-sdk/workflow-tengo:canonical")
 monetization := import("@platforma-sdk/workflow-tengo:exec.monetization_internal")
 execConstants := import("@platforma-sdk/workflow-tengo:exec.constants")
+execFormula := import("@platforma-sdk/workflow-tengo:exec.formula")
 units := import("@platforma-sdk/workflow-tengo:units")
 feats := import("@platforma-sdk/workflow-tengo:feats")
 
@@ -27,6 +28,34 @@ feats := import("@platforma-sdk/workflow-tengo:feats")
 
 
 
+lineCounterSoft := assets.importSoftware("@platforma-open/milaboratories.software-small-binaries:line-counter")
+
+
+
+
+
+
+_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")
+}
+_assertValidMemRequest := func(amount, ctx) {
+	validation.assertType(amount, ["or", "number", "string"], ctx + ": RAM amount should be a number or string")
+	ll.assert(is_string(amount) || amount >= 16 * units.MiB, ctx + ": amount in bytes should be at least 16MiB")
+}
+
+
+
+
+
+
 builder := func() {
 	self := undefined
 
@@ -55,6 +84,13 @@ builder := func() {
 	ramRequest := undefined
 	gpuMemory := undefined
 
+
+	memFormulaAst := undefined
+	memFormulaFallback := undefined
+	cpuFormulaAst := undefined
+	cpuFormulaFallback := undefined
+	fileTags := {}   // fileName -> tag (for f.size("tag") / f.lineCount("tag") aggregation)
+
 	commandName := ""
 	cache := 0
 	inputCache := 0
@@ -405,8 +441,7 @@ builder := func() {
 
 
 		cpu: func(amount) {
-			validation.assertType(amount, "number", "exec.builder.cpu: amount of cores must be a number")
-			ll.assert(amount > 0, "exec.builder.cpu: amount of cores should be greater than 0")
+			_assertValidCpuRequest(amount, "exec.builder.cpu")
 			cpuRequest = amount
 
 			return self
@@ -424,8 +459,7 @@ builder := func() {
 
 
 		mem: func(amount) {
-			validation.assertType(amount, ["or", "number", "string"], "exec.builder.mem: RAM amount should be a number or string")
-			ll.assert(is_string(amount) || amount >= 16 * units.MiB, "exec.builder.mem: amount in bytes should be at least 16MiB")
+			_assertValidMemRequest(amount, "exec.builder.mem")
 			ramRequest = amount
 
 			return self
@@ -448,6 +482,89 @@ 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
+		},
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+		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)
+				}
+				if !is_undefined(opts[0].fallback) {
+					_assertValidCpuRequest(opts[0].fallback, "exec.builder.cpuFormula fallback")
+					cpuFormulaFallback = opts[0].fallback
+				}
+			}
+			return self
+		},
+
+
+
+
+
+
+
 
 
 		gpuMemory: func(...args) {
@@ -786,8 +903,14 @@ builder := func() {
 
 			fileName = path.canonize(fileName)
 			filesToAdd[fileName] = file
-			if len(opts) > 0 && ll.isMap(opts[0]) && opts[0].writable == true {
-				sets.add(writableFiles, fileName)
+			if len(opts) > 0 && ll.isMap(opts[0]) {
+				if opts[0].writable == true {
+					sets.add(writableFiles, fileName)
+				}
+				if !is_undefined(opts[0].tag) {
+					ll.assert(is_string(opts[0].tag), "exec.builder().addFile: tag must be a string")
+					fileTags[fileName] = opts[0].tag
+				}
 			}
 			monetization.addOptionalArg(mnz, fileName, opts...)
 			return self
@@ -1103,14 +1226,88 @@ builder := func() {
 			if (is_int(ramRequest)) {
 				ramRequest = string(ramRequest) + "b"
 			}
+
+
+
+
+
+
+
+
+
+			hasFormula := !is_undefined(memFormulaAst) || !is_undefined(cpuFormulaAst)
+			resolvedMem := undefined
+			resolvedCpu := undefined
+			lineCountMapResource := undefined
+
+			if hasFormula {
+
+
+
+
+
+
+
+
+				canEvaluateFormulas := feats.hasBlobSize
+				if !canEvaluateFormulas {
+
+
+
+
+
+					fb := execFormula.applyFormulaFallback({
+						ram: { ast: memFormulaAst, fallback: memFormulaFallback, static: ramRequest },
+						cpu: { ast: cpuFormulaAst, fallback: cpuFormulaFallback, static: cpuRequest }
+					})
+					ll.assert(is_undefined(fb.err), fb.err)
+					ramRequest = fb.ram
+					cpuRequest = fb.cpu
+					if is_int(ramRequest) { ramRequest = string(ramRequest) + "b" }
+				} else {
+					tagMap := {}
+					for fileName, tag in fileTags {
+						existing := is_undefined(tagMap[tag]) ? [] : tagMap[tag]
+						tagMap[tag] = append(existing, fileName)
+					}
+					allFiles := maps.getKeys(filesToAdd)
+
+					neededLineCount := {}
+					if !is_undefined(memFormulaAst) {
+						resolvedMem = execFormula.resolveAst(memFormulaAst, tagMap, allFiles)
+						refs := execFormula.referencedMetricFiles(resolvedMem)
+						if !is_undefined(refs.lineCount) { sets.add(neededLineCount, refs.lineCount...) }
+					}
+					if !is_undefined(cpuFormulaAst) {
+						resolvedCpu = execFormula.resolveAst(cpuFormulaAst, tagMap, allFiles)
+						refs := execFormula.referencedMetricFiles(resolvedCpu)
+						if !is_undefined(refs.lineCount) { sets.add(neededLineCount, refs.lineCount...) }
+					}
+
+					if len(neededLineCount) > 0 {
+						perFile := {}
+						for fn, _ in neededLineCount {
+							perFile[fn] = _lineCountResource(fn, filesToAdd[fn])
+						}
+						lineCountMapResource = smart.createMapResource(perFile)
+					}
+				}
+			}
+
 			quotaData := {
 				queue: queue,
 				cpu: cpuRequest,
 				ram: ramRequest
 			}
 			if !is_undefined(gpuMemory) {
-				ll.assert(!is_undefined(cpuRequest), "exec.builder: cpu() 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), "exec.builder: mem() is required when gpuMemory() is set. GPU nodes vary in RAM capacity and cost; please provide an explicit RAM request.")
+
+
+
+
+
+
+				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
 			}
 			metaExecInputs := {
@@ -1120,6 +1317,26 @@ 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(lineCountMapResource) { pureExecInputs[execConstants.REGULAR_INPUT_LINE_COUNT] = lineCountMapResource }
+
+
+
+
 			if monetization.shouldRun(mnz) {
 				pureExecInputs.runOptions.monetization = monetization.toJson(mnz)
 			}
@@ -1283,6 +1500,27 @@ builder := func() {
 	return self
 }
 
+
+
+
+
+
+_lineCountResource = func(fileName, fileRef) {
+	countOut := "linecount.txt"
+	res := builder().
+		software(lineCounterSoft).
+		addFile(fileName, fileRef).
+		arg("--input").arg(fileName).
+		arg("--output").arg(countOut).
+		saveFileContent(countOut).
+		inLightQueue().
+		cacheInputsDays(30).
+		mem("256MiB").
+		cpu(1).
+		run()
+	return res.getFileContent(countOut)
+}
+
 export ll.toStrict({
 	builder: builder,
 
@@ -1290,5 +1528,6 @@ export ll.toStrict({
 
 
 
-	hasGpu: feats.hasGpu
+	hasGpu: feats.hasGpu,
+	formula: execFormula
 })

package/dist/tengo/lib/feats.lib.tengo

@@ -77,5 +77,10 @@ export ll.toStrict({
 	secretEnvSupport:         _isEnabled("secretEnvSupport"),
 
 
-	contextDomainQuery:       _isEnabled("contextDomainQuery")
+	contextDomainQuery:       _isEnabled("contextDomainQuery"),
+
+
+
+
+	multiStepProgress:        _isEnabled("multiStepProgress")
 })

package/dist/tengo/lib/file.internal.lib.tengo

@@ -12,6 +12,7 @@
 ll := import("@platforma-sdk/workflow-tengo:ll")
 smart := import("@platforma-sdk/workflow-tengo:smart")
 validation := import("@platforma-sdk/workflow-tengo:validation")
+feats := import("@platforma-sdk/workflow-tengo:feats")
 
 json := import("json")
 
@@ -19,6 +20,22 @@ json := import("json")
 
 
 
+
+
+
+
+
+_progressField := func(importer, handleField) {
+	if feats.multiStepProgress {
+		return importer.getField("progress")
+	}
+	return smart.mapBuilder().addRef("01", handleField).build()
+}
+
+
+
+
+
 RTYPE_BLOB_IMPORT_EXTERNAL := { Name: "BlobImportExternal", Version: "1" }
 RTYPE_BLOB_IMPORT_INTERNAL := { Name: "BlobImportInternal", Version: "1" }
 RTYPE_BLOB_UPLOAD := { Name: "BlobUpload", Version: "1" }
@@ -30,6 +47,9 @@ RTYPE_BLOB_DOWNLOAD := { Name: "BlobDownload", Version: "2" }
 
 
 
+
+
+
 createBlobImportExternal := func(settings) {
 	validation.assertType(settings, {
 		"dataURL": "string",
@@ -38,10 +58,12 @@ createBlobImportExternal := func(settings) {
 	})
 
 	importer := smart.structBuilder(RTYPE_BLOB_IMPORT_EXTERNAL, json.encode(settings)).lockAndBuild()
+	handleField := importer.getField("handle")
 
 	return ll.toStrict({
 		file: importer.getField("blob"),
-		handle: importer.getField("handle")
+		handle: handleField,
+		progress: _progressField(importer, handleField)
 	})
 }
 
@@ -51,6 +73,9 @@ createBlobImportExternal := func(settings) {
 
 
 
+
+
+
 createBlobImportInternal := func(settings) {
 	validation.assertType(settings, {
 		"path": "string",
@@ -60,10 +85,12 @@ createBlobImportInternal := func(settings) {
 	})
 
 	importer := smart.structBuilder(RTYPE_BLOB_IMPORT_INTERNAL, json.encode(settings)).lockAndBuild()
+	handleField := importer.getField("handle")
 
 	return ll.toStrict({
 		file: importer.getField("blob"),
-		handle: importer.getField("handle")
+		handle: handleField,
+		progress: _progressField(importer, handleField)
 	})
 }
 
@@ -73,6 +100,9 @@ createBlobImportInternal := func(settings) {
 
 
 
+
+
+
 createBlobUpload := func(settings) {
 	validation.assertType(settings, {
 		"modificationTime": "string",
@@ -82,10 +112,12 @@ createBlobUpload := func(settings) {
 	})
 
 	uploader := smart.structBuilder(RTYPE_BLOB_UPLOAD, json.encode(settings)).lockAndBuild()
+	handleField := uploader.getField("handle")
 
 	return ll.toStrict({
 		file: uploader.getField("blob"),
-		handle: uploader.getField("handle")
+		handle: handleField,
+		progress: _progressField(uploader, handleField)
 	})
 }
 

package/dist/tengo/lib/file.lib.tengo

@@ -31,6 +31,10 @@ json := import("json")
 
 
 
+
+
+
+
 importFile := func(importFileHandle) {
 	validation.assertType(
 		importFileHandle,

package/dist/tengo/lib/pt.lib.tengo

@@ -442,6 +442,14 @@ workflow := func() {
 
 
 
+		_testGetLastRawStep: func() {
+			ll.assert(len(steps) > 0, "_testGetLastRawStep: no steps registered")
+			return steps[len(steps)-1](undefined)
+		},
+
+
+
+
 
 
 
@@ -513,6 +521,7 @@ workflow := func() {
 			nRowsOpt := undefined
 			ignoreErrorsOpt := undefined
 			commentPrefixOpt := undefined
+			delimiterOpt := undefined
 
 			if is_map(frameInput) && !is_undefined(frameInput.file) {
 				fileRef = frameInput.file
@@ -610,6 +619,15 @@ workflow := func() {
 				commentPrefixOpt = opts.commentPrefix
 			}
 
+			if !is_undefined(opts.delimiter) {
+				if !is_string(opts.delimiter) {
+					ll.panic("'delimiter' option must be a string. Got: %T", opts.delimiter)
+				}
+				ll.assert(finalFormat == "csv" || finalFormat == "tsv",
+					"'delimiter' option applies only to csv/tsv reads, not %q", finalFormat)
+				delimiterOpt = opts.delimiter
+			}
+
 			if !is_undefined(fileRef) {
 				ll.assert(
 					smart.isReference(fileRef),
@@ -682,6 +700,13 @@ workflow := func() {
 				if !is_undefined(commentPrefixOpt) {
 					step.commentPrefix = commentPrefixOpt
 				}
+
+
+
+
+				if !is_undefined(delimiterOpt) {
+					step.delimiter = delimiterOpt
+				}
 			}
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "6.3.3",
+  "version": "6.5.0",
   "description": "Tengo SDK library",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -18,7 +18,7 @@
   "dependencies": {
     "@milaboratories/pframes-rs-wasip2": "1.1.44",
     "@milaboratories/software-pframes-conv": "2.2.9",
-    "@platforma-open/milaboratories.software-small-binaries": "^2.0.3",
+    "@platforma-open/milaboratories.software-small-binaries": "^2.1.1",
     "@platforma-open/milaboratories.software-ptexter": "1.2.2",
     "@platforma-open/milaboratories.software-ptabler": "2.1.1"
   },