@platforma-sdk/workflow-tengo 2.8.8 → 2.9.0

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

@@ -4,6 +4,8 @@ plapi := import("plapi")
 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")
+maps := import("@platforma-sdk/workflow-tengo:maps")
 
 
 
@@ -29,46 +31,6 @@ return smart.resource(plapi.getTemplateId(tplName))
 
 
 
-
-importSoftware := func(swName) {
-sw := plapi.getSoftwareInfo(swName)
-return ll.toStrict({
-_type: "softwareDescriptor",
-_id: sw.id,
-
-resource: smart.resource(sw.id),
-name: sw.name,
-version: sw.version,
-blobRef: sw.blobRef,
-descriptor: ll.toStrict(json.decode(sw.descriptor)) // raw sw.json data with software entrypoint descriptor
-})
-}
-
-
-
-
-
-
-
-
-isSoftwareInfo := func(toCheck) {
-if !ll.isMap(toCheck) {
-return false
-}
-
-return (ll.fromStrict(toCheck)._type) == "softwareDescriptor"
-}
-
-
-
-
-
-
-
-
-
-
-
 importAsset := func(assetName) {
 asset := plapi.getSoftwareInfo(assetName)
 return ll.toStrict({
@@ -95,13 +57,17 @@ if !ll.isMap(toCheck) {
 return false
 }
 
-return (ll.fromStrict(toCheck)._type) == "assetDescriptor"
+if !maps.containsKey(toCheck, "_type") {
+return false
+}
+
+return toCheck._type == "assetDescriptor"
 }
 
 export ll.toStrict({
-importTemplate: importTemplate,
-importSoftware: importSoftware,
-isSoftwareInfo: isSoftwareInfo,
-importAsset:    importAsset,
-isAssetInfo:    isAssetInfo
+importTemplate      : importTemplate,
+importSoftware      : swinfo.importSoftware,
+isSoftwareInfo      : swinfo.isSoftwareInfo,
+importAsset         : importAsset,
+isAssetInfo         : isAssetInfo
 })

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

@@ -0,0 +1,65 @@
+
+
+
+
+plapi := import("plapi")
+ll := import("@platforma-sdk/workflow-tengo:ll")
+maps := import("@platforma-sdk/workflow-tengo:maps")
+smart := import("@platforma-sdk/workflow-tengo:smart")
+json := import("json")
+
+
+
+
+newSoftwareInfo := func(sw) {
+return ll.toStrict({
+_type: "softwareDescriptor",
+_id: sw.id,
+
+resource: smart.resource(sw.id),
+name: sw.name,
+version: sw.version,
+blobRef: sw.blobRef,
+descriptor: ll.toStrict(json.decode(sw.descriptor)) // raw sw.json data with software entrypoint descriptor
+})
+}
+
+
+
+
+
+
+
+
+
+
+
+
+importSoftware := func(swName) {
+return newSoftwareInfo(plapi.getSoftwareInfo(swName))
+}
+
+
+
+
+
+
+
+
+isSoftwareInfo := func(toCheck) {
+if !ll.isMap(toCheck) {
+return false
+}
+
+if !maps.containsKey(toCheck, "_type") {
+return false
+}
+
+return toCheck._type == "softwareDescriptor"
+}
+
+export ll.toStrict({
+newSoftwareInfo: newSoftwareInfo,
+importSoftware: importSoftware,
+isSoftwareInfo: isSoftwareInfo
+})

package/dist/tengo/lib/exec.R.internal.lib.tengo

@@ -1,8 +1,9 @@
 ll := import("@platforma-sdk/workflow-tengo:ll")
 validation := import("@platforma-sdk/workflow-tengo:validation")
 runcmd := import("@platforma-sdk/workflow-tengo:exec.runcmd")
-pkg := import("@platforma-sdk/workflow-tengo:exec.package")
 path := import("@platforma-sdk/workflow-tengo:path")
+desc := import("@platforma-sdk/workflow-tengo:exec.descriptor")
+constants := import("@platforma-sdk/workflow-tengo:exec.constants")
 
 rVenvInputSchema := {
 operationMode: "string",
@@ -10,18 +11,21 @@ toolset: "string",
 dependencies: {"any": "string"},
 software: validation.reference,
 
-rDescriptor: pkg.runEnvDescriptorScheme,
+rDescriptor: desc.runEnvScheme,
 R: validation.reference
 }
 
 runRBuilder := func(wd, rPackage, rDescriptor) {
+t := desc.canBackendUseExpressions() ? constants.ARG_TYPE_EXPRESSION : constants.ARG_TYPE_VAR
+rule := desc.canBackendUseExpressions() ? "R" : "{R}"
+
 return runcmd.builder(wd).
 ref("r-run-environment", rPackage).
-substitutionRule("{R}", "r-run-environment").
-addToPath(path.join("{R}", rDescriptor.binDir), true).
-envVar("R_HOME_DIR", "{R}").
-envVar("RHOME", "{R}").
-envVar("RENV_PATHS_ROOT", path.join("{R}", "renv-root"))
+substitutionRule(rule, "r-run-environment").
+addToPath(t, path.join("{R}", rDescriptor.binDir)).
+envTyped("R_HOME_DIR", t, "{R}").
+envTyped("RHOME", t, "{R}").
+envTyped("RENV_PATHS_ROOT", t, path.join("{R}", "renv-root"))
 }
 
 export ll.toStrict({

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

@@ -8,9 +8,12 @@ smart := import("@platforma-sdk/workflow-tengo:smart")
 render := import("@platforma-sdk/workflow-tengo:render")
 pkg := import("@platforma-sdk/workflow-tengo:exec.package")
 internal := import("@platforma-sdk/workflow-tengo:exec.R.internal")
+desc := import("@platforma-sdk/workflow-tengo:exec.descriptor")
 
 _OUTPUT_RUN_ENV       := "runEnv"
 
+createRenvTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:exec.R.create-renv")
+
 rVenvBuilder := func() {
 self := undefined
 
@@ -43,7 +46,7 @@ return self
 },
 
 runEnvDescriptor: func(descriptor) {
-validation.assertJsonSchema(descriptor, pkg.runEnvDescriptorScheme, "exec.R.runEnvDescriptor: <descriptor> must be run environment specification")
+validation.assertJsonSchema(descriptor, desc.runEnvScheme, "exec.R.runEnvDescriptor: <descriptor> must be run environment specification")
 ll.assert(descriptor.type == "R", "exec.R.runEnvDescriptor: not a 'R' run environment: %q", descriptor.type)
 
 rDescriptor = ll.fromStrict(descriptor)
@@ -149,7 +152,7 @@ R: rPkg
 
 validation.assertJsonSchema(rVenvInputs, internal.rVenvInputSchema, "incomplete R runenv configuration")
 
-tpl := render.create(assets.importTemplate("@platforma-sdk/workflow-tengo:exec.R.create-renv"), rVenvInputs)
+tpl := render.create(createRenvTpl, rVenvInputs)
 
 self := undefined
 self = ll.toStrict(oop.inherit(tpl, {

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

@@ -0,0 +1,11 @@
+ARG_TYPE_STRING := "string"
+ARG_TYPE_EXPRESSION := "expressionRef"
+ARG_TYPE_VAR        := "variableRef" // TODO: deprecated, remove after 15 Mar 2025
+ARG_TYPES := [ARG_TYPE_STRING, ARG_TYPE_EXPRESSION, ARG_TYPE_VAR]
+
+export {
+ARG_TYPE_STRING: ARG_TYPE_STRING,
+ARG_TYPE_EXPRESSION: ARG_TYPE_EXPRESSION,
+ARG_TYPE_VAR: ARG_TYPE_VAR,
+ARG_TYPES: ARG_TYPES
+}

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

@@ -0,0 +1,54 @@
+
+
+
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+
+runEnvScheme := {
+registry: "string",
+package: "string",
+type: "string",
+binDir: "string"
+}
+
+binaryScheme := {
+registry: "string",
+package: "string",
+cmd: ["string"],
+"runEnv,?": runEnvScheme
+}
+
+assetScheme := {
+registry: "string",
+package: "string",
+url: "string"
+}
+
+localScheme := {
+hash: "string",
+path: "string",
+cmd: ["string"],
+runEnv: runEnvScheme
+}
+
+scheme := {
+"isDev,?": "bool",
+"schemaVersion,?": "number",
+"binary,?": binaryScheme,
+"asset,?": assetScheme,
+"local,?": localScheme
+}
+
+
+canBackendUseExpressions := func() {
+return ll.apiVersion() >= 2
+}
+
+export {
+runEnvScheme: runEnvScheme,
+binaryScheme: binaryScheme,
+assetScheme: assetScheme,
+localScheme: localScheme,
+scheme: scheme,
+canBackendUseExpressions: canBackendUseExpressions
+}

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

@@ -16,29 +16,59 @@ pkg := import("@platforma-sdk/workflow-tengo:exec.package")
 runcmd := import("@platforma-sdk/workflow-tengo:exec.runcmd")
 python := import("@platforma-sdk/workflow-tengo:exec.python")
 R := import("@platforma-sdk/workflow-tengo:exec.R")
+constants := import("@platforma-sdk/workflow-tengo:exec.constants")
+desc := import("@platforma-sdk/workflow-tengo:exec.descriptor")
 validation := import("@platforma-sdk/workflow-tengo:validation")
 
 
-_ARG_VAR_PKG            := "{pkg}"  // abs path to software package
-_ARG_VAR_JAVA           := "{java}" // abs path to 'java' run environment
-_ARG_VAR_PYTHON         := "{python}" // abs path to 'python' run environment
-_ARG_VAR_R              := "{R}" // abs path to 'R' run environment runtime
-_ARG_VAR_R_VENV         := "{rVenv}" // abs path to 'R' portable virtual environment
-_ARG_VAR_MNZ            := "{monetization}" // monetization env value
+_ARG_VAR_PKG            := "pkg"  // abs path to software package
+_ARG_VAR_JAVA           := "java" // abs path to 'java' run environment
+_ARG_VAR_PYTHON         := "python" // abs path to 'python' run environment
+_ARG_VAR_R              := "R" // abs path to 'R' run environment runtime
+_ARG_VAR_R_VENV         := "rVenv" // abs path to 'R' portable virtual environment
+_ARG_VAR_MNZ            := "monetization" // monetization env value
+
+
+_expr := func(varName) {
+return "{" + varName + "}"
+}
 
 
 
 
 
 
-_newArg := func(hasVariables, value) {
+
+
+_newArg := func(isString, value) {
+if isString {
+return ll.toStrict({
+type: constants.ARG_TYPE_STRING,
+value: value
+})
+}
+if desc.canBackendUseExpressions() {
+return ll.toStrict({
+type: constants.ARG_TYPE_EXPRESSION,
+value: value
+})
+}
 return ll.toStrict({
-hasVars: hasVariables,
+type: constants.ARG_TYPE_VAR,
 value: value
 })
 }
 
 _newRefVar := func(varName, refName, reference) {
+
+if !desc.canBackendUseExpressions() {
+return ll.toStrict({
+varName: "{" + varName + "}",
+refName: refName,
+reference: reference
+})
+}
+
 return ll.toStrict({
 varName: varName,
 refName: refName,
@@ -58,7 +88,7 @@ _directCallOptions := func(runOptions) {
 return ll.toStrict({
 variables: [],
 customPaths: [],
-cmd: _newArg(false, runOptions.cmd),
+cmd: _newArg(true, runOptions.cmd),
 args: [],
 envs: {}
 })
@@ -72,7 +102,7 @@ return ll.toStrict({
 runEnvType: "java",
 
 variables: [ javaRefVar ],
-customPaths: [ _newArg(true, path.join(_ARG_VAR_JAVA, descriptor.runEnv.binDir)) ],
+customPaths: [ _newArg(false, path.join(_expr(_ARG_VAR_JAVA), descriptor.runEnv.binDir)) ],
 envs: {}
 })
 }
@@ -92,7 +122,7 @@ cacheDays(7).
 build().
 venv()
 
-venvRoot := path.join(_ARG_VAR_PYTHON, "venv")
+venvRoot := path.join(_expr(_ARG_VAR_PYTHON), "venv")
 venvRefKey := softName + "/venv"
 
 pythonRefVar := _newRefVar(_ARG_VAR_PYTHON, venvRefKey, venv)
@@ -101,9 +131,9 @@ return ll.toStrict({
 runEnvType: "python",
 
 variables: [ pythonRefVar ],
-customPaths: [ _newArg(true, path.join(venvRoot, "bin")) ],
+customPaths: [ _newArg(false, path.join(venvRoot, "bin")) ],
 envs: {
-"VIRTUAL_ENV": _newArg(true, venvRoot)
+"VIRTUAL_ENV": _newArg(false, venvRoot)
 }
 })
 }
@@ -126,7 +156,7 @@ build()
 rEnv := rRuntime.venv()
 rPackage := rRuntime.R()
 
-rBinDir := path.join(_ARG_VAR_R, descriptor.runEnv.binDir)
+rBinDir := path.join(_expr(_ARG_VAR_R), descriptor.runEnv.binDir)
 
 rRefKey := softName + "/R-runtime"
 rRefVar := _newRefVar(_ARG_VAR_R, rRefKey, rPackage)
@@ -138,15 +168,15 @@ return ll.toStrict({
 runEnvType: "R",
 
 variables: [ rRefVar, rEnvRefVar ],
-customPaths: [ _newArg(true, rBinDir) ],
+customPaths: [ _newArg(false, rBinDir) ],
 envs: {
-"R_HOME_DIR": _newArg(true, _ARG_VAR_R),
-"RHOME": _newArg(true, _ARG_VAR_R),
-"RENV_PATHS_ROOT": _newArg(true, path.join(_ARG_VAR_R, "renv-root")),
-"RENV_PATHS_RENV": _newArg(true, path.join(_ARG_VAR_R_VENV, "renv")),
-"RENV_PATHS_LOCKFILE": _newArg(true, path.join(_ARG_VAR_PKG, descriptor.dependencies.lockFile)),
-"RENV_CONFIG_AUTO_SNAPSHOT": _newArg(false, "FALSE"),
-"RENV_CONFIG_SYNCHRONIZED_CHECK": _newArg(false, "FALSE")
+"R_HOME_DIR": _newArg(false, _expr(_ARG_VAR_R)),
+"RHOME": _newArg(false, _expr(_ARG_VAR_R)),
+"RENV_PATHS_ROOT": _newArg(false, path.join(_expr(_ARG_VAR_R), "renv-root")),
+"RENV_PATHS_RENV": _newArg(false, path.join(_expr(_ARG_VAR_R_VENV), "renv")),
+"RENV_PATHS_LOCKFILE": _newArg(false, path.join(_expr(_ARG_VAR_PKG), descriptor.dependencies.lockFile)),
+"RENV_CONFIG_AUTO_SNAPSHOT": _newArg(true, "FALSE"),
+"RENV_CONFIG_SYNCHRONIZED_CHECK": _newArg(true, "FALSE")
 }
 })
 }
@@ -194,12 +224,14 @@ envs[n] = v
 }
 }
 
-ll.assert(len(descriptor.cmd) != 0, "cannot render final command for software: empty 'cmd' in software descritor")
+ll.assert(
+len(descriptor.cmd) != 0,
+"cannot render final command for software: empty 'cmd' and 'command' in software descriptor")
 
-cmd := _newArg(true, descriptor.cmd[0])
+cmd := _newArg(false, descriptor.cmd[0])
 
 for arg in splice(descriptor.cmd, 1) {
-args = append(args, _newArg(true, arg))
+args = append(args, _newArg(false, arg))
 }
 
 return ll.toStrict({
@@ -246,7 +278,7 @@ ll.assert(is_string(softwareName),
 "exec.internal.swToRunCmdOptions: software name must be a string, got %v", softwareName)
 ll.assert(is_string(softwareVersion),
 "exec.internal.swToRunCmdOptions: software version must be a string, got %v", softwareVersion)
-validation.assertJsonSchema(softwareDescriptor, pkg.descriptorScheme,
+validation.assertJsonSchema(softwareDescriptor, desc.scheme,
 "exec.internal.swToRunCmdOptions: descriptor does not fit schema")
 
 result := undefined
@@ -276,11 +308,13 @@ binaryRunOptions := func(runOptions, mnzEnvs) {
 validation.assertJsonSchema(mnzEnvs, {"any": validation.reference})
 
 runCmdOpts := undefined
+onlyStrings := false
 if (is_undefined(ll.fromStrict(runOptions).software)) {
 
 
 
 runCmdOpts = _directCallOptions(runOptions)
+onlyStrings = true
 } else {
 software := runOptions.software
 descriptor := software.descriptor
@@ -290,16 +324,16 @@ runCmdOpts = swToRunCmdOptions(software.name, software.version, descriptor)
 
 
 for arg in runOptions.args {
-runCmdOpts.args = append(runCmdOpts.args, _newArg(false, arg))
+runCmdOpts.args = append(runCmdOpts.args, _newArg(onlyStrings, arg))
 }
 for name, val in runOptions.envs {
-runCmdOpts.envs[name] = _newArg(false, val)
+runCmdOpts.envs[name] = _newArg(onlyStrings, val)
 }
 
 for name, val in mnzEnvs { // can be empty
 
 
-runCmdOpts.envs[name] = _newArg(true, _ARG_VAR_MNZ)
+runCmdOpts.envs[name] = _newArg(false, _expr(_ARG_VAR_MNZ))
 
 runCmdOpts.variables = append(runCmdOpts.variables,
 _newRefVar(_ARG_VAR_MNZ, "monetization", val))
@@ -320,16 +354,12 @@ runBuilder.substitutionRule(varInfo.varName, varInfo.refName)
 
 
 for p in opts.customPaths {
-runBuilder.addToPath(p.value, p.hasVars)
+runBuilder.addToPath(p.type, p.value)
 }
 
 
 for name, value in opts.envs {
-if value.hasVars {
-runBuilder.envVar(name, value.value)
-} else {
-runBuilder.env(name, value.value)
-}
+runBuilder.envTyped(name, value.type, value.value)
 }
 
 return runBuilder

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

@@ -15,6 +15,7 @@ enum := import("enum")
 oop := import("@platforma-sdk/workflow-tengo:oop")
 validation := import("@platforma-sdk/workflow-tengo:validation")
 constants := import("@platforma-sdk/workflow-tengo:constants")
+desc := import("@platforma-sdk/workflow-tengo:exec.descriptor")
 monetization := import("@platforma-sdk/workflow-tengo:exec.monetization")
 
 _HEAVY_QUEUE    := "heavy"
@@ -779,5 +780,6 @@ return self
 }
 
 export ll.toStrict({
-builder: builder
+builder: builder,
+canBackendUseExpressions: desc.canBackendUseExpressions
 })

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

@@ -9,6 +9,8 @@ text := import("text")
 runcmd := import("@platforma-sdk/workflow-tengo:exec.runcmd")
 workdir := import("@platforma-sdk/workflow-tengo:workdir")
 render := import("@platforma-sdk/workflow-tengo:render")
+desc := import("@platforma-sdk/workflow-tengo:exec.descriptor")
+constants := import("@platforma-sdk/workflow-tengo:exec.constants")
 
 _JWT_TOKEN_RESULT_ENV := "PLATFORMA_MNZ_JWT"
 
@@ -36,7 +38,15 @@ schema := {
 "fileParams": {"any": fileParamsSchema}
 }
 
-_assertIsReady := func(mnz) {
+
+
+_validateParams := func(params) {
+ll.assert(ll.isMap(params), "monetization.validateParams(): mnz params must be a map")
+ll.assert(is_string(params.arg), "monetization.validateParams(): 'arg' in {\"mnz\": {...}} param must be a string")
+ll.assert(is_array(params.collect) && len(params.collect) > 0, "monetization.validateParams(): 'collect' in {\"mnz\": {...}} param must be non-empty an array")
+}
+
+_validateIsReady := func(mnz) {
 validation.assertJsonSchema(mnz, schema,
 "monetization.assertIsReady(): monetization does not fit schema")
 ll.assert(len(mnz.productName) > 0,
@@ -60,7 +70,7 @@ mnz.productName = productName
 
 shouldRun := func(mnz) {
 if mnz.enabled {
-_assertIsReady(mnz)
+_validateIsReady(mnz)
 return true
 }
 
@@ -79,6 +89,8 @@ addFileParams := func(mnz, fileName, params) {
 validation.assertJsonSchema(mnz, schema,
 "monetization.addFileParams(): monetization object does not fit json schema")
 
+_validateParams(params)
+
 validation.assertJsonSchema(params, fileParamsSchema,
 "monetization.addFileParams(): file params does not fit json schema")
 
@@ -99,12 +111,15 @@ mnz.fileParams[fileName] = params
 
 
 run := func(mnz, wd, queue) {
-_assertIsReady(mnz)
+_validateIsReady(mnz)
 
 mnzSw := assets.importSoftware("@platforma-open/milaboratories.software-small-binaries:mnz-client")
 
 builder := runcmd.builder(wd)
-builder.envVar("MI_LICENSE", "{secrets.MI_LICENSE}")
+
+exprType := desc.canBackendUseExpressions() ? constants.ARG_TYPE_EXPRESSION : constants.ARG_TYPE_VAR
+
+builder.envTyped("MI_LICENSE", exprType, "{secrets.MI_LICENSE}")
 
 opts := internal.swToRunCmdOptions(mnzSw.name, mnzSw.version, mnzSw.descriptor)
 
@@ -113,10 +128,10 @@ builder.ref(varInfo.refName, varInfo.reference)
 builder.substitutionRule(varInfo.varName, varInfo.refName)
 }
 
-builder.cmdVar(opts.cmd.value)
+builder.cmdTyped(exprType, opts.cmd.value)
 for _, arg in opts.args {
 
-builder.argVar(arg)
+builder.argTyped(exprType, arg)
 }
 builder.arg("-productName").arg(mnz.productName)
 

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

@@ -9,45 +9,12 @@ oop := import("@platforma-sdk/workflow-tengo:oop")
 sets := import("@platforma-sdk/workflow-tengo:sets")
 validation := import("@platforma-sdk/workflow-tengo:validation")
 json := import("json")
-
-runEnvDescriptorScheme := {
-registry: "string",
-package: "string",
-type: "string",
-binDir: "string"
-}
-
-binaryDescriptorScheme := {
-registry: "string",
-package: "string",
-cmd: ["string"],
-"runEnv,?": runEnvDescriptorScheme
-}
-
-assetDescriptorScheme := {
-registry: "string",
-package: "string",
-url: "string"
-}
-
-localDescriptorScheme := {
-hash: "string",
-path: "string",
-cmd: ["string"],
-runEnv: runEnvDescriptorScheme
-}
-
-descriptorScheme := {
-"isDev,?": "bool",
-"binary,?": binaryDescriptorScheme,
-"asset,?": assetDescriptorScheme,
-"local,?": localDescriptorScheme
-}
+desc := import("@platforma-sdk/workflow-tengo:exec.descriptor")
 
 softwareInfoScheme := {
 "name": "string",
 "version": "string",
-"descriptor": descriptorScheme
+"descriptor": desc.scheme
 }
 
 META_KEY_DESCRIPTOR := "ctl/runner/package/descriptor"
@@ -291,11 +258,6 @@ progress: assets.progress
 
 export ll.toStrict({
 softwareInfoScheme                 : softwareInfoScheme,
-descriptorScheme                   : descriptorScheme,
-assetDescriptorScheme              : assetDescriptorScheme,
-binaryDescriptorScheme             : binaryDescriptorScheme,
-localDescriptorScheme              : localDescriptorScheme,
-runEnvDescriptorScheme             : runEnvDescriptorScheme,
 
 META_KEY_DESCRIPTOR                : META_KEY_DESCRIPTOR,
 

package/dist/tengo/lib/exec.python.internal.lib.tengo

@@ -1,13 +1,13 @@
 ll := import("@platforma-sdk/workflow-tengo:ll")
 validation := import("@platforma-sdk/workflow-tengo:validation")
-pkg := import("@platforma-sdk/workflow-tengo:exec.package")
+desc := import("@platforma-sdk/workflow-tengo:exec.descriptor")
 
 pythonVenvInputSchema := {
 toolset: "string",
 dependencies: {"any": validation.reference},
 
 
-pythonDescriptor: pkg.runEnvDescriptorScheme,
+pythonDescriptor: desc.runEnvScheme,
 python: validation.reference
 }
 

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

@@ -9,9 +9,12 @@ render := import("@platforma-sdk/workflow-tengo:render")
 pkg := import("@platforma-sdk/workflow-tengo:exec.package")
 internal := import("@platforma-sdk/workflow-tengo:exec.python.internal")
 runenv := import("@platforma-sdk/workflow-tengo:exec.runenv")
+desc := import("@platforma-sdk/workflow-tengo:exec.descriptor")
 
 _OUTPUT_RUN_ENV       := "runEnv"
 
+createVenvTpl := assets.importTemplate("@platforma-sdk/workflow-tengo:exec.python.create-venv")
+
 pythonVenvBuilder := func() {
 self := undefined
 
@@ -32,7 +35,7 @@ return self
 },
 
 runEnvDescriptor: func(descriptor) {
-validation.assertJsonSchema(descriptor, pkg.runEnvDescriptorScheme, "exec.python.runEnvDescriptor: <descriptor> must be run environment specification")
+validation.assertJsonSchema(descriptor, desc.runEnvScheme, "exec.python.runEnvDescriptor: <descriptor> must be run environment specification")
 ll.assert(descriptor.type == "python", "exec.python.runEnvDescriptor: not a 'python' run environment: %q", descriptor.type)
 
 pythonDescriptor = ll.fromStrict(descriptor)
@@ -139,7 +142,7 @@ python: pythonPkg
 
 validation.assertJsonSchema(pyVenvInputs, internal.pythonVenvInputSchema, "incomplete python runenv configuration")
 
-tpl := render.create(assets.importTemplate("@platforma-sdk/workflow-tengo:exec.python.create-venv"), pyVenvInputs)
+tpl := render.create(createVenvTpl, pyVenvInputs)
 
 self := undefined
 self = ll.toStrict(oop.inherit(tpl, {

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

@@ -7,6 +7,9 @@ maps := import("@platforma-sdk/workflow-tengo:maps")
 oop := import("@platforma-sdk/workflow-tengo:oop")
 smart := import("@platforma-sdk/workflow-tengo:smart")
 json := import("json")
+constants := import("@platforma-sdk/workflow-tengo:exec.constants")
+slices := import("@platforma-sdk/workflow-tengo:slices")
+desc := import("@platforma-sdk/workflow-tengo:exec.descriptor")
 
 _RTYPE_RUN_COMMAND := { Name: "RunCommand/executor", Version: "1" }
 _RTYPE_RUN_COMMAND_CMD := { Name: "RunCommandCmd", Version: "1" }
@@ -21,7 +24,7 @@ _RTYPE_RUN_COMMAND_REFS := { Name: "RunCommandRefs", Version: "1" }
 
 _createSimpleArg := func(argument) {
 return {
-type: "string",
+type: constants.ARG_TYPE_STRING,
 value: argument
 }
 }
@@ -30,9 +33,24 @@ value: argument
 
 
 
+
 _createVariableArg := func(argTpl) {
 return {
-type: "variableRef",
+type: constants.ARG_TYPE_VAR,
+value: argTpl
+}
+}
+
+
+
+
+
+
+
+
+_createExpressionArg := func(argTpl) {
+return {
+type: constants.ARG_TYPE_EXPRESSION,
 value: argTpl
 }
 }
@@ -56,7 +74,8 @@ queue := ""
 refs := {}
 
 substRules := {}
-hasPatternArgs := false
+hasPatternArgs := false // TODO: deprecated, remove after a month of expressionRefs in prod.
+hasExpressionArgs := false
 customPaths := []
 
 stdout := "stdout.txt"
@@ -93,6 +112,35 @@ return self
 
 
 
+
+
+
+cmdExpression: func(commandTpl) {
+cmd = _createExpressionArg(commandTpl)
+hasExpressionArgs = true
+return self
+},
+
+cmdTyped: func(type, value) {
+ll.assert(slices.hasElement(constants.ARG_TYPES, type),
+"runcmd.builder().cmdTyped: unknown type %s, expect: %v", type, constants.ARG_TYPES)
+
+if type == constants.ARG_TYPE_STRING {
+return self.cmd(value)
+} else if type == constants.ARG_TYPE_EXPRESSION {
+return self.cmdExpression(value)
+} else if type == constants.ARG_TYPE_VAR {
+return self.cmdVar(value)
+}
+
+ll.panic("runcmd.builder().cmdTyped: unknown type %s, expect: %v", type, constants.ARG_TYPES)
+},
+
+
+
+
+
+
 arg: func(arg) {
 args = append(args, _createSimpleArg(arg))
 return self
@@ -112,6 +160,41 @@ hasPatternArgs = true
 return self
 },
 
+
+
+
+
+
+
+
+
+argExpression: func(argTpl) {
+args = append(args, _createExpressionArg(argTpl))
+hasExpressionArgs = true
+return self
+},
+
+argTyped: func(type, value) {
+ll.assert(slices.hasElement(constants.ARG_TYPES, type),
+"runcmd.builder().argTyped: unknown type %s, expect: %v", type, constants.ARG_TYPES)
+
+if type == constants.ARG_TYPE_STRING {
+return self.arg(value)
+} else if type == constants.ARG_TYPE_EXPRESSION {
+return self.argExpression(value)
+} else if type == constants.ARG_TYPE_VAR {
+return self.argVar(value)
+}
+
+ll.panic("runcmd.builder().argTyped: unknown type %s, expect: %v", type, constants.ARG_TYPES)
+},
+
+
+
+
+
+
+
 ref: func(refKey, ref) {
 ll.assert(smart.isReference(ref),
 "runcmd.builder().ref() must be a reference (valid field or resource)")
@@ -153,13 +236,50 @@ return self
 
 
 
-addToPath: func(value, hasVars) {
-if hasVars {
+
+envExpression: func(name, valueTpl) {
+envs[name] = _createExpressionArg(valueTpl)
+hasExpressionArgs = true
+return self
+},
+
+envTyped: func(name, type, value) {
+ll.assert(slices.hasElement(constants.ARG_TYPES, type),
+"runcmd.builder().envTyped: unknown type %s, expect: %v", type, constants.ARG_TYPES)
+
+if type == constants.ARG_TYPE_STRING {
+return self.env(name, value)
+} else if type == constants.ARG_TYPE_EXPRESSION {
+return self.envExpression(name, value)
+} else if type == constants.ARG_TYPE_VAR {
+return self.envVar(name, value)
+}
+
+ll.panic("runcmd.builder().envTyped: unknown type %s, expect: %v", type, constants.ARG_TYPES)
+},
+
+
+
+
+
+
+
+addToPath: func(type, value) {
+ll.assert(slices.hasElement(constants.ARG_TYPES, type),
+"runcmd.builder().addToPath: unknown type %s, expect: %v", type, constants.ARG_TYPES)
+
+if type == constants.ARG_TYPE_STRING {
+customPaths = append(customPaths, _createSimpleArg(value))
+} else if type == constants.ARG_TYPE_EXPRESSION {
+customPaths = append(customPaths, _createExpressionArg(value))
+hasExpressionArgs = true
+} else if type == constants.ARG_TYPE_VAR {
 customPaths = append(customPaths, _createVariableArg(value))
 hasPatternArgs = true
 } else {
-customPaths = append(customPaths, _createSimpleArg(value))
+ll.panic("runcmd.builder().addToPath: unknown type %s, expect: %v", type, constants.ARG_TYPES)
 }
+
 return self
 },
 
@@ -235,8 +355,12 @@ return self
 build: func() {
 
 
-ll.assert(!hasPatternArgs || len(substRules) != 0,
-"found pattern argument, but no substitution rules were set")
+ll.assert(!(hasPatternArgs || hasExpressionArgs) || len(substRules) != 0,
+"found pattern argument, but no substitution rules were set: hasPatternArgs: %v, substRules: %v, cmd: %v, args: %v, envs: %v",
+hasPatternArgs, substRules, cmd, args, envs)
+ll.assert(!hasExpressionArgs || desc.canBackendUseExpressions(),
+"runcmd.builder().build: expression arguments must be enabled only if platforma backend supports expressions, found: %v",
+hasExpressionArgs)
 
 refsRes := smart.createMapResourceWithType(_RTYPE_RUN_COMMAND_REFS, refs)
 self.getField("refs").set(refsRes)

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

@@ -8,13 +8,6 @@ text := import("text")
 
 
 
-apiVersion := func() {
-return 0 // stub code. Real API checker will appear here.
-}
-
-
-
-
 print := func(txt, ...args) {
 plapi.print(txt, args...)
 }
@@ -86,35 +79,6 @@ return plapi.strictToMap(r)
 
 
 
-
-
-methodExists := func(module, methodName) {
-if isStrict(module) {
-if !is_callable(plapi.mapHasKey) {
-module = fromStrict(module)
-
-} else {
-if !plapi.mapHasKey(module, methodName) {
-return false
-}
-}
-}
-
-method := module[methodName]
-
-if is_undefined(method) {
-return false
-}
-
-return is_callable(method)
-}
-
-
-
-
-
-
-
 ensureNonStrict := func(r) {
 if isStrict(r) {
 return fromStrict(r)
@@ -164,6 +128,46 @@ return plapi.mapToStrict(v)
 
 
 
+
+
+
+
+
+methodExists := func(module, methodName) {
+if isStrict(module) {
+if !is_callable(plapi.mapHasKey) {
+module = fromStrict(module)
+
+} else {
+if !plapi.mapHasKey(module, methodName) {
+return false
+}
+}
+}
+
+method := module[methodName]
+
+if is_undefined(method) {
+return false
+}
+
+return true
+}
+
+
+
+
+apiVersion := func() {
+if !methodExists(plapi, "apiVersion") {
+return 0 // before we introduced apiVersion
+}
+
+return plapi.apiVersion
+}
+
+
+
+
 fieldId := func(resourceId, fieldName) {
 return plapi.newFieldID(resourceId, fieldName)
 }

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

@@ -19,6 +19,7 @@ return slices.sortByFn(res, func(elem) { return elem })
 
 
 
+
 containsKey := func(map, key) {
 for k, _ in map {
 if key == k {

package/dist/tengo/lib/smart.lib.tengo

@@ -96,14 +96,14 @@ createBlobMapResource := undefined
 
 
 isResource := func(f) {
-return ll.isStrict(f) && ll.fromStrict(f)["_type"] == "resource"
+return ll.isStrict(f) && maps.containsKey(f, "_type") && f["_type"] == "resource"
 }
 
 
 
 
 isField := func(f) {
-return ll.isStrict(f) && ll.fromStrict(f)["_type"] == "field"
+return ll.isStrict(f) && maps.containsKey(f, "_type") && f["_type"] == "field"
 }
 
 

package/package.json

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