@platforma-sdk/workflow-tengo 5.24.0 → 5.26.0

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

@@ -65,6 +65,10 @@ builder := func() {
 
 	filesToWrite := {}
 
+
+
+	writableFiles := {}
+
 	dirsToCreate := {}
 
 
@@ -769,12 +773,22 @@ builder := func() {
 
 
 
+
+
+
+
+
+
+
 		addFile: func(fileName, file, ...opts) {
 			ll.assert(is_string(fileName), "exec.builder().addFile: fileName must be a string")
 			ll.assert(smart.isReference(file), "exec.builder().addFile: file must be a reference")
 
 			fileName = path.canonize(fileName)
 			filesToAdd[fileName] = file
+			if len(opts) > 0 && ll.isMap(opts[0]) && opts[0].writable == true {
+				sets.add(writableFiles, fileName)
+			}
 			monetization.addOptionalArg(mnz, fileName, opts...)
 			return self
 		},
@@ -784,6 +798,7 @@ builder := func() {
 
 
 
+
 		addFiles: func(filesMap, ...opts) {
 			ll.assert(ll.isMap(filesMap), "exec.builder().addFiles: filesMap must be map of file names to file resources")
 			maps.forEach(filesMap, func(fileName, file) {
@@ -804,6 +819,13 @@ builder := func() {
 
 
 
+
+
+
+
+
+
+
 
 
 
@@ -823,6 +845,9 @@ builder := func() {
 			fileName = path.canonize(fileName)
 
 			filesToWrite[fileName] = data
+			if len(opts) > 0 && ll.isMap(opts[0]) && opts[0].writable == true {
+				sets.add(writableFiles, fileName)
+			}
 			monetization.addOptionalArg(mnz, fileName, opts...)
 
 			return self
@@ -833,6 +858,24 @@ builder := func() {
 
 
 
+
+
+
+
+
+		writeFiles: func(filesMap, ...opts) {
+			ll.assert(ll.isMap(filesMap), "exec.builder().writeFiles: filesMap must be map of file names to contents")
+			maps.forEach(filesMap, func(fileName, data) {
+				self.writeFile(fileName, data, opts...)
+			})
+			return self
+		},
+
+
+
+
+
+
 		mkDir: func(dir) {
 			dir = path.canonize(dir)
 			dirsToCreate = sets.add(dirsToCreate, dir)
@@ -1051,6 +1094,12 @@ builder := func() {
 				assetCache: assetCache
 			}
 
+
+
+			if len(writableFiles) > 0 {
+				pureExecInputs.writableFiles = slices.fromSet(writableFiles)
+			}
+
 			if (is_int(ramRequest)) {
 				ramRequest = string(ramRequest) + "b"
 			}

package/dist/tengo/lib/pframes-rs.lib.tengo

@@ -0,0 +1,223 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+assets := import("@platforma-sdk/workflow-tengo:assets")
+json := import("json")
+
+WASM_NAME := "@milaboratories/pframes-rs-wasip2:main"
+
+
+
+
+
+
+
+
+_bundleTag := func() {
+	if false {
+		return assets.importWasm("@milaboratories/pframes-rs-wasip2:main")
+	}
+	return undefined
+}
+
+_runtimeUnavailable := func() {
+	return error("pframes-rs wasm runtime not yet wired (see plan/tengo-wasm-call); the wasm bytes are bundled but cannot be invoked from Tengo today")
+}
+
+
+
+
+
+_load := func(limit) {
+	return undefined
+}
+
+
+
+_resolve := func(handle, path) {
+	node := handle
+	for name in path {
+		if is_undefined(node) {
+			return undefined
+		}
+		node = node[name]
+	}
+	return node
+}
+
+
+
+
+_staticCall := func(path) {
+	return func(request) {
+		h := _load(undefined)
+		if is_undefined(h) {
+			return _runtimeUnavailable()
+		}
+		fn := _resolve(h, path)
+		if is_undefined(fn) {
+			return error("pframes-rs wasm export missing: " + string(path))
+		}
+		requestJson := ""
+		if !is_undefined(request) {
+			requestJson = json.encode(request)
+		}
+		responseJson := fn(requestJson)
+		if is_error(responseJson) {
+			return responseJson
+		}
+		return json.decode(responseJson)
+	}
+}
+
+
+
+
+
+_instanceMethod := func(hostHandle, methodName, takesArgs) {
+	return func(args) {
+		method := hostHandle[methodName]
+		if is_undefined(method) {
+			return error("pframes-rs handle method missing: " + methodName)
+		}
+		responseJson := undefined
+		if takesArgs {
+			requestJson := ""
+			if !is_undefined(args) {
+				requestJson = json.encode(args)
+			}
+			responseJson = method(requestJson)
+		} else {
+			responseJson = method()
+		}
+		if is_error(responseJson) {
+			return responseJson
+		}
+		return json.decode(responseJson)
+	}
+}
+
+
+
+_wrapFrame := func(hostFrame) {
+	if is_error(hostFrame) {
+		return hostFrame
+	}
+	return ll.toStrict({
+		listColumns:        _instanceMethod(hostFrame, "listColumns", false),
+		discoverColumns:    _instanceMethod(hostFrame, "discoverColumns", true),
+		findColumns:        _instanceMethod(hostFrame, "findColumns", true),
+		evaluateQuery:      _instanceMethod(hostFrame, "evaluateQuery", true),
+		rewriteLegacyQuery: _instanceMethod(hostFrame, "rewriteLegacyQuery", true)
+	})
+}
+
+frameFromJson := func(spec) {
+	h := _load(undefined)
+	if is_undefined(h) {
+		return _runtimeUnavailable()
+	}
+	specJson := json.encode(spec)
+	hostFrame := h.frame.fromJson(specJson)
+	return _wrapFrame(hostFrame)
+}
+
+frameNS := ll.toStrict({
+	fromJson:      frameFromJson,
+	deleteColumns: _staticCall(["frame", "deleteColumns"]),
+	buildQuery:    _staticCall(["frame", "buildQuery"])
+})
+
+
+
+_wrapTable := func(hostTable) {
+	if is_error(hostTable) {
+		return hostTable
+	}
+	return ll.toStrict({
+		findColumn: _instanceMethod(hostTable, "findColumn", true)
+	})
+}
+
+tableFromJson := func(spec) {
+	h := _load(undefined)
+	if is_undefined(h) {
+		return _runtimeUnavailable()
+	}
+	specJson := json.encode(spec)
+	hostTable := h.table.fromJson(specJson)
+	return _wrapTable(hostTable)
+}
+
+tableNS := ll.toStrict({
+	fromJson: tableFromJson
+})
+
+
+
+_wrapAxes := func(hostAxes) {
+	if is_error(hostAxes) {
+		return hostAxes
+	}
+	return ll.toStrict({
+		expand: _instanceMethod(hostAxes, "expand", false),
+		find:   _instanceMethod(hostAxes, "find", true)
+	})
+}
+
+axesFromJson := func(spec) {
+	h := _load(undefined)
+	if is_undefined(h) {
+		return _runtimeUnavailable()
+	}
+	specJson := json.encode(spec)
+	hostAxes := h.axes.fromJson(specJson)
+	return _wrapAxes(hostAxes)
+}
+
+axesNS := ll.toStrict({
+	fromJson: axesFromJson,
+	collapse: _staticCall(["axes", "collapse"])
+})
+
+export ll.toStrict({
+	frame: frameNS,
+	table: tableNS,
+	axes:  axesNS
+})

package/dist/tengo/lib/workdir.lib.tengo

@@ -55,11 +55,11 @@ createV2 := func(allocationRef) {
 
 
 
-_getFileFillRule := func(filePath, extension) {
+_getFileFillRule := func(filePath, extension, writable) {
 	return {
 		type: "file",
 		path: filePath,
-		permissions: 0o400,
+		permissions: writable ? 0o600 : 0o400,
 		pathKey: filePath,
 		blobKey: filePath,
 		copyOptional: false,
@@ -93,11 +93,11 @@ _getArchiveFillRule := func(dstDir, whatToExtract, archiveBlobKey) {
 
 
 
-_getValueFillRule := func(filePath) {
+_getValueFillRule := func(filePath, writable) {
 	return {
 		type: "value",
 		path: filePath,
-		permissions: 0o400,
+		permissions: writable ? 0o600 : 0o400,
 		pathKey: filePath,
 		valueKey: filePath
 	}
@@ -133,6 +133,10 @@ _fill := func() {
 	values := {}
 	dirs := {}
 
+
+
+	writableFiles := {}
+
 	queue := undefined
 	cpu := undefined
 	ram := undefined
@@ -248,13 +252,24 @@ _fill := func() {
 
 
 
-		addFile: func(fileName, fileResource) {
+
+
+
+
+
+
+
+
+		addFile: func(fileName, fileResource, ...opts) {
 			validation.assertType(fileName, "string")
 			validation.assertType(fileResource, validation.reference)
 
 			files[fileName] = fileResource
 			blobs[fileName] = fileResource
 			self._addDirs(fileName)
+			if len(opts) > 0 && ll.isMap(opts[0]) && opts[0].writable == true {
+				sets.add(writableFiles, fileName)
+			}
 
 			return self
 		},
@@ -264,8 +279,11 @@ _fill := func() {
 
 
 
-		addFiles: func(fileMap) {
-			maps.forEach(fileMap, self.addFile)
+
+		addFiles: func(fileMap, ...opts) {
+			maps.forEach(fileMap, func(fileName, fileResource) {
+				self.addFile(fileName, fileResource, opts...)
+			})
 			return self
 		},
 
@@ -275,10 +293,17 @@ _fill := func() {
 
 
 
-		writeFile: func(fileName, contentRef) {
+
+
+
+
+		writeFile: func(fileName, contentRef, ...opts) {
 			validation.assertType(fileName, "string")
 			values[fileName] = contentRef
 			self._addDirs(fileName)
+			if len(opts) > 0 && ll.isMap(opts[0]) && opts[0].writable == true {
+				sets.add(writableFiles, fileName)
+			}
 
 			return self
 		},
@@ -288,8 +313,11 @@ _fill := func() {
 
 
 
-		writeFiles: func(contentRefMap) {
-			maps.forEach(contentRefMap, self.writeFile)
+
+		writeFiles: func(contentRefMap, ...opts) {
+			maps.forEach(contentRefMap, func(fileName, contentRef) {
+				self.writeFile(fileName, contentRef, opts...)
+			})
 			return self
 		},
 
@@ -360,10 +388,10 @@ _fill := func() {
 				rules = append(rules, _getDirFillRule(dir))
 			}
 			for fileName, _ in files {
-				rules = append(rules, _getFileFillRule(fileName, path.getExtension(fileName)))
+				rules = append(rules, _getFileFillRule(fileName, path.getExtension(fileName), sets.hasElement(writableFiles, fileName)))
 			}
 			for fileName, _ in values {
-				rules = append(rules, _getValueFillRule(fileName))
+				rules = append(rules, _getValueFillRule(fileName, sets.hasElement(writableFiles, fileName)))
 			}
 
 			for blobKey, directories in zipExtractions {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "5.24.0",
+  "version": "5.26.0",
   "description": "Tengo SDK library",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -16,13 +16,14 @@
     "./dist/**/*"
   ],
   "dependencies": {
+    "@milaboratories/pframes-rs-wasip2": "1.1.35",
     "@milaboratories/software-pframes-conv": "2.2.9",
     "@platforma-open/milaboratories.software-small-binaries": "^2.0.3",
-    "@platforma-open/milaboratories.software-ptexter": "1.2.2",
-    "@platforma-open/milaboratories.software-ptabler": "1.16.1"
+    "@platforma-open/milaboratories.software-ptabler": "1.16.1",
+    "@platforma-open/milaboratories.software-ptexter": "1.2.2"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "2.5.29"
+    "@platforma-sdk/tengo-builder": "3.0.3"
   },
   "scripts": {
     "type-check": "pl-tengo check",