@platforma-sdk/workflow-tengo 6.0.0 → 6.2.0

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

@@ -5,6 +5,7 @@ json := import("json")
 ll := import("@platforma-sdk/workflow-tengo:ll")
 smart := import("@platforma-sdk/workflow-tengo:smart")
 swinfo := import("@platforma-sdk/workflow-tengo:assets.swinfo")
+wasm := import("@platforma-sdk/workflow-tengo:assets.wasm")
 maps := import("@platforma-sdk/workflow-tengo:maps")
 
 
@@ -69,5 +70,6 @@ export ll.toStrict({
 	importSoftware      : swinfo.importSoftware,
 	isSoftwareInfo      : swinfo.isSoftwareInfo,
 	importAsset         : importAsset,
-	isAssetInfo         : isAssetInfo
+	isAssetInfo         : isAssetInfo,
+	importWasm          : wasm.importWasm
 })

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

@@ -0,0 +1,113 @@
+
+
+
+
+plapi := import("plapi")
+ll := import("@platforma-sdk/workflow-tengo:ll")
+maps := import("@platforma-sdk/workflow-tengo:maps")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+importWasm := func(wasmName, ...rest) {
+	ll.assert(
+		len(rest) <= 1,
+		"assets.importWasm: too many arguments (want 1 or 2, got %d)",
+		1 + len(rest)
+	)
+	if len(rest) == 0 {
+		return plapi.loadWasm(wasmName)
+	}
+	opts := rest[0]
+	ll.assert(ll.isMap(opts), "assets.importWasm: opts must be a map, got %v", opts)
+
+
+
+	for k, _ in opts {
+		ll.assert(
+			k == "memoryLimit",
+			"assets.importWasm: unknown opts key %q (recognised: \"memoryLimit\")",
+			k
+		)
+	}
+	if !maps.containsKey(opts, "memoryLimit") {
+		return plapi.loadWasm(wasmName)
+	}
+	limit := opts.memoryLimit
+	ll.assert(
+		is_int(limit) || is_string(limit),
+		"assets.importWasm: opts.memoryLimit must be int (bytes) or string (e.g. \"50MiB\"), got %v",
+		limit
+	)
+	return plapi.loadWasm(wasmName, limit)
+}
+
+export ll.toStrict({
+	importWasm: importWasm
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/workflow-tengo",
-  "version": "6.0.0",
+  "version": "6.2.0",
   "description": "Tengo SDK library",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -16,14 +16,14 @@
     "./dist/**/*"
   ],
   "dependencies": {
-    "@milaboratories/pframes-rs-wasip2": "1.1.37",
+    "@milaboratories/pframes-rs-wasip2": "1.1.38",
     "@milaboratories/software-pframes-conv": "2.2.9",
     "@platforma-open/milaboratories.software-small-binaries": "^2.0.3",
-    "@platforma-open/milaboratories.software-ptabler": "2.0.0",
-    "@platforma-open/milaboratories.software-ptexter": "1.2.2"
+    "@platforma-open/milaboratories.software-ptexter": "1.2.2",
+    "@platforma-open/milaboratories.software-ptabler": "2.0.0"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "3.0.5"
+    "@platforma-sdk/tengo-builder": "4.0.2"
   },
   "scripts": {
     "type-check": "pl-tengo check",

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

@@ -1,223 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-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
-})