@platforma-sdk/workflow-tengo 4.11.0 → 4.13.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,29 @@ pColumnData := import("@platforma-sdk/workflow-tengo:pframes.data")
 llProcessTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.process-pcolumn-data")
 
 
+TSV_CONTENT_SETTINGS_SCHEMA := {
+	"axes": [{
+		"column": "string",
+		"spec": {
+			"type": "string,regex=Int|Long|Float|Double|String",
+			"name,?": "string",
+			"domain,?": { "any": "string" },
+			"annotations,?": { "any": "string" }
+		}
+	}],
+	"columns": [{
+		"column": "string",
+		"id,?": "string",
+		"spec": {
+			"valueType": "string,regex=Int|Long|Float|Double|String",
+			"name,?": "string",
+			"domain,?": { "any": "string" },
+			"annotations,?": { "any": "string" }
+		}
+	}]
+}
+
+
 
 
 
@@ -185,6 +208,36 @@ __primitiveValueTypes := { "Int": true, "Long": true, "Float": true, "Double": t
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -249,12 +302,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 +355,7 @@ processColumn := func(input, bodyTpl, outputs, ...opts) {
 		metaExtra = {}
 	}
 
-	iterationAxesSpec := input.spec.axesSpec
+	iterationAxesSpec := copy(input.spec.axesSpec)
 
 
 	if !isPotentiallyPartitioned {
@@ -376,19 +442,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 +467,68 @@ 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 := {
+				axes: slices.map(output.settings.axes, func(axis) {
+					return {
+						name: axis.column,
+						type: axis.spec.type
+					}
+				}),
+				columns: slices.map(output.settings.columns, func(column) {
+					transformedColumn := {
+						name: column.column,
+						type: column.spec.valueType
+					}
+					if !is_undefined(column.id) {
+						transformedColumn.id = column.id
+					}
+					return transformedColumn
+				})
+			}
+
+
+			columnsSpec := {}
+			axesSpec := copy(iterationAxesSpec)
+			for axis in output.settings.axes {
+				axesSpec = append(axesSpec, axis.spec)
+			}
+
+			for column in output.settings.columns {
+				columnId := column.id
+				if is_undefined(columnId) {
+					columnId = column.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 +573,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 +585,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 +608,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 +638,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 +653,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 +674,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 +699,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 +767,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])

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/pt.expression.lib.tengo

@@ -1,6 +1,8 @@
 ll := import("@platforma-sdk/workflow-tengo:ll")
 maps := import("@platforma-sdk/workflow-tengo:maps")
 slices := import("@platforma-sdk/workflow-tengo:slices")
+validation := import("@platforma-sdk/workflow-tengo:validation")
+fmt := import("fmt")
 
 
 
@@ -16,6 +18,24 @@ when := undefined
 rank := undefined
 
 
+
+
+_validateOptions := func(options, schema, functionName) {
+	if len(options) > 1 {
+		ll.panic("%s accepts at most one options map argument.", functionName)
+	}
+	if len(options) == 0 {
+		return {}
+	}
+
+	opsMap := options[0]
+	ll.assert(is_map(opsMap), "Options argument to %s(), if provided, must be an options map.", functionName)
+
+	validation.assertType(opsMap, schema, fmt.sprintf("%s options validation error", functionName))
+	return opsMap
+}
+
+
 _isExpression := func(item) {
 	return ll.isMap(item) && ll.methodExists(item, "getExpression")
 }
@@ -266,15 +286,13 @@ _newExpression = func(expression, currentAlias) {
 
 
 		cast: func(dtype, ...options) {
+			ops := _validateOptions(options, {
+				"__options__,closed": "",
+				"strict,?": "bool"
+			}, "cast")
 			strictVal := false
-			if len(options) > 0 {
-				ll.assert(len(options) == 1, "cast accepts at most one options map argument.")
-				opsMap := options[0]
-				ll.assert(is_map(opsMap), "Second argument to cast(), if provided, must be an options map.")
-				if !is_undefined(opsMap.strict) {
-					ll.assert(is_bool(opsMap.strict), "strict in options map must be a boolean")
-					strictVal = opsMap.strict
-				}
+			if !is_undefined(ops.strict) {
+				strictVal = ops.strict
 			}
 			return _newExpression(
 				{type: "cast", value: expression, dtype: dtype, strict: strictVal},
@@ -334,14 +352,19 @@ _newExpression = func(expression, currentAlias) {
 			if len(args) > 0 {
 				arg := args[0]
 				if is_map(arg) {
-					if arg.length != undefined && arg.end != undefined {
+					ops := _validateOptions([arg], {
+						"__options__,closed": "",
+						"length,?": "any",
+						"end,?": "any"
+					}, "strSlice")
+					if ops.length != undefined && ops.end != undefined {
 						ll.panic("strSlice cannot have both 'length' and 'end' options.")
 					}
-					if !is_undefined(arg.length) {
-						expr.length = _mapToSingleExpressionStruct(arg.length, "col")
+					if !is_undefined(ops.length) {
+						expr.length = _mapToSingleExpressionStruct(ops.length, "col")
 					}
-					if !is_undefined(arg.end) {
-						expr.end = _mapToSingleExpressionStruct(arg.end, "col")
+					if !is_undefined(ops.end) {
+						expr.end = _mapToSingleExpressionStruct(ops.end, "col")
 					}
 				} else {
 					expr.length = _mapToSingleExpressionStruct(arg, "col")
@@ -361,21 +384,19 @@ _newExpression = func(expression, currentAlias) {
 
 
 		strReplace: func(pattern, replacement, ...options) {
+			ops := _validateOptions(options, {
+				"__options__,closed": "",
+				"replaceAll,?": "bool",
+				"literal,?": "bool"
+			}, "strReplace")
 			replaceAllVal := false
 			literalVal := false
 
-			if len(options) > 0 {
-				ll.assert(len(options) == 1, "strReplace accepts at most one options map argument.")
-				opsMap := options[0]
-				ll.assert(is_map(opsMap), "Third argument to strReplace(), if provided, must be an options map.")
-				if !is_undefined(opsMap.replaceAll) {
-					ll.assert(is_bool(opsMap.replaceAll), "replaceAll in options map must be a boolean")
-					replaceAllVal = opsMap.replaceAll
-				}
-				if !is_undefined(opsMap.literal) {
-					ll.assert(is_bool(opsMap.literal), "literal in options map must be a boolean")
-					literalVal = opsMap.literal
-				}
+			if !is_undefined(ops.replaceAll) {
+				replaceAllVal = ops.replaceAll
+			}
+			if !is_undefined(ops.literal) {
+				literalVal = ops.literal
 			}
 
 			return _newExpression({
@@ -413,6 +434,147 @@ _newExpression = func(expression, currentAlias) {
 
 
 
+		strContains: func(pattern, ...options) {
+			ops := _validateOptions(options, {
+				"__options__,closed": "",
+				"literal,?": "bool",
+				"strict,?": "bool"
+			}, "strContains")
+			literalVal := false
+			strictVal := true
+
+			if !is_undefined(ops.literal) {
+				literalVal = ops.literal
+			}
+			if !is_undefined(ops.strict) {
+				strictVal = ops.strict
+			}
+
+			return _newExpression({
+				type: "str_contains",
+				value: expression,
+				pattern: _mapToSingleExpressionStruct(pattern, "lit"),
+				literal: literalVal,
+				strict: strictVal
+			}, undefined)
+		},
+
+
+
+
+
+
+
+
+		strContainsAny: func(patterns, ...options) {
+			ll.assert(is_array(patterns), "patterns must be an array of strings")
+			for pattern in patterns {
+				ll.assert(is_string(pattern), "all patterns must be strings")
+			}
+
+			ops := _validateOptions(options, {
+				"__options__,closed": "",
+				"asciiCaseInsensitive,?": "bool"
+			}, "strContainsAny")
+			asciiCaseInsensitiveVal := false
+			if !is_undefined(ops.asciiCaseInsensitive) {
+				asciiCaseInsensitiveVal = ops.asciiCaseInsensitive
+			}
+
+			return _newExpression({
+				type: "str_contains_any",
+				value: expression,
+				patterns: patterns,
+				asciiCaseInsensitive: asciiCaseInsensitiveVal
+			}, undefined)
+		},
+
+
+
+
+
+
+
+
+		strCountMatches: func(pattern, ...options) {
+			ops := _validateOptions(options, {
+				"__options__,closed": "",
+				"literal,?": "bool"
+			}, "strCountMatches")
+			literalVal := false
+
+			if !is_undefined(ops.literal) {
+				literalVal = ops.literal
+			}
+
+			return _newExpression({
+				type: "str_count_matches",
+				value: expression,
+				pattern: _mapToSingleExpressionStruct(pattern, "lit"),
+				literal: literalVal
+			}, undefined)
+		},
+
+
+
+
+
+
+
+
+		strExtract: func(pattern, ...options) {
+			ops := _validateOptions(options, {
+				"__options__,closed": "",
+				"groupIndex,?": "number"
+			}, "strExtract")
+			groupIndexVal := 0
+
+			if !is_undefined(ops.groupIndex) {
+				groupIndexVal = ops.groupIndex
+			}
+
+			return _newExpression({
+				type: "str_extract",
+				value: expression,
+				pattern: _mapToSingleExpressionStruct(pattern, "lit"),
+				groupIndex: groupIndexVal
+			}, undefined)
+		},
+
+
+
+
+
+
+		strStartsWith: func(prefix) {
+			return _newExpression({
+				type: "str_starts_with",
+				value: expression,
+				prefix: _mapToSingleExpressionStruct(prefix, "lit")
+			}, undefined)
+		},
+
+
+
+
+
+
+		strEndsWith: func(suffix) {
+			return _newExpression({
+				type: "str_ends_with",
+				value: expression,
+				suffix: _mapToSingleExpressionStruct(suffix, "lit")
+			}, undefined)
+		},
+
+
+
+
+
+
+
+
+
 		strDistance: func(string2, metric, returnSimilarity) {
 			ll.assert(_isExpression(string2), "string2 must be an expression object")
 			ll.assert(is_string(metric), "metric must be a string")
@@ -561,13 +723,16 @@ _newExpression = func(expression, currentAlias) {
 			actualArgs := args
 
 			if len(args) > 0 && is_map(args[len(args)-1]) && !(_isExpression(args[len(args)-1])) {
-				ops := args[len(args)-1]
+				ops := _validateOptions([args[len(args)-1]], {
+					"__options__,closed": "",
+					"orderBy,?": "any",
+					"descending,?": "bool"
+				}, "cumsum")
 				actualArgs = args[0:len(args)-1]
-				if maps.containsKey(ops, "orderBy") {
+				if !is_undefined(ops.orderBy) {
 					additionalOrderByVal = _mapToExpressionStructList(ops.orderBy, "col")
 				}
-				if maps.containsKey(ops, "descending") {
-					ll.assert(is_bool(ops.descending), "descending in options map must be a boolean")
+				if !is_undefined(ops.descending) {
 					descendingVal = ops.descending
 				}
 			}
@@ -645,15 +810,13 @@ concatStr := func(expressions, ...options) {
 	ll.assert(is_array(expressions), "First argument to concatStr must be an array of expressions")
 	ll.assert(len(expressions) > 0, "Expression array for concatStr cannot be empty")
 
+	ops := _validateOptions(options, {
+		"__options__,closed": "",
+		"delimiter,?": "string"
+	}, "concatStr")
 	delimiterVal := "" // Default to empty string
-	if len(options) > 0 {
-		ll.assert(len(options) == 1, "concatStr accepts at most one options map argument.")
-		opsMap := options[0]
-		ll.assert(is_map(opsMap), "Second argument to concatStr(), if provided, must be an options map.")
-		if !is_undefined(opsMap.delimiter) {
-			ll.assert(is_string(opsMap.delimiter), "delimiter in options map must be a string")
-			delimiterVal = opsMap.delimiter
-		}
+	if !is_undefined(ops.delimiter) {
+		delimiterVal = ops.delimiter
 	}
 
 	return _newExpression({
@@ -800,14 +963,12 @@ rank = func(orderByExpressions, ...options) {
 	orderByVal = _mapToExpressionStructList(orderByExpressions, "col")
 	ll.assert(len(orderByVal) > 0, "rank() 'orderBy' list cannot be empty after processing arguments.")
 
-	if len(options) > 0 {
-		ll.assert(len(options) == 1, "rank() accepts at most one options map argument.")
-		opsMap := options[0]
-		ll.assert(is_map(opsMap), "Second argument to rank(), if provided, must be an options map.")
-		if maps.containsKey(opsMap, "descending") {
-			ll.assert(is_bool(opsMap.descending), "descending in options map must be a boolean")
-			descendingVal = opsMap.descending
-		}
+	ops := _validateOptions(options, {
+		"__options__,closed": "",
+		"descending,?": "bool"
+	}, "rank")
+	if !is_undefined(ops.descending) {
+		descendingVal = ops.descending
 	}
 
 	return _newWindowExpression({

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.11.0",
+  "version": "4.13.0",
   "description": "Tengo SDK library",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -18,7 +18,7 @@
   "dependencies": {
     "@milaboratories/software-pframes-conv": "2.2.2",
     "@platforma-open/milaboratories.software-small-binaries": "^1.15.21",
-    "@platforma-open/milaboratories.software-ptabler": "1.7.0"
+    "@platforma-open/milaboratories.software-ptabler": "1.8.0"
   },
   "devDependencies": {
     "@platforma-sdk/tengo-builder": "^2.1.12"