@platforma-sdk/workflow-tengo 6.17.3 → 6.19.0

package/dist/index.cjs

@@ -43,5 +43,7 @@ module.exports = { Templates: {
   'pframes.process-pcolumn-batch': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.process-pcolumn-batch.plj.gz') },
   'pframes.process-pcolumn-data': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.process-pcolumn-data.plj.gz') },
   'pframes.export-pframe': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.export-pframe.plj.gz') },
+  'v2.export-collection-for-ui': { type: 'from-file', path: require.resolve('./tengo/tpl/v2.export-collection-for-ui.plj.gz') },
+  'v2.export-for-ui': { type: 'from-file', path: require.resolve('./tengo/tpl/v2.export-for-ui.plj.gz') },
   'pframes.export-pframe-for-ui': { type: 'from-file', path: require.resolve('./tengo/tpl/pframes.export-pframe-for-ui.plj.gz') }
 }};

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-parquet-pcolumn-chunk" | "pframes.export-single-pcolumn" | "pframes.import-dir" | "pframes.merge-resource-maps" | "pframes.remove-nulls" | "pt.import-dir" | "waiter.waiter" | "workdir.save" | "workflow.build-ctx" | "workflow.query-context-filter" | "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" | "workflow.query-anchored" | "check_network.create_workdir_from_storage" | "exec.conda.create-env" | "exec.exec-impl" | "exec.monetization_info" | "exec.python.create-venv" | "pframes.slice-data" | "check_network.download_blob" | "check_network.upload_blob" | "check_network.upload_template" | "exec.load-software.impl" | "pframes.parse-to-json" | "exec.exec" | "pt.workflow-run" | "check_network.run_hello_world" | "check_network.run_hello_world_py" | "pframes.build-table" | "pframes.xsv-export-pframe" | "pframes.xsv-import-if-not-null" | "pframes.xsv-import-map" | "annotations.compute" | "pframes.process-pcolumn-batch-split" | "pframes.process-pcolumn-batch" | "pframes.process-pcolumn-data" | "pframes.export-pframe" | "pframes.export-pframe-for-ui";
+declare type TplName = "ll.get-field" | "pframes.export-parquet-pcolumn-chunk" | "pframes.export-single-pcolumn" | "pframes.import-dir" | "pframes.merge-resource-maps" | "pframes.remove-nulls" | "pt.import-dir" | "waiter.waiter" | "workdir.save" | "workflow.build-ctx" | "workflow.query-context-filter" | "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" | "workflow.query-anchored" | "check_network.create_workdir_from_storage" | "exec.conda.create-env" | "exec.exec-impl" | "exec.monetization_info" | "exec.python.create-venv" | "pframes.slice-data" | "check_network.download_blob" | "check_network.upload_blob" | "check_network.upload_template" | "exec.load-software.impl" | "pframes.parse-to-json" | "exec.exec" | "pt.workflow-run" | "check_network.run_hello_world" | "check_network.run_hello_world_py" | "pframes.build-table" | "pframes.xsv-export-pframe" | "pframes.xsv-import-if-not-null" | "pframes.xsv-import-map" | "annotations.compute" | "pframes.process-pcolumn-batch-split" | "pframes.process-pcolumn-batch" | "pframes.process-pcolumn-data" | "pframes.export-pframe" | "v2.export-collection-for-ui" | "v2.export-for-ui" | "pframes.export-pframe-for-ui";
 declare const Templates: Record<TplName, TemplateFromFile>;
 export { Templates };

package/dist/index.js

@@ -44,5 +44,7 @@ export const Templates = {
   'pframes.process-pcolumn-batch': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.process-pcolumn-batch.plj.gz') },
   'pframes.process-pcolumn-data': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.process-pcolumn-data.plj.gz') },
   'pframes.export-pframe': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.export-pframe.plj.gz') },
+  'v2.export-collection-for-ui': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/v2.export-collection-for-ui.plj.gz') },
+  'v2.export-for-ui': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/v2.export-for-ui.plj.gz') },
   'pframes.export-pframe-for-ui': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/pframes.export-pframe-for-ui.plj.gz') }
 };

package/dist/tengo/lib/action-context.lib.tengo

@@ -0,0 +1,296 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+maps := import("@platforma-sdk/workflow-tengo:maps")
+feats := import("@platforma-sdk/workflow-tengo:feats")
+constants := import("@platforma-sdk/workflow-tengo:constants")
+json := import("json")
+slices := import("@platforma-sdk/workflow-tengo:slices")
+text := import("text")
+times := import("times")
+tx := import("tx")
+
+LINK_FIELD := "actionContext"
+STATES := ["WaitingForInputs", "Running", "WaitingWorkdirGate", "WaitingSubmissionGate", "PopulatingWorkdir",
+	"CollectingOutputs", "WaitingForScheduler", "WaitingForMachine", "Terminated", "Completed"]
+CHILD_FIELD_PREFIX := "child/"
+CONTEXT_TYPE := { Name: "ActionContext", Version: "1" }
+SINKHOLE_TYPE := { Name: "ActionSinkhole", Version: "1" }
+
+
+
+_vars := func() {
+	return ll.moduleVars("action-context")
+}
+
+
+
+
+
+
+
+linkOf := func(rid) {
+	fields := tx.getResource(rid).ServiceFields
+	if !maps.containsKey(fields, LINK_FIELD) || fields[LINK_FIELD].Value == 0 {
+		return { kind: "none" }
+	}
+	target := fields[LINK_FIELD].Value
+	if tx.getResource(target).Type.Name == CONTEXT_TYPE.Name {
+		return { kind: "context", id: target }
+	}
+	return { kind: "sinkhole", id: target }
+}
+
+
+
+
+
+contextOf := func(rid) {
+	link := linkOf(rid)
+	return link.kind == "context" ? link.id : undefined
+}
+
+_own := func() {
+	vars := _vars()
+	own := vars.get("own")
+	if is_undefined(own) {
+		own = linkOf(ll.getCurrentTemplateRenderer().ID)
+		vars.set("own", own)
+	}
+	return own
+}
+
+_ownBaggage := func() {
+	vars := _vars()
+	baggage := vars.get("ownBaggage")
+	if is_undefined(baggage) {
+		baggage = {}
+		raw := tx.getResource(_own().id).Data
+		if !is_undefined(raw) && len(raw) > 0 {
+			baggage = json.decode(raw)
+		}
+		vars.set("ownBaggage", baggage)
+	}
+	return copy(baggage)
+}
+
+_childFieldName := func() {
+	vars := _vars()
+	counter := vars.get("childCounter")
+	counter = is_undefined(counter) ? 0 : counter + 1
+	vars.set("childCounter", counter)
+	return CHILD_FIELD_PREFIX + string(times.time_unix_nano(times.now())) + "-" + string(counter)
+}
+
+
+
+_enabled := func() {
+	return feats.kvAsync && feats.optionalFieldsInSchemas
+}
+
+_link := func(rid, target) {
+	if !_enabled() {
+		return
+	}
+	field := ll.fieldId(rid, LINK_FIELD)
+	tx.createField(field, constants.FTYPE_SERVICE)
+	tx.setFieldToResource(field, target)
+}
+
+_validateKeyPart := func(name, part) {
+	ll.assert(is_string(part) && len(part) > 0, "action context: %s must be a non-empty string", name)
+	ll.assert(!text.contains(part, "/"), "action context: %s %q contains \"/\"", name, part)
+}
+
+_createLinked := func(rid, type, baggage) {
+	id := tx.createEphemeral(type.Name, type.Version, json.encode(baggage))
+	_link(rid, id)
+	return id
+}
+
+
+_childBaggage := func(name) {
+	baggage := _own().kind == "none" ? {} : _ownBaggage()
+	if !is_undefined(name) {
+		baggage.name = name
+	}
+	return baggage
+}
+
+
+
+
+
+
+
+
+
+
+sinkhole := func(rid, ...name) {
+	if _enabled() {
+		_createLinked(rid, SINKHOLE_TYPE, _childBaggage(len(name) > 0 ? name[0] : undefined))
+	}
+}
+
+
+
+
+
+
+
+
+
+inherit := func(rid) {
+	own := _own()
+	if own.kind != "none" {
+		_link(rid, own.id)
+	}
+}
+
+
+
+
+
+
+
+
+
+
+createContext := func(rid, baggage) {
+	return _enabled() ? _createLinked(rid, CONTEXT_TYPE, copy(baggage)) : undefined
+}
+
+
+
+
+
+
+
+
+
+
+createChild := func(rid, name) {
+	if !_enabled() {
+		return undefined
+	}
+	own := _own()
+	if own.kind == "none" {
+		return undefined
+	}
+	if own.kind == "sinkhole" {
+		sinkhole(rid, name)
+		return undefined
+	}
+
+	contextId := _createLinked(rid, CONTEXT_TYPE, _childBaggage(name))
+
+	childField := ll.fieldId(own.id, _childFieldName())
+	tx.createField(childField, constants.FTYPE_DYNAMIC)
+	tx.setFieldToResource(childField, contextId)
+
+	return contextId
+}
+
+
+
+
+
+
+
+
+
+
+of := func(rid) {
+	contextId := func() {
+		return _enabled() ? contextOf(rid) : undefined
+	}
+
+	return ll.toStrict({
+		setReading: func(namespace, key, value) {
+			_validateKeyPart("namespace", namespace)
+			_validateKeyPart("reading key", key)
+			ctx := contextId()
+			if !is_undefined(ctx) {
+				tx.resourceKeyValueSetAsync(ctx, "reading/" + namespace + "/" + string(rid) + "/" + key, value)
+			}
+		},
+
+		record: func(namespace, state, ...detail) {
+			_validateKeyPart("namespace", namespace)
+			ll.assert(slices.hasElement(STATES, state), "action context: unknown state %q", state)
+			ctx := contextId()
+			if !is_undefined(ctx) {
+				key := "transition/" + namespace + "/" + string(rid) + "/" + string(times.time_unix_nano(times.now()))
+				value := json.encode({ state: state, detail: len(detail) > 0 ? detail[0] : "", reason: "" })
+				tx.resourceKeyValueSetAsync(ctx, key, value)
+			}
+		}
+	})
+}
+
+
+
+
+
+
+
+
+
+
+self := func() {
+	renderer := ll.getCurrentTemplateRenderer().ID
+	handle := of(renderer)
+	return ll.toStrict({
+		setReading: handle.setReading,
+		record: handle.record,
+
+		baggage: func() {
+			return _own().kind == "none" ? undefined : _ownBaggage()
+		},
+
+		id: func() {
+			return _own().kind == "context" ? _own().id : undefined
+		}
+	})
+}
+
+export ll.toStrict({
+	LINK_FIELD: LINK_FIELD,
+	CHILD_FIELD_PREFIX: CHILD_FIELD_PREFIX,
+
+	linkOf: linkOf,
+	contextOf: contextOf,
+	createChild: createChild,
+	createContext: createContext,
+	inherit: inherit,
+	sinkhole: sinkhole,
+	of: of,
+	self: self
+})

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

@@ -18,8 +18,28 @@ maps := import("@platforma-sdk/workflow-tengo:maps")
 
 
 
+
+
+
+_templateNames := func() {
+	return ll.moduleVars("assets.templateNames")
+}
+
 importTemplate := func(tplName) {
-	return smart.resource(plapi.getTemplateId(tplName))
+	id := plapi.getTemplateId(tplName)
+	_templateNames().set(string(id), tplName)
+	return smart.resource(id)
+}
+
+
+
+
+
+
+
+templateName := func(tpl) {
+	id := smart.isResource(tpl) ? tpl.id : tpl
+	return _templateNames().get(string(id))
 }
 
 
@@ -66,6 +86,7 @@ isAssetInfo := func(toCheck) {
 
 export ll.toStrict({
 	importTemplate      : importTemplate,
+	templateName        : templateName,
 	importSoftware      : swinfo.importSoftware,
 	isSoftwareInfo      : swinfo.isSoftwareInfo,
 	importAsset         : importAsset,

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

@@ -13,6 +13,7 @@ smart := import("@platforma-sdk/workflow-tengo:smart")
 json := import("json")
 constants := import("@platforma-sdk/workflow-tengo:exec.constants")
 feats := import("@platforma-sdk/workflow-tengo:feats")
+actionContext := import("@platforma-sdk/workflow-tengo:action-context")
 
 _RTYPE_QUOTA := { Name: "Quota", Version: "1" }
 
@@ -278,6 +279,8 @@ computeRequestBuilder := func() {
 
 			requestBuilder.getField(_CR_FIELD_REQUEST).set(quota)
 
+
+			actionContext.inherit(requestBuilder.id)
 			requestRef := requestBuilder.lockAndBuild()
 
 			return ll.toStrict(

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

@@ -17,6 +17,7 @@ slices := import("@platforma-sdk/workflow-tengo:slices")
 limits := import("@platforma-sdk/workflow-tengo:exec.limits")
 
 delayedCompAlloc := import("@platforma-sdk/workflow-tengo:exec.delayed-compute-allocation")
+actionContext := import("@platforma-sdk/workflow-tengo:action-context")
 
 _RTYPE_RUN_COMMAND_V1 := { Name: "RunCommand/executor", Version: "1" }
 _RTYPE_RUN_COMMAND_CMD := { Name: "RunCommandCmd", Version: "1" }
@@ -776,6 +777,9 @@ builder := func(workdir, ...initialState) {
 			argsRes := smart.createValueResource(_RTYPE_RUN_COMMAND_ARGS, json.encode(options.args))
 			runRes.getField(_FIELD_ARGS).set(argsRes)
 
+
+			actionContext.inherit(runRes.id)
+
 			res := oop.inherit(runRes.lockAndBuild(), {
 				"workdir": runRes.outputs()[_FIELD_WORKDIR_OUT],
 				"options": buildOptions

package/dist/tengo/lib/feats.lib.tengo

@@ -97,5 +97,13 @@ export ll.toStrict({
 
 
 
-	multiStepProgress:        _isEnabled("multiStepProgress")
+	multiStepProgress:        _isEnabled("multiStepProgress"),
+
+
+	kvAsync:                  _isEnabled("kvAsync"),
+
+
+
+
+	optionalFieldsInSchemas:  _isEnabled("optionalFieldsInSchemas") || _isEnabled("optionalServiceField")
 })

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

@@ -65,7 +65,8 @@ render := import("@platforma-sdk/workflow-tengo:render")
 
 
 
-createBuilder := func(ctx) {
+
+createBuilderWith := func(q, ctx) {
 
 
 
@@ -117,6 +118,9 @@ createBuilder := func(ctx) {
 
 
 		isGlobalRef := is_map(decodedId) && decodedId.__isRef == true
+		if isGlobalRef && maps.containsKey(q, "isRef") {
+			ll.panic("serialized value ids are not supported by this query API; add a ref {block, workflow, name} with addRef, got %v", id)
+		}
 		if isGlobalRef {
 			refKey := is_string(id) ? id : canonical.encode(decodedId)
 			if !is_undefined(queryKey) {
@@ -305,7 +309,7 @@ createBuilder := func(ctx) {
 		build: func() {
 
 
-			resolveResult := bquery.anchoredQuery(ctx, anchors, queries, anchoredQueryOpts)
+			resolveResult := q.anchoredQuery(ctx, anchors, queries, anchoredQueryOpts)
 
 			bundle := smart.mapBuilder(pConstants.RTYPE_P_COLUMN_BUNDLE)
 
@@ -314,7 +318,7 @@ createBuilder := func(ctx) {
 					bundle.addRef(refKey, resolveResult.getAnchor(ref))
 					bundle.addRef(ref, resolveResult.getAnchor(ref))
 				} else {
-					bundle.addRef(refKey, bquery.resolve(ref, ctx))
+					bundle.addRef(refKey, q.resolve(ref, ctx))
 				}
 			}
 
@@ -334,6 +338,15 @@ createBuilder := func(ctx) {
 
 
 
+createBuilder := func(ctx) {
+	return createBuilderWith(bquery, ctx)
+}
+
+
+
+
+
+
 
 
 
@@ -392,6 +405,17 @@ pColumnBundleUnmarshaller := func() {
 
 				result := bResultUnmarshaller.parse(value.getValue(), parser)
 
+
+
+
+				dataOf := func(r) {
+					if !ll.isMap(r) || maps.containsKey(r, "data") || !maps.containsKey(r, "ref") ||
+						!ll.isMap(r.ref) || !maps.containsKey(r.ref, "block") {
+						return r.data
+					}
+					return undefined
+				}
+
 				if is_array(result) {
 					arr := []
 					for i, r in result {
@@ -400,7 +424,7 @@ pColumnBundleUnmarshaller := func() {
 						el := {
 							key: k,
 							spec: r.spec,
-							data: r.data
+							data: dataOf(r)
 						}
 						pool[k] = el
 						arr = append(arr, el)
@@ -410,7 +434,7 @@ pColumnBundleUnmarshaller := func() {
 					pool[resultKey] = {
 						key: resultKey,
 						spec: result.spec,
-						data: result.data
+						data: dataOf(result)
 					}
 				}
 			}
@@ -611,5 +635,6 @@ pColumnBundleUnmarshaller := func() {
 
 export ll.toStrict({
 	createBuilder: createBuilder,
+	createBuilderWith: createBuilderWith,
 	pColumnBundleUnmarshaller: pColumnBundleUnmarshaller
 })

package/dist/tengo/lib/pframes.table-builder.lib.tengo

@@ -22,8 +22,6 @@
 
 
 
-
-
 
 
 
@@ -148,6 +146,29 @@ isQuerySpec := func(q) {
 
 
 
+holdsRef := func(value, isRef) {
+	stack := [value]
+	si := 0
+	for si < len(stack) {
+		v := stack[si]
+		si += 1
+		if isRef(v) { return true }
+		if ll.isMap(v) {
+			if isResolvedColumn(v) { continue }
+			for _, child in v {
+				stack = append(stack, child)
+			}
+		} else if is_array(v) {
+			for _, child in v {
+				stack = append(stack, child)
+			}
+		}
+	}
+	return false
+}
+
+
+
 
 
 
@@ -157,7 +178,16 @@ isQuerySpec := func(q) {
 
 
 
-tableBuilder := func(format, ...ctxArg) {
+tableBuilderWith := func(q, format, ...ctxArg) {
+
+	unresolved := isUnresolved
+	if maps.containsKey(q, "isRef") {
+		unresolved = func(value) { return holdsRef(value, q.isRef) }
+	}
+	querySpec := func(v) {
+		return !unresolved(v) && !isResolvedColumn(v) && !isEnrichmentRef(v)
+	}
+
 	ll.assert(!is_undefined(VALID_FORMATS[format]),
 		"format must be one of [tsv, csv, parquet, ndjson], got '%s'", format)
 
@@ -194,7 +224,7 @@ tableBuilder := func(format, ...ctxArg) {
 				header = opts[0].header
 			}
 
-			unresolved := isUnresolved(value)
+			unresolved := unresolved(value)
 			if !unresolved {
 				ll.assert(
 					isResolvedColumn(value) ||
@@ -232,7 +262,7 @@ tableBuilder := func(format, ...ctxArg) {
 				header = opts[0].header
 			}
 			join := columnJoinOpt(opts)
-			if isUnresolved(query) || isEnrichmentRef(query) {
+			if unresolved(query) || isEnrichmentRef(query) {
 				_hasUnresolved = true
 			}
 			_columns = append(_columns, {
@@ -283,7 +313,7 @@ tableBuilder := func(format, ...ctxArg) {
 						entrySuffix = undefined
 					}
 
-					if isUnresolved(entryQuery) || isEnrichmentRef(entryQuery) {
+					if unresolved(entryQuery) || isEnrichmentRef(entryQuery) {
 						_hasUnresolved = true
 					}
 					_columns = append(_columns, {
@@ -298,7 +328,7 @@ tableBuilder := func(format, ...ctxArg) {
 				return self
 			}
 
-			if isUnresolved(query) || isEnrichmentRef(query) {
+			if unresolved(query) || isEnrichmentRef(query) {
 				_hasUnresolved = true
 			}
 			_columns = append(_columns, {
@@ -406,7 +436,7 @@ tableBuilder := func(format, ...ctxArg) {
 
 			hasQuerySpec := false
 			for _, c in _columns {
-				if isQuerySpec(c.query) {
+				if querySpec(c.query) {
 					hasQuerySpec = true
 					break
 				}
@@ -421,15 +451,18 @@ tableBuilder := func(format, ...ctxArg) {
 
 			resolveColumn := func(value) {
 				if is_string(value) {
+					if maps.containsKey(q, "isRef") {
+						ll.panic("serialized value ids are not supported by this query API; pass a ref {block, workflow, name}, got %v", value)
+					}
 					ref := decodeGlobalPObjectId(value)
-					r := bquery.resolve(ref, _ctx)
+					r := q.resolve(ref, _ctx)
 					return {
 						spec: r.getFutureInputField("spec"),
 						data: r.getFutureInputField("data")
 					}
 				}
-				if isUnresolved(value) {
-					r := bquery.resolve(value, _ctx)
+				if unresolved(value) {
+					r := q.resolve(value, _ctx)
 					return {
 						spec: r.getFutureInputField("spec"),
 						data: r.getFutureInputField("data")
@@ -462,7 +495,7 @@ tableBuilder := func(format, ...ctxArg) {
 					data: resolvedCol.data,
 					filters: []
 				}
-				if isUnresolved(column) {
+				if unresolved(column) {
 					primaryPlRefs[p.name] = column
 				}
 
@@ -487,7 +520,7 @@ tableBuilder := func(format, ...ctxArg) {
 			multiQueryResultByIdx := {}
 			qMap := {}
 			for idx, c in _columns {
-				if isQuerySpec(c.query) {
+				if querySpec(c.query) {
 					strategy := "expectSingle"
 					if c.mode == "multi" { strategy = "expectMultiple" }
 					qMap["q" + string(idx)] = maps.deepMerge(c.query, {
@@ -500,9 +533,9 @@ tableBuilder := func(format, ...ctxArg) {
 					"column query specs require at least one primary added as a PlRef " +
 					"or PrimaryRef (pre-resolved primaries cannot anchor column queries)")
 
-				qResult := bquery.anchoredQuery(_ctx, primaryPlRefs, qMap)
+				qResult := q.anchoredQuery(_ctx, primaryPlRefs, qMap)
 				for idx, c in _columns {
-					if isQuerySpec(c.query) {
+					if querySpec(c.query) {
 						r := qResult.getResult("q" + string(idx))
 						if c.mode == "multi" {
 
@@ -552,7 +585,7 @@ tableBuilder := func(format, ...ctxArg) {
 				} else if isResolvedColumn(c.query) {
 					entry.spec = c.query.spec
 					entry.data = c.query.data
-				} else if isUnresolved(c.query) {
+				} else if unresolved(c.query) {
 					resolved := resolveColumn(c.query)
 					entry.spec = resolved.spec
 					entry.data = resolved.data
@@ -646,6 +679,14 @@ tableBuilder := func(format, ...ctxArg) {
 	return ll.toStrict(self)
 }
 
+
+
+
+tableBuilder := func(format, ...ctxArg) {
+	return tableBuilderWith(bquery, format, ctxArg...)
+}
+
 export ll.toStrict({
-	tableBuilder: tableBuilder
+	tableBuilder: tableBuilder,
+	tableBuilderWith: tableBuilderWith
 })