@platforma-sdk/workflow-tengo 1.7.6 → 1.8.1

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 declare type TemplateFromFile = { readonly type: "from-file"; readonly path: string; };
-declare type TplName = "pframes.aggregate" | "pframes.export-single-pcolumn" | "pframes.import-dir" | "pframes.map-pframe" | "workdir.save" | "workflow.build-ctx" | "exec.python.install-deps" | "pframes.export-multiple-pcolumns" | "pframes.export-pframe" | "exec.python.create-venv" | "exec.exec" | "pframes.import-xsv-map";
+declare type TplName = "pframes.aggregate" | "pframes.export-single-pcolumn" | "pframes.import-dir" | "pframes.map-pframe" | "workdir.save" | "workflow.build-ctx" | "exec.python.install-deps" | "pframes.export-multiple-pcolumns" | "pframes.export-pframe" | "exec.python.create-venv" | "exec.exec" | "pframes.xsv-export-pframe" | "pframes.xsv-import-map";
 declare const Templates: Record<TplName, TemplateFromFile>;
 export { Templates };

package/dist/index.js

@@ -10,5 +10,6 @@ module.exports = { Templates: {
   'pframes.export-pframe': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.export-pframe.plj.gz') },
   'exec.python.create-venv': { type: 'from-file', path: require.resolve('./tengo/tpl/exec.python.create-venv.plj.gz') },
   'exec.exec': { type: 'from-file', path: require.resolve('./tengo/tpl/exec.exec.plj.gz') },
-  'pframes.import-xsv-map': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.import-xsv-map.plj.gz') }
+  'pframes.xsv-export-pframe': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.xsv-export-pframe.plj.gz') },
+  'pframes.xsv-import-map': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.xsv-import-map.plj.gz') }
 }};

package/dist/index.mjs

@@ -11,5 +11,6 @@ export const Templates = {
   'pframes.export-pframe': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.export-pframe.plj.gz') },
   'exec.python.create-venv': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/exec.python.create-venv.plj.gz') },
   'exec.exec': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/exec.exec.plj.gz') },
-  'pframes.import-xsv-map': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.import-xsv-map.plj.gz') }
+  'pframes.xsv-export-pframe': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.xsv-export-pframe.plj.gz') },
+  'pframes.xsv-import-map': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.xsv-import-map.plj.gz') }
 };

package/dist/tengo/lib/assets.lib.tengo

@@ -66,7 +66,7 @@ isSoftwareInfo := func(toCheck) {
  * @param assetName: string - full name of asset entrypoint, including namespace (NPM package name).
  *                            Local software entrypoints (within the same package) can omit namespace
  *                            part and start the name with colon:
- *                              - "@company/package:some-oftware"
+ *                              - "@company/package:some-software"
  *                              - ":my-local-software"
  */
 importAsset := func(assetName) {

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

@@ -31,18 +31,18 @@ RTYPE_BLOB_DOWNLOAD := { Name: "BlobDownload", Version: "2" }
  *  'handle' - reference to resource with 'progress' API.
  */
 createBlobImportExternal := func(settings) {
-    validation.assertJsonSchema(settings, {
-        "dataURL": "string",
-        "dataHeaders,omitempty": [["string"]],
-        "dataVersion,omitempty": "string"
-    })
+	validation.assertJsonSchema(settings, {
+		"dataURL": "string",
+		"dataHeaders,omitempty": [["string"]],
+		"dataVersion,omitempty": "string"
+	})
 
-    importer := smart.structBuilder(RTYPE_BLOB_IMPORT_EXTERNAL, json.encode(settings)).lockAndBuild()
+	importer := smart.structBuilder(RTYPE_BLOB_IMPORT_EXTERNAL, json.encode(settings)).lockAndBuild()
 
-    return ll.toStrict({
-        file: importer.getField("blob"),
-        handle: importer.getField("handle")
-    })
+	return ll.toStrict({
+		file: importer.getField("blob"),
+		handle: importer.getField("handle")
+	})
 }
 
 /**
@@ -52,19 +52,19 @@ createBlobImportExternal := func(settings) {
  *  'handle' - reference to resource with 'progress' API.
  */
 createBlobImportInternal := func(settings) {
-    validation.assertJsonSchema(settings, {
-        "path": "string",
-        "storageId": "string",
-        "maxSpeedBytes,omitempty": "number",
-        "dataVersion,omitempty": "string"
-    })
+	validation.assertJsonSchema(settings, {
+		"path": "string",
+		"storageId": "string",
+		"maxSpeedBytes,omitempty": "number",
+		"dataVersion,omitempty": "string"
+	})
 
-    importer := smart.structBuilder(RTYPE_BLOB_IMPORT_INTERNAL, json.encode(settings)).lockAndBuild()
+	importer := smart.structBuilder(RTYPE_BLOB_IMPORT_INTERNAL, json.encode(settings)).lockAndBuild()
 
-    return ll.toStrict({
-        file: importer.getField("blob"),
-        handle: importer.getField("handle")
-    })
+	return ll.toStrict({
+		file: importer.getField("blob"),
+		handle: importer.getField("handle")
+	})
 }
 
 /**
@@ -74,28 +74,28 @@ createBlobImportInternal := func(settings) {
  *  'handle' - reference to resource with 'progress' and 'upload' APIs.
  */
 createBlobUpload := func(settings) {
-    validation.assertJsonSchema(settings, {
-        "modificationTime": "string",
-        "localPath": "string",
-        "pathSignature": "string",
-        "sizeBytes": "string"
-    })
+	validation.assertJsonSchema(settings, {
+		"modificationTime": "string",
+		"localPath": "string",
+		"pathSignature": "string",
+		"sizeBytes": "string"
+	})
 
-    uploader := smart.structBuilder(RTYPE_BLOB_UPLOAD, json.encode(settings)).lockAndBuild()
+	uploader := smart.structBuilder(RTYPE_BLOB_UPLOAD, json.encode(settings)).lockAndBuild()
 
-    return ll.toStrict({
-        file: uploader.getField("blob"),
-        handle: uploader.getField("handle")
-    })
+	return ll.toStrict({
+		file: uploader.getField("blob"),
+		handle: uploader.getField("handle")
+	})
 }
 
 export ll.toStrict({
-    RTYPE_BLOB_IMPORT_EXTERNAL      : RTYPE_BLOB_IMPORT_EXTERNAL,
-    RTYPE_BLOB_IMPORT_INTERNAL      : RTYPE_BLOB_IMPORT_INTERNAL,
-    RTYPE_BLOB_UPLOAD               : RTYPE_BLOB_UPLOAD,
-    RTYPE_BLOB_DOWNLOAD             : RTYPE_BLOB_DOWNLOAD,
+	RTYPE_BLOB_IMPORT_EXTERNAL      : RTYPE_BLOB_IMPORT_EXTERNAL,
+	RTYPE_BLOB_IMPORT_INTERNAL      : RTYPE_BLOB_IMPORT_INTERNAL,
+	RTYPE_BLOB_UPLOAD               : RTYPE_BLOB_UPLOAD,
+	RTYPE_BLOB_DOWNLOAD             : RTYPE_BLOB_DOWNLOAD,
 
-    createBlobImportExternal        : createBlobImportExternal,
-    createBlobImportInternal        : createBlobImportInternal,
-    createBlobUpload                : createBlobUpload
+	createBlobImportExternal        : createBlobImportExternal,
+	createBlobImportInternal        : createBlobImportInternal,
+	createBlobUpload                : createBlobUpload
 })

package/dist/tengo/lib/ll.lib.tengo

@@ -147,7 +147,7 @@ isFieldId := func(val) {
 /**
  * Converts reference ID (resource ID or field ID) to stable string representation, suitable for use as map keys
  */
- idToString := func(referenceID) {
+idToString := func(referenceID) {
 	if isFieldId(referenceID) {
 		return fmt.sprintf("0x%X/%s", referenceID.ResourceID, referenceID.Name)
 	}
@@ -155,7 +155,7 @@ isFieldId := func(val) {
 		return fmt.sprintf("0x%X", referenceID)
 	}
 	panic("ll.idToString: <referenceID> cannot be used as resource or field ID")
- }
+}
 
 /**
  * Returns current template renderer

package/dist/tengo/lib/objects.lib.tengo

@@ -1,22 +1,22 @@
 /**
-* Utilities for working with objects
-*/
+ * Utilities for working with objects
+ */
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 
 /**
-* Deletes entries with undefined values from object
-*/
+ * Deletes entries with undefined values from object
+ */
 deleteUndefined := func(obj) {
-    for k, v in obj {
-        if is_undefined(v) {
-            delete(obj, k)
-        }
-    }
+	for k, v in obj {
+		if is_undefined(v) {
+			delete(obj, k)
+		}
+	}
 
-    return obj
+	return obj
 }
 
 export ll.toStrict({
-    deleteUndefined: deleteUndefined
-})
+	deleteUndefined: deleteUndefined
+})

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

@@ -4,7 +4,6 @@
 
 ll := import("@platforma-sdk/workflow-tengo:ll")
 oop := import("@platforma-sdk/workflow-tengo:oop")
-json := import("json")
 smart := import("@platforma-sdk/workflow-tengo:smart")
 assets := import("@platforma-sdk/workflow-tengo:assets")
 render := import("@platforma-sdk/workflow-tengo:render")
@@ -15,70 +14,52 @@ constants := import("@platforma-sdk/workflow-tengo:pframes.constants")
  * downloaded from the UI side.
  */
 exportFrame := func(pf) {
-    return render.createEphemeral(assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.export-pframe"), { pf: pf }).output("result")
+	return render.createEphemeral(assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.export-pframe"), { pf: pf }).output("result")
 }
 
 /**
  * Export single PColumn data
  */
 exportColumnData := func(data) {
-    return render.createEphemeral(assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.export-single-pcolumn"), { data: data }).output("result")
+	return render.createEphemeral(assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.export-single-pcolumn"), { data: data }).output("result")
 }
 
-/** 
+/**
  * Creates a builder for p-frame resource.
  */
 pFrameBuilder := func() {
-    r := smart.structBuilder(constants.RTYPE_P_FRAME)
+	r := smart.structBuilder(constants.RTYPE_P_FRAME)
 
-    self := undefined
-    self = ll.toStrict(oop.inherit(r, {
+	self := undefined
+	self = ll.toStrict(oop.inherit(r, {
 
-        add: func(column, spec, data) {
-            if (!is_undefined(spec)) {
-                r.createInputField(column + ".spec").setRefOrJson(spec)
-            }
-            if (!is_undefined(data)) {
-		        r.createInputField(column + ".data").setRefOrJson(data)
-            }
-            return self
-        },
+		add: func(column, spec, data) {
+			if (!is_undefined(spec)) {
+				r.createInputField(column + ".spec").setRefOrJson(spec)
+			}
+			if (!is_undefined(data)) {
+				r.createInputField(column + ".data").setRefOrJson(data)
+			}
+			return self
+		},
 
-        build: func() {
-            return r.lockAndBuild()
-        }
-    }))
-    return self
+		build: func() {
+			return r.lockAndBuild()
+		}
+	}))
+	return self
 }
 
-/** 
+/**
  * Creates a builder for a resource map p-column's data.
  */
 pColumnResourceMapDataBuilder := func(keyLength) {
-    r := smart.structBuilder(
-		constants.RTYPE_P_COLUMN_DATA_RESOURCE_MAP,
-		json.encode({ keyLength: 1 })
-	)
-
-    self := undefined
-    self = ll.toStrict(oop.inherit(r, {
-
-        add: func(key, data) {
-            ll.assert(is_array(key), "key must be an array, got ", key)
-            r.createInputField(json.encode(key)).setRefOrJson(data)
-            return self
-        },
-
-        build: func() {
-            return r.lockAndBuild()
-        }
-    }))
-    return self
+	ll.panic("pframes.pColumnResourceMapDataBuilder is not supported any more; use pcolumn.resourceMapBuilder")
 }
 
 export ll.toStrict({
-    exportFrame: exportFrame,
-    pFrameBuilder: pFrameBuilder,
-    exportColumnData: exportColumnData,
-    pColumnResourceMapDataBuilder: pColumnResourceMapDataBuilder
+	exportFrame: exportFrame,
+	pFrameBuilder: pFrameBuilder,
+	exportColumnData: exportColumnData,
+	pColumnResourceMapDataBuilder: pColumnResourceMapDataBuilder
 })

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

@@ -0,0 +1,71 @@
+/**
+ * Working with a single p-column
+ */
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+oop := import("@platforma-sdk/workflow-tengo:oop")
+json := import("json")
+smart := import("@platforma-sdk/workflow-tengo:smart")
+assets := import("@platforma-sdk/workflow-tengo:assets")
+render := import("@platforma-sdk/workflow-tengo:render")
+constants := import("@platforma-sdk/workflow-tengo:pframes.constants")
+
+/**
+ * Returns true if given resource is a p-column resource map data
+ */
+isResourceMap := func(r) {
+	return smart.isResource(r) && r.info().Type.Name == constants.RTYPE_P_COLUMN_DATA_RESOURCE_MAP.Name
+}
+
+/**
+ * Creates a builder for a resource map p-column's data.
+ *
+ * @param keyLength: int - key length
+ */
+resourceMapBuilder := func(keyLength) {
+	r := smart.structBuilder(
+		constants.RTYPE_P_COLUMN_DATA_RESOURCE_MAP,
+		json.encode({ keyLength: keyLength })
+	)
+
+	self := undefined
+	self = ll.toStrict(oop.inherit(r, {
+
+		add: func(key, data) {
+			ll.assert(is_array(key), "key must be an array, got ", key)
+			ll.assert(len(key) == keyLength, "array length does not match specified keyLength", key, keyLength)
+			r.createInputField(json.encode(key)).setRefOrJson(data)
+			return self
+		},
+
+		build: func() {
+			return r.lockAndBuild()
+		}
+	}))
+	return self
+}
+
+/**
+ * Convert map object to a p-column resource map.
+ *
+ * @param map - tengo map
+ * @param keyLength: int - length of the partitioned key
+ * @param keyParser: func - function to parse string map keys and return array of p-column keys
+ */
+fromMap := func(map, keyLength, keyParser) {
+	b := resourceMapBuilder(keyLength)
+
+	for k, v in map {
+		arr := keyParser(k)
+		ll.assert(is_array(arr), "keyParser should return array")
+		b.add(arr, v)
+	}
+
+	return b.build()
+}
+
+export ll.toStrict({
+	fromMap: fromMap,
+	isResourceMap: isResourceMap,
+	resourceMapBuilder: resourceMapBuilder
+})

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

@@ -35,7 +35,7 @@ _SPEC_AXES_SCHEMA := {
 	// Should the N/A values (or empty rows) be allowed;
 	// default: false
 	`allowNA,omitempty`: `bool`,
-	// Should the parsing error be interpreted as N/A
+	// Should the parsing error be interpreted as N/A;
 	// default: false
 	`parseErrorToNA,omitempty`: `bool`,
 	// Specification of the axis
@@ -69,7 +69,7 @@ _SPEC_COLUMN_SCHEMA := {
 	// Should the N/A values (or empty rows) be allowed;
 	// default: true
 	`allowNA,omitempty`: `bool`,
-	// Should the parsing error be interpreted as N/A
+	// Should the parsing error be interpreted as N/A;
 	// default: false
 	`parseErrorToNA,omitempty`: `bool`,
 	// Specification of the column
@@ -106,7 +106,7 @@ _SPEC_INDEX_SCHEMA := {
 	`parentAxes,omitempty`: [`number`]
 }
 
-PFCONV_CFG_SCHEMA := {
+PFCONV_IMPORT_CFG_SCHEMA := {
 	// Columns would be stored using specified format;
 	// default: Binary
 	`storageFormat,omitempty` : `string,regex=Binary|Json`,
@@ -121,16 +121,16 @@ PFCONV_CFG_SCHEMA := {
 	// Axis of type Int with XSV row numbers (would be the last one);
 	// default: do not create additional axis with indexes
 	`index,omitempty`: _SPEC_INDEX_SCHEMA,
-	// String representing NA values of types Int, Long, Float, Double
+	// String representing NA values of types Int, Long, Float, Double;
 	// default: NaN
 	`naStr,omitempty`: `string`,
-	// String representing NA values of types String, Bytes
+	// String representing NA values of types String, Bytes;
 	// default: null
 	`nullStr,omitempty`: `string`,
 	// Single ASCII character to be used as separator;
 	// default: ',' for .csv, '\t' for .tsv
 	`separator,omitempty`: `string`,
-	// Interpret empty string as NA value
+	// Interpret empty string as NA value;
 	// default: true
 	`emptyStrAsNA,omitempty`: `bool`,
 	// Prefix all column names with given string;
@@ -145,6 +145,42 @@ PFCONV_CFG_SCHEMA := {
 	`allowArtificialColumns,omitempty`: `bool`
 }
 
+_COLUMN_FILTER_SCHEMA := {
+	// Match any of the types listed here;
+	// default: type is ignored during matching
+	`type,omitempty`: `string,regex=Int|Long|Float|Double|String|Bytes`,
+	// Match any of the names listed here;
+	// default: name is ignored during matching
+	`name,omitempty`: `string`,
+	// Match requires all the listed annotations to have provided values;
+	// default: no annotation equality checks are performed during matching
+	`annotationValue,omitempty`: { any: `string` },
+	// Match requires all the listed annotations to match provided regex patterns;
+	// default: no annotation pattern matching is performed during matching
+	`annotationPattern,omitempty`: { any: `string` }
+}
+
+PFCONV_EXPORT_CFG_SCHEMA := {
+	// String representing NA values of types Int, Long, Float, Double;
+	// default: NaN
+	`naStr,omitempty`: `string`,
+	// String representing NA and missing values of types String, Bytes;
+	// default: null
+	`nullStr,omitempty`: `string`,
+	// Toggle to export or skip axes and columns of type Bytes;
+	// default: false
+	`exportBytes,omitempty`: `bool`,
+	// Single ASCII character to be used as separator;
+	// default: ',' for .csv, '\t' for .tsv
+	`separator,omitempty`: `string`,
+	// Only columns matching the selector are exported;
+	// default: all columns are exported
+	`columnSelector,omitempty`: [_COLUMN_FILTER_SCHEMA],
+	// During export, columns with equal axes specifications would be joined into single table
+	// using the join type specified;
+	// default: Full
+	`joinType,omitempty` : `string,regex=Full|Inner`
+}
 
 /**
  * Get column id from the column spec
@@ -188,7 +224,7 @@ purifySpec := func(spec) {
 	}
 	newSpec.columns = newCols
 
-	validation.assertJsonSchema(newSpec, PFCONV_CFG_SCHEMA)
+	validation.assertJsonSchema(newSpec, PFCONV_IMPORT_CFG_SCHEMA)
 
 	return newSpec
 }
@@ -217,8 +253,8 @@ purifySpec := func(spec) {
  *           columnsSpec   - map of full column specs by ids from the original cfg
  *         }
  */
-decomposePfconvCfg := func(cfg, ...ops) {
-	ll.assert(len(ops) <= 1, "too many options for decomposePfconvCfg: %v", len(ops))
+decomposePfconvImportCfg := func(cfg, ...ops) {
+	ll.assert(len(ops) <= 1, "too many options for decomposePfconvImportCfg: %v", len(ops))
 
 	axesSpec := []
 	if len(ops) == 1 && !is_undefined(ops[0].additionalAxesSpec) {
@@ -247,9 +283,10 @@ decomposePfconvCfg := func(cfg, ...ops) {
 }
 
 export ll.toStrict({
-	PFCONV_CFG_SCHEMA: PFCONV_CFG_SCHEMA,
+	PFCONV_IMPORT_CFG_SCHEMA: PFCONV_IMPORT_CFG_SCHEMA,
+	PFCONV_EXPORT_CFG_SCHEMA: PFCONV_EXPORT_CFG_SCHEMA,
 
 	xsvColumnId: xsvColumnId,
 	purifySpec: purifySpec,
-	decomposePfconvCfg: decomposePfconvCfg
+	decomposePfconvImportCfg: decomposePfconvImportCfg
 })

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

@@ -6,8 +6,10 @@ validation := import("@platforma-sdk/workflow-tengo:validation")
 constants := import("@platforma-sdk/workflow-tengo:pframes.constants")
 objects := import("@platforma-sdk/workflow-tengo:objects")
 render := import("@platforma-sdk/workflow-tengo:render")
+smart := import("@platforma-sdk/workflow-tengo:smart")
 exec := import("@platforma-sdk/workflow-tengo:exec")
 json := import("json")
+text := import("text")
 util := import("@platforma-sdk/workflow-tengo:pframes.util")
 ll := import("@platforma-sdk/workflow-tengo:ll")
 assets := import("@platforma-sdk/workflow-tengo:assets")
@@ -84,7 +86,7 @@ getColumnSpec := func(axesSpec, col) {
 importFile := func(xsvFile, xsvType, spec, ...ops) {
 	ll.assert(xsvType == "csv" || xsvType == "tsv", "expected one of [tsv, csv] types")
 
-	validation.assertJsonSchema(spec, util.PFCONV_CFG_SCHEMA)
+	validation.assertJsonSchema(spec, util.PFCONV_IMPORT_CFG_SCHEMA)
 
 	xsvFileName := "file." + xsvType
 
@@ -190,7 +192,7 @@ importFile := func(xsvFile, xsvType, spec, ...ops) {
  * Imports a map with xsv files into a p-frame. The resulting map resource contains all columns specified in the params (column identifiers as
  * provided by the spec used as map keys). Resulting p-columns may be double-partitioned.
  *
- * @param xsvFile: reference - a reference to a file
+ * @param xsvMap: reference - a reference to a p-column resource map with xsv files
  * @param xsvType: string - either csv or tsv
  * @param spec: object - xsv conversion specification
  * @param ops: object - additional options
@@ -217,17 +219,17 @@ importFile := func(xsvFile, xsvType, spec, ...ops) {
  */
 importFileMap := func(xsvMap, xsvType, spec, ...ops) {
 
-	importXsvMapTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.import-xsv-map")
+	importXsvMapTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.xsv-import-map")
 
 	ops := renderOps({
-	    dataOnly: false,
+		dataOnly: false,
 		splitDataAndSpec: false,
 		additionalAxesSpec: [],
 		transpose: undefined
-	  }, ops...)
+	}, ops...)
 
 	// spec without any metadata (for caching purposes)
-	decomposedSpec := util.decomposePfconvCfg(spec, { additionalAxesSpec: ops.additionalAxesSpec })
+	decomposedSpec := util.decomposePfconvImportCfg(spec, { additionalAxesSpec: ops.additionalAxesSpec })
 	pureSpec := decomposedSpec.purifiedCfg
 	columnsSpec := decomposedSpec.columnsSpec
 
@@ -262,7 +264,27 @@ importFileMap := func(xsvMap, xsvType, spec, ...ops) {
 	return result
 }
 
+/**
+ * Export p-frame into xsv file
+ *
+ * @param pf: p-frame - a collection of p-columns
+ * @param xsvType: string - "csv" or "tsv"
+ * @param params: map - export params
+ */
+exportFrame := func(pf, xsvType, params) {
+	exportPfTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:pframes.xsv-export-pframe")
+	
+	r := render.create(exportPfTpl, {
+		pf: pf,
+		xsvType: xsvType,
+		params: params
+	})
+
+	return r.output("result")
+}
+
 export ll.toStrict({
 	importFile: importFile,
-	importFileMap: importFileMap
+	importFileMap: importFileMap,
+	exportFrame: exportFrame
 })

package/dist/tengo/lib/render.lib.tengo

@@ -58,11 +58,11 @@ createUniversal := func(tpl, isEph, inputs) {
 		 * Returns an output field with a given name
 		 */
 		output: func(name, ...cache) {
-			ll.assert(len(cache) == 0 || is_int(cache[0]), "cache should be a number (milliseconds)")
+			ll.assert(len(cache) == 0 || is_int(cache[0]), "cache should be a number (use 'times' tengo library), got: %v", cache)
 			out := renderer.getFutureOutputField(tplutil.TEMPLATE_OUTPUT_PREFIX + name)
 			if len(cache) > 0 && cache[0] > 0 {
 				cache = cache[0]
-				tx.cacheSetToField(out.id, cache * times.millisecond)
+				tx.cacheSetToField(out.id, cache)
 			}
 
 			return out

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

@@ -421,7 +421,7 @@ tpl := func() {
 					outputsWithValues = sets.add(outputsWithValues, _delegatedOutputs...)
 
 					ll.assert(sets.fromSlice(self.definedOutputs) == outputsWithValues,
-						"tpl.body() callback must return the same list of outputs as were given to 'defineOutputs()'. Want %s, got %s", 
+						"tpl.body() callback must return the same list of outputs as were given to 'defineOutputs()'. Want %s, got %s",
 						self.definedOutputs, sets.toSlice(outputsWithValues))
 
 					// set result to self outputs

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

@@ -4,5 +4,5 @@ ll := import("@platforma-sdk/workflow-tengo:ll")
 NO_PREFIX_EXPORT := "_"
 
 export ll.toStrict({
-    NO_PREFIX_EXPORT: NO_PREFIX_EXPORT
-})
+	NO_PREFIX_EXPORT: NO_PREFIX_EXPORT
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "1.7.6",
+  "version": "1.8.1",
   "description": "Tengo SDK library",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",