@platforma-sdk/workflow-tengo 4.12.0 → 4.14.0

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-single-pcolumn" | "pframes.import-dir" | "pframes.remove-nulls" | "waiter.waiter" | "workdir.save" | "workflow.build-ctx" | "workflow.query-anchored" | "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" | "pframes.slice-data" | "check_network.create_workdir_from_storage" | "check_network.download_blob" | "check_network.upload_blob" | "check_network.upload_template" | "exec.R.create-renv" | "exec.exec-impl" | "exec.monetization_info" | "exec.python.create-venv" | "exec.load-software.impl" | "exec.exec" | "pframes.xsv-export-pframe" | "pframes.xsv-import-if-not-null" | "pframes.xsv-import-map" | "check_network.run_hello_world" | "check_network.run_hello_world_py" | "pframes.process-pcolumn-data" | "pframes.export-pframe" | "pframes.export-pframe-for-ui";
+declare type TplName = "ll.get-field" | "pframes.export-single-pcolumn" | "pframes.import-dir" | "pframes.remove-nulls" | "waiter.waiter" | "workdir.save" | "workflow.build-ctx" | "workflow.query-anchored" | "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" | "pframes.slice-data" | "check_network.create_workdir_from_storage" | "check_network.download_blob" | "check_network.upload_blob" | "check_network.upload_template" | "exec.R.create-renv" | "exec.exec-impl" | "exec.monetization_info" | "exec.python.create-venv" | "pframes.parse-to-json" | "exec.load-software.impl" | "exec.exec" | "pframes.xsv-export-pframe" | "pframes.xsv-import-if-not-null" | "pframes.xsv-import-map" | "check_network.run_hello_world" | "check_network.run_hello_world_py" | "pframes.process-pcolumn-data" | "pframes.export-pframe" | "pframes.export-pframe-for-ui";
 declare const Templates: Record<TplName, TemplateFromFile>;
 export { Templates };

package/dist/index.js

@@ -24,6 +24,7 @@ module.exports = { Templates: {
   'exec.exec-impl': { type: 'from-file', path: require.resolve('./tengo/tpl/exec.exec-impl.plj.gz') },
   'exec.monetization_info': { type: 'from-file', path: require.resolve('./tengo/tpl/exec.monetization_info.plj.gz') },
   'exec.python.create-venv': { type: 'from-file', path: require.resolve('./tengo/tpl/exec.python.create-venv.plj.gz') },
+  'pframes.parse-to-json': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.parse-to-json.plj.gz') },
   'exec.load-software.impl': { type: 'from-file', path: require.resolve('./tengo/tpl/exec.load-software.impl.plj.gz') },
   'exec.exec': { type: 'from-file', path: require.resolve('./tengo/tpl/exec.exec.plj.gz') },
   'pframes.xsv-export-pframe': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.xsv-export-pframe.plj.gz') },

package/dist/index.mjs

@@ -25,6 +25,7 @@ export const Templates = {
   'exec.exec-impl': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/exec.exec-impl.plj.gz') },
   'exec.monetization_info': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/exec.monetization_info.plj.gz') },
   'exec.python.create-venv': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/exec.python.create-venv.plj.gz') },
+  'pframes.parse-to-json': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.parse-to-json.plj.gz') },
   'exec.load-software.impl': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/exec.load-software.impl.plj.gz') },
   'exec.exec': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/exec.exec.plj.gz') },
   'pframes.xsv-export-pframe': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.xsv-export-pframe.plj.gz') },

package/dist/tengo/lib/maps.lib.tengo

@@ -213,8 +213,14 @@ deepTransform = func(...maps) {
 				} else {
 					res[k] = result
 				}
-			} else if is_map(res[k]) && is_map(v) {
-				res[k] = deepTransform(res[k], v)
+			} else if is_map(v) {
+				if is_map(res[k]) {
+					res[k] = deepTransform(res[k], v)
+				} else {
+
+
+					res[k] = deepTransform({}, v)
+				}
 			} else {
 				res[k] = v
 			}

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

@@ -20,6 +20,147 @@ pColumnData := import("@platforma-sdk/workflow-tengo:pframes.data")
 llProcessTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.process-pcolumn-data")
 
 
+BASIC_TSV_COLUMN_SPEC_SCHEMA := {
+	"valueType": "string,regex=Int|Long|Float|Double|String",
+	"name,?": "string",
+	"domain,?": { "any": "string" },
+	"annotations,?": { "any": "string" }
+}
+
+
+BASIC_TSV_COLUMN_SPEC_SCHEMA_STRING := {
+	"valueType": "string,regex=String",
+	"name,?": "string",
+	"domain,?": { "any": "string" },
+	"annotations,?": { "any": "string" }
+}
+
+
+BASIC_COLUMN_INFO_SCHEMA := {
+	"__options__,closed": "",
+	"column": "string",
+	"id,?": "string",
+	"type": "string,regex=Int|Long|Float|Double|String"
+}
+
+
+TSV_CONTENT_SETTINGS_SCHEMA := {
+	"__options__,closed": "",
+	"axes": [{
+		"__options__,closed": "",
+		"column": "string",
+		"spec": {
+			"__options__,closed": "",
+			"type": "string,regex=Int|Long|Float|Double|String",
+			"name,?": "string",
+			"domain,?": { "any": "string" },
+			"annotations,?": { "any": "string" }
+		}
+	}],
+	"columns": [["or",
+		{
+			"__options__,closed": "",
+			"kind": "string,regex=column",
+			"column": "string",
+			"id,?": "string",
+			"spec": BASIC_TSV_COLUMN_SPEC_SCHEMA
+		},
+		{
+			"__options__,closed": "",
+			"kind": "string,regex=line",
+			"id": "string",
+			"spec": BASIC_TSV_COLUMN_SPEC_SCHEMA_STRING
+		},
+		{
+			"__options__,closed": "",
+			"kind": "string,regex=json-line",
+			"id": "string",
+			"spec": BASIC_TSV_COLUMN_SPEC_SCHEMA_STRING,
+			"columns": [BASIC_COLUMN_INFO_SCHEMA]
+		},
+		{
+			"__options__,closed": "",
+			"column": "string",
+			"id,?": "string",
+			"spec": BASIC_TSV_COLUMN_SPEC_SCHEMA
+		}
+	]]
+}
+
+
+getTsvColumnId := func(column) {
+	kind := column.kind
+	if is_undefined(kind) {
+		kind = "column"
+	}
+
+	if kind == "column" {
+		columnId := column.id
+		if is_undefined(columnId) {
+			columnId = column.column
+		}
+		return columnId
+	} else if kind == "line" || kind == "json-line" {
+		return column.id
+	} else {
+		ll.panic("Unknown column kind: %s", kind)
+	}
+}
+
+
+transformTsvSettings := func(settings) {
+	return {
+		axes: slices.map(settings.axes, func(axis) {
+			return {
+				name: axis.column,
+				type: axis.spec.type
+			}
+		}),
+		columns: slices.map(settings.columns, func(column) {
+
+			kind := column.kind
+			if is_undefined(kind) {
+				kind = "column"
+			}
+
+			if kind == "column" {
+				transformedColumn := {
+					kind: "column",
+					name: column.column,
+					type: column.spec.valueType
+				}
+				if !is_undefined(column.id) {
+					transformedColumn.id = column.id
+				}
+				return transformedColumn
+			} else if kind == "line" {
+				return {
+					kind: "line",
+					id: column.id
+				}
+			} else if kind == "json-line" {
+				return {
+					kind: "json-line",
+					id: column.id,
+					columns: slices.map(column.columns, func(jsonCol) {
+						transformedCol := {
+							name: jsonCol.column,
+							type: jsonCol.type
+						}
+						if !is_undefined(jsonCol.id) {
+							transformedCol.id = jsonCol.id
+						}
+						return transformedCol
+					})
+				}
+			} else {
+				ll.panic("Unknown column kind: %s", kind)
+			}
+		})
+	}
+}
+
+
 
 
 
@@ -38,6 +179,181 @@ exportColumnData := func(data) {
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+parseToJson := func(targetContent, params) {
+	validation.assertType(params, TSV_CONTENT_SETTINGS_SCHEMA, "Invalid TsvContent settings")
+
+
+	transformedSettings := transformTsvSettings(params)
+
+
+	input := undefined
+	baseAxesSpec := []
+
+	if is_string(targetContent) || smart.isReference(targetContent) {
+
+		input = targetContent
+	} else if is_map(targetContent) && !is_undefined(targetContent.data) && !is_undefined(targetContent.spec) {
+
+		input = targetContent.data
+		validation.assertType(targetContent.spec, pSpec.P_COLUMN_SPEC_SCHEMA)
+		baseAxesSpec = slices.normalize(targetContent.spec.axesSpec)
+	} else {
+		ll.panic("targetContent must be a string, resource reference, or {data: resource, spec: PColumnSpec}")
+	}
+
+
+	axesSpec := copy(baseAxesSpec)
+	for axis in params.axes {
+		axesSpec = append(axesSpec, axis.spec)
+	}
+
+
+	outputSpecs := {}
+	for column in params.columns {
+		columnId := getTsvColumnId(column)
+		spec := maps.merge(column.spec, { axesSpec: axesSpec, kind: "PColumn" })
+		outputSpecs[columnId] = spec
+	}
+
+
+	parseToJsonTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.parse-to-json")
+	renderResult := render.create(parseToJsonTpl, {
+		params: smart.createJsonResource(transformedSettings),
+		input: input
+	})
+
+
+	self := undefined
+	self = ll.toStrict({
+
+
+
+
+
+
+		output: func(columnId) {
+			spec := outputSpecs[columnId]
+			if is_undefined(spec) {
+				ll.panic("unknown column: " + columnId)
+			}
+			return {
+				data: renderResult.resolveOutput(["result", columnId]),
+				spec: spec
+			}
+		},
+
+
+
+
+
+
+
+		outputData: func(columnId) {
+			if is_undefined(outputSpecs[columnId]) {
+				ll.panic("unknown column: " + columnId)
+			}
+			return renderResult.resolveOutput(["result", columnId])
+		},
+
+
+
+
+
+
+
+		outputSpec: func(columnId) {
+			spec := outputSpecs[columnId]
+			if is_undefined(spec) {
+				ll.panic("unknown column: " + columnId)
+			}
+			return spec
+		},
+
+
+
+
+
+
+		listOutputs: func() {
+			return maps.getKeys(outputSpecs)
+		},
+
+
+
+
+
+
+
+
+		addAllOutputsToBuilder: func(builder, ...separator) {
+			maps.forEach(outputSpecs, func(columnId, spec) {
+				builder.add(
+					columnId,
+					spec,
+					renderResult.resolveOutput(["result", columnId])
+				)
+			})
+
+			return builder
+		}
+	})
+
+	return self
+}
+
+
+
+
+
 pColumnResourceMapDataBuilder := func(keyLength) {
 	ll.panic("pframes.pColumnResourceMapDataBuilder is not supported any more; use pcolumn.resourceMapBuilder")
 }
@@ -185,6 +501,57 @@ __primitiveValueTypes := { "Int": true, "Long": true, "Float": true, "Double": t
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -249,12 +616,25 @@ 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])
 
-	trace := undefined
-	if !is_undefined(opts.traceSteps) || !is_undefined(input.spec.annotations[pSpec.A_TRACE]) {
-		trace = pSpec.makeTrace(input.spec, (opts.traceSteps ? opts.traceSteps : [])...)
-	}
+		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,
@@ -289,7 +669,7 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 		metaExtra = {}
 	}
 
-	iterationAxesSpec := input.spec.axesSpec
+	iterationAxesSpec := copy(input.spec.axesSpec)
 
 
 	if !isPotentiallyPartitioned {
@@ -376,19 +756,20 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 	for output in outputs {
 
 		outputsMap[output.name] = output
+		traceInfo := createOutputTrace(output)
 		if output.type == "Resource" || output.type == "BinaryPartitioned" || output.type == "JsonPartitioned" {
-			spec := maps.merge(output.spec, { axesSpec: iterationAxesSpec + slices.normalize(output.spec.axesSpec) })
-			if !is_undefined(trace) {
-				spec = trace.inject(spec)
+			spec := maps.merge(output.spec, { axesSpec: copy(iterationAxesSpec) + slices.normalize(output.spec.axesSpec) })
+			if !is_undefined(traceInfo.trace) {
+				spec = traceInfo.trace.inject(spec, {override: traceInfo.overrideTrace})
 			}
 			outputSpecs[output.name] = spec
-			processedOutputs = append(processedOutputs, maps.merge(output, {spec: undefined })) // removing spec field
+			processedOutputs = append(processedOutputs, maps.merge(output, {spec: undefined, traceSteps: undefined, overrideTrace: undefined }))
 		} else if output.type == "ResourceMap" {
 			processedOutputs = append(processedOutputs, maps.merge(output,
-				{ keyLength: len(output.spec.axesSpec), spec: undefined }))
-			spec := maps.merge(output.spec, { axesSpec: iterationAxesSpec + slices.normalize(output.spec.axesSpec) })
-			if !is_undefined(trace) {
-				spec = trace.inject(spec)
+				{ keyLength: len(output.spec.axesSpec), spec: undefined, traceSteps: undefined, overrideTrace: undefined }))
+			spec := maps.merge(output.spec, { axesSpec: copy(iterationAxesSpec) + slices.normalize(output.spec.axesSpec) })
+			if !is_undefined(traceInfo.trace) {
+				spec = traceInfo.trace.inject(spec, {override: traceInfo.overrideTrace})
 			}
 			outputSpecs[output.name] = spec
 		} else if output.type == "Xsv" {
@@ -400,17 +781,50 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 			})
 			purifiedPfconvCfg := decomposition.purifiedCfg
 			columnsSpec := decomposition.columnsSpec
-			if !is_undefined(trace) {
+			if !is_undefined(traceInfo.trace) {
 				for columnName, spec in columnsSpec {
-					columnsSpec[columnName] = trace.inject(spec)
+					columnsSpec[columnName] = traceInfo.trace.inject(spec, {override: traceInfo.overrideTrace})
 				}
 			}
 			outputSpecs[output.name] = columnsSpec
 			processedOutputs = append(processedOutputs, maps.merge(output,
 				{
 					settings: purifiedPfconvCfg,
-					flattenWithDelimiter: "/"
+					flattenWithDelimiter: "/",
+					traceSteps: undefined,
+					overrideTrace: undefined
 				}))
+		} else if output.type == "TsvContent" {
+			validation.assertType(output.settings, TSV_CONTENT_SETTINGS_SCHEMA, "Invalid TsvContent settings")
+
+
+			transformedSettings := transformTsvSettings(output.settings)
+
+
+			columnsSpec := {}
+			axesSpec := copy(iterationAxesSpec)
+			for axis in output.settings.axes {
+				axesSpec = append(axesSpec, axis.spec)
+			}
+
+			for column in output.settings.columns {
+				columnId := getTsvColumnId(column)
+
+
+				spec := maps.merge(column.spec, { axesSpec: axesSpec, kind: "PColumn" })
+				if !is_undefined(traceInfo.trace) {
+					spec = traceInfo.trace.inject(spec, {override: traceInfo.overrideTrace})
+				}
+				columnsSpec[columnId] = spec
+			}
+
+			outputSpecs[output.name] = columnsSpec
+			processedOutputs = append(processedOutputs, maps.merge(output, {
+				settings: transformedSettings,
+				flattenWithDelimiter: "/",
+				traceSteps: undefined,
+				overrideTrace: undefined
+			}))
 		} else {
 			ll.panic("unknown output type: " + output.type)
 		}
@@ -455,9 +869,9 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 			}
 
 			spec := outputSpecs[name]
-			if output.type == "Xsv" {
+			if output.type == "Xsv" || output.type == "TsvContent" {
 				if len(column) != 1 {
-					ll.panic("column name must be provided for Xsv output")
+					ll.panic("column name must be provided for " + output.type + " output")
 				}
 				columnName := column[0]
 				spec = spec[columnName]
@@ -467,7 +881,7 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 				return spec
 			} else {
 				if len(column) > 0 {
-					ll.panic("column name should not be provided for non-Xsv output")
+					ll.panic("column name should not be provided for non-Xsv/TsvContent output")
 				}
 				return spec
 			}
@@ -490,14 +904,14 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 				ll.panic("unknown output: " + name)
 			}
 
-			if output.type == "Xsv" {
+			if output.type == "Xsv" || output.type == "TsvContent" {
 				if len(column) != 1 {
-					ll.panic("column name must be provided for Xsv output")
+					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 output")
+					ll.panic("column name should not be provided for non-Xsv/TsvContent output")
 				}
 				return renderResult.output(name)
 			}
@@ -520,9 +934,9 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 				ll.panic("unknown output: " + name)
 			}
 
-			if output.type == "Xsv" {
+			if output.type == "Xsv" || output.type == "TsvContent" {
 				if len(column) != 1 {
-					ll.panic("column name must be provided for Xsv output")
+					ll.panic("column name must be provided for " + output.type + " output")
 				}
 				columnName := column[0]
 				spec := outputSpecs[name][columnName]
@@ -535,7 +949,7 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 				}
 			} else {
 				if len(column) > 0 {
-					ll.panic("column name should not be provided for non-Xsv output")
+					ll.panic("column name should not be provided for non-Xsv/TsvContent output")
 				}
 				return {
 					data: renderResult.output(name),
@@ -556,8 +970,8 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 				ll.panic("unknown output: " + name)
 			}
 
-			if output.type != "Xsv" {
-				ll.panic("outputFrame can only be used with Xsv outputs")
+			if output.type != "Xsv" && output.type != "TsvContent" {
+				ll.panic("outputFrame can only be used with Xsv or TsvContent outputs")
 			}
 
 			builder := builder.pFrameBuilder()
@@ -581,7 +995,7 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 			}
 
 			maps.forEach(outputsMap, func(name, output) {
-				if output.type == "Xsv" {
+				if output.type == "Xsv" || output.type == "TsvContent" {
 
 					for columnName, spec in outputSpecs[name] {
 						builder.add(
@@ -649,8 +1063,8 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 			if is_undefined(output) {
 				ll.panic("unknown output: " + name)
 			}
-			if output.type != "Xsv" {
-				ll.panic("output is not Xsv: " + name)
+			if output.type != "Xsv" && output.type != "TsvContent" {
+				ll.panic("output is not Xsv or TsvContent: " + name)
 			}
 
 			return maps.getKeys(outputSpecs[name])
@@ -690,5 +1104,6 @@ export ll.toStrict({
 	exportColumnData: exportColumnData,
 	pColumnResourceMapDataBuilder: pColumnResourceMapDataBuilder,
 	tsvFileBuilder: func() { return xsvBuilder.xsvFileBuilder("tsv") },
-	csvFileBuilder: func() { return xsvBuilder.xsvFileBuilder("csv") }
+	csvFileBuilder: func() { return xsvBuilder.xsvFileBuilder("csv") },
+	parseToJson: parseToJson
 })

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

@@ -258,10 +258,44 @@ makeTrace := func(input, ...steps) {
 	return ll.toStrict({
 		value: currentTrace,
 		valueStr: currentTraceStr,
-		
-		inject: func(spec) {
+
+
+
+
+
+
+
+
+
+
+
+
+		inject: func(spec, ...opts) {
 			validation.assertType(spec, P_COLUMN_SPEC_SCHEMA)
-			return maps.deepMerge(spec, {annotations: {"pl7.app/trace": currentTraceStr}})
+
+
+			options := {}
+			if len(opts) > 0 {
+				if len(opts) == 1 && is_map(opts[0]) {
+					options = opts[0]
+				} else {
+					ll.panic("inject: optional parameters must be a single map argument, got: %v", opts)
+				}
+			}
+
+
+			override := options.override
+			if is_undefined(override) {
+				override = true
+			}
+
+			return maps.deepTransform(spec, {annotations: {"pl7.app/trace": func(oldValue) {
+
+				if override || is_undefined(oldValue) {
+					return currentTraceStr
+				}
+				return oldValue
+			}}})
 		}
 	})
 }

package/dist/tengo/lib/slices.lib.tengo

@@ -310,7 +310,7 @@ normalize := func(s) {
 	if is_undefined(s) {
 		return []
 	}
-	return s
+	return copy(s)
 }
 
 export ll.toStrict({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "4.12.0",
+  "version": "4.14.0",
   "description": "Tengo SDK library",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -21,7 +21,7 @@
     "@platforma-open/milaboratories.software-ptabler": "1.8.0"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "^2.1.12"
+    "@platforma-sdk/tengo-builder": "^2.1.13"
   },
   "scripts": {
     "type-check": "pl-tengo check",