@milaboratories/pl-middle-layer 1.48.11 → 1.48.13

package/dist/js_render/computable_context.js

@@ -1,571 +1,436 @@
-import { Computable } from '@milaboratories/computable';
-import { mapPObjectData, mapValueInVOE, mapPTableDef, mapPTableDefV2, isDataInfo, mapDataInfo, checkBlockFlag } from '@platforma-sdk/model';
-import { notEmpty } from '@milaboratories/ts-helpers';
-import { randomUUID } from 'node:crypto';
-import { parseFinalPObjectCollection } from '../pool/p_object_collection.js';
-import { Scope } from 'quickjs-emscripten';
+import { parseFinalPObjectCollection } from "../pool/p_object_collection.js";
+import { checkBlockFlag, isDataInfo, mapDataInfo, mapPObjectData, mapPTableDef, mapPTableDefV2, mapValueInVOE } from "@platforma-sdk/model";
+import { notEmpty } from "@milaboratories/ts-helpers";
+import { Computable } from "@milaboratories/computable";
+import { randomUUID } from "node:crypto";
+import { Scope } from "quickjs-emscripten";
 
+//#region src/js_render/computable_context.ts
 function bytesToBase64(data) {
-    return data !== undefined ? Buffer.from(data).toString("base64") : undefined;
-}
-class ComputableContextHelper {
-    parent;
-    blockCtx;
-    env;
-    featureFlags;
-    computablesToResolve = {};
-    computableCtx;
-    accessors = new Map();
-    meta;
-    constructor(parent, blockCtx, env, featureFlags, computableCtx) {
-        this.parent = parent;
-        this.blockCtx = blockCtx;
-        this.env = env;
-        this.featureFlags = featureFlags;
-        this.computableCtx = computableCtx;
-        this.meta = blockCtx.blockMeta(computableCtx);
-    }
-    resetComputableCtx() {
-        this.computableCtx = undefined;
-        this.accessors.clear();
-    }
-    //
-    // Methods for injected ctx object
-    //
-    getAccessorHandleByName(name) {
-        if (this.computableCtx === undefined)
-            throw new Error("Accessors can't be used in this context");
-        const wellKnownAccessor = (name, ctxKey) => {
-            if (!this.accessors.has(name)) {
-                const lambda = this.blockCtx[ctxKey];
-                if (lambda === undefined)
-                    throw new Error("Staging context not available");
-                const entry = lambda(this.computableCtx);
-                if (!entry)
-                    this.accessors.set(name, undefined);
-                else
-                    this.accessors.set(name, this.computableCtx.accessor(entry).node({ ignoreError: true }));
-            }
-            return this.accessors.get(name) ? name : undefined;
-        };
-        if (name === "staging")
-            return wellKnownAccessor("staging", "staging");
-        else if (name === "main")
-            return wellKnownAccessor("main", "prod");
-        return undefined;
-    }
-    //
-    // Accessors
-    //
-    resolveWithCommon(handle, commonOptions, ...steps) {
-        return this.wrapAccessor(this.getAccessor(handle).traverseWithCommon(commonOptions, ...steps));
-    }
-    getResourceType(handle) {
-        return this.getAccessor(handle).resourceType;
-    }
-    getInputsLocked(handle) {
-        return this.getAccessor(handle).getInputsLocked();
-    }
-    getOutputsLocked(handle) {
-        return this.getAccessor(handle).getOutputsLocked();
-    }
-    getIsReadyOrError(handle) {
-        return this.getAccessor(handle).getIsReadyOrError();
-    }
-    getIsFinal(handle) {
-        return this.getAccessor(handle).getIsFinal();
-    }
-    getError(handle) {
-        return this.wrapAccessor(this.getAccessor(handle).getError());
-    }
-    listInputFields(handle) {
-        return this.getAccessor(handle).listInputFields();
-    }
-    listOutputFields(handle) {
-        return this.getAccessor(handle).listOutputFields();
-    }
-    listDynamicFields(handle) {
-        return this.getAccessor(handle).listDynamicFields();
-    }
-    getKeyValueBase64(handle, key) {
-        return bytesToBase64(this.getAccessor(handle).getKeyValue(key));
-    }
-    getKeyValueAsString(handle, key) {
-        return this.getAccessor(handle).getKeyValueAsString(key);
-    }
-    getDataBase64(handle) {
-        return bytesToBase64(this.getAccessor(handle).getData());
-    }
-    getDataAsString(handle) {
-        return this.getAccessor(handle).getDataAsString();
-    }
-    //
-    // Accessor helpers
-    //
-    parsePObjectCollection(handle, errorOnUnknownField, prefix, ...resolveSteps) {
-        const acc = this.getAccessor(handle);
-        if (!acc.getIsReadyOrError())
-            return undefined;
-        const accResult = parseFinalPObjectCollection(acc, errorOnUnknownField, prefix, resolveSteps);
-        const result = {};
-        for (const [key, obj] of Object.entries(accResult)) {
-            result[key] = mapPObjectData(obj, (d) => this.wrapAccessor(d));
-        }
-        return result;
-    }
-    //
-    // Blobs
-    //
-    registerComputable(hPrefix, computable) {
-        const fHandle = `${hPrefix}_${randomUUID()}`;
-        this.computablesToResolve[fHandle] = computable;
-        return fHandle;
-    }
-    getBlobContentAsString(handle, range) {
-        const resourceInfo = this.getAccessor(handle).resourceInfo;
-        return this.registerComputable("getBlobContentAsString", Computable.make((ctx) => this.env.driverKit.blobDriver.getDownloadedBlob(resourceInfo, ctx), {
-            postprocessValue: async (value) => {
-                if (value === undefined)
-                    return undefined;
-                return Buffer.from(await this.env.driverKit.blobDriver.getContent(value.handle, range)).toString("utf-8");
-            },
-        }));
-    }
-    getBlobContentAsBase64(handle, range) {
-        const resourceInfo = this.getAccessor(handle).resourceInfo;
-        return this.registerComputable("getBlobContentAsBase64", Computable.make((ctx) => this.env.driverKit.blobDriver.getDownloadedBlob(resourceInfo, ctx), {
-            postprocessValue: async (value) => {
-                if (value === undefined)
-                    return undefined;
-                return Buffer.from(await this.env.driverKit.blobDriver.getContent(value.handle, range)).toString("base64");
-            },
-        }));
-    }
-    getDownloadedBlobContentHandle(handle) {
-        const resourceInfo = this.getAccessor(handle).resourceInfo;
-        return this.registerComputable("getDownloadedBlobContentHandle", this.env.driverKit.blobDriver.getDownloadedBlob(resourceInfo));
-    }
-    getOnDemandBlobContentHandle(handle) {
-        const resource = this.getAccessor(handle).persist();
-        return this.registerComputable("getOnDemandBlobContentHandle", this.env.driverKit.blobDriver.getOnDemandBlob(resource));
-    }
-    //
-    // Blobs to URLs
-    //
-    extractArchiveAndGetURL(handle, format) {
-        const resource = this.getAccessor(handle).persist();
-        return this.registerComputable("extractArchiveAndGetURL", this.env.driverKit.blobToURLDriver.extractArchiveAndGetURL(resource, format));
-    }
-    //
-    // Import progress
-    //
-    getImportProgress(handle) {
-        const resource = this.getAccessor(handle).persist();
-        return this.registerComputable("getImportProgress", this.env.driverKit.uploadDriver.getProgressId(resource));
-    }
-    //
-    // Logs
-    //
-    getLastLogs(handle, nLines) {
-        const resource = this.getAccessor(handle).persist();
-        return this.registerComputable("getLastLogs", this.env.driverKit.logDriver.getLastLogs(resource, nLines));
-    }
-    getProgressLog(handle, patternToSearch) {
-        const resource = this.getAccessor(handle).persist();
-        return this.registerComputable("getProgressLog", this.env.driverKit.logDriver.getProgressLog(resource, patternToSearch));
-    }
-    getProgressLogWithInfo(handle, patternToSearch) {
-        const resource = this.getAccessor(handle).persist();
-        return this.registerComputable("getProgressLogWithInfo", this.env.driverKit.logDriver.getProgressLogWithInfo(resource, patternToSearch));
-    }
-    getLogHandle(handle) {
-        const resource = this.getAccessor(handle).persist();
-        return this.registerComputable("getLogHandle", this.env.driverKit.logDriver.getLogHandle(resource));
-    }
-    //
-    // Blocks
-    //
-    getBlockLabel(blockId) {
-        const b = this.meta.get(blockId);
-        if (b === undefined)
-            throw new Error(`Block ${blockId} not found.`);
-        return b.label;
-    }
-    //
-    // Result Pool
-    //
-    _resultPool = undefined;
-    get resultPool() {
-        if (this._resultPool === undefined) {
-            if (this.computableCtx === undefined)
-                throw new Error("can't use result pool in this context (most porbably called from the future mapper)");
-            this._resultPool = notEmpty(this.blockCtx.getResultsPool, "getResultsPool")(this.computableCtx);
-        }
-        return this._resultPool;
-    }
-    calculateOptions(predicate) {
-        return this.resultPool.calculateOptions(predicate);
-    }
-    getDataFromResultPool() {
-        const collection = this.resultPool.getData();
-        if (collection.instabilityMarker !== undefined)
-            this.computableCtx.markUnstable(`incomplete_result_pool:${collection.instabilityMarker}`);
-        return {
-            isComplete: collection.isComplete,
-            entries: collection.entries.map((e) => ({
-                ref: e.ref,
-                obj: mapPObjectData(e.obj, (d) => this.wrapAccessor(d)),
-            })),
-        };
-    }
-    getDataWithErrorsFromResultPool() {
-        const collection = this.resultPool.getDataWithErrors();
-        if (collection.instabilityMarker !== undefined)
-            this.computableCtx.markUnstable(`incomplete_result_pool:${collection.instabilityMarker}`);
-        return {
-            isComplete: collection.isComplete,
-            entries: collection.entries.map((e) => ({
-                ref: e.ref,
-                obj: {
-                    id: e.obj.id,
-                    spec: e.obj.spec,
-                    data: mapValueInVOE(e.obj.data, (d) => this.wrapAccessor(d)),
-                },
-            })),
-        };
-    }
-    getSpecsFromResultPool() {
-        const specs = this.resultPool.getSpecs();
-        if (specs.instabilityMarker !== undefined)
-            this.computableCtx.markUnstable(`specs_from_pool_incomplete:${specs.instabilityMarker}`);
-        return specs;
-    }
-    getSpecFromResultPoolByRef(blockId, exportName) {
-        return this.resultPool.getSpecByRef(blockId, exportName);
-    }
-    getDataFromResultPoolByRef(blockId, exportName) {
-        return mapPObjectData(this.resultPool.getDataByRef(blockId, exportName), (acc) => this.wrapAccessor(acc));
-    }
-    //
-    // PFrames / PTables
-    //
-    createPFrame(def) {
-        if (this.computableCtx === undefined)
-            throw new Error("can't instantiate PFrames from this context (most porbably called from the future mapper)");
-        const { key, unref } = this.env.driverKit.pFrameDriver.createPFrame(def.map((c) => mapPObjectData(c, (d) => this.transformInputPData(d))));
-        this.computableCtx.addOnDestroy(unref);
-        return key;
-    }
-    createPTable(def) {
-        if (this.computableCtx === undefined)
-            throw new Error("can't instantiate PTable from this context (most porbably called from the future mapper)");
-        const { key, unref } = this.env.driverKit.pFrameDriver.createPTable(mapPTableDef(def, (c) => mapPObjectData(c, (d) => this.transformInputPData(d))));
-        this.computableCtx.addOnDestroy(unref);
-        return key;
-    }
-    createPTableV2(def) {
-        if (this.computableCtx === undefined)
-            throw new Error("can't instantiate PTable from this context (most porbably called from the future mapper)");
-        const { key, unref } = this.env.driverKit.pFrameDriver.createPTableV2(mapPTableDefV2(def, (c) => mapPObjectData(c, (d) => this.transformInputPData(d))));
-        this.computableCtx.addOnDestroy(unref);
-        return key;
-    }
-    /**
-     * Transforms input data for PFrame/PTable creation
-     * - Converts string handles to accessors
-     * - Maps accessors in DataInfo objects
-     * - Passes through other values
-     */
-    transformInputPData(d) {
-        if (typeof d === "string") {
-            return this.getAccessor(d);
-        }
-        else if (isDataInfo(d)) {
-            return mapDataInfo(d, (a) => this.getAccessor(a));
-        }
-        else {
-            return d;
-        }
-    }
-    //
-    // Computable
-    //
-    getCurrentUnstableMarker() {
-        return this.computableCtx?.unstableMarker;
-    }
-    //
-    // Logging
-    //
-    logInfo(message) {
-        this.env.blockEventDispatcher.logInfo(this.blockCtx.blockId, message);
-    }
-    logWarn(message) {
-        this.env.blockEventDispatcher.logWarn(this.blockCtx.blockId, message);
-    }
-    logError(message) {
-        this.env.blockEventDispatcher.logError(this.blockCtx.blockId, message);
-    }
-    //
-    // Helpers
-    //
-    getAccessor(handle) {
-        const accessor = this.accessors.get(handle);
-        if (accessor === undefined)
-            throw new Error("No such accessor");
-        return accessor;
-    }
-    wrapAccessor(accessor) {
-        if (accessor === undefined)
-            return undefined;
-        else {
-            const nextHandle = randomUUID();
-            this.accessors.set(nextHandle, accessor);
-            return nextHandle;
-        }
-    }
-    injectCtx(configCtx) {
-        const parent = this.parent;
-        const vm = parent.vm;
-        Scope.withScope((localScope) => {
-            // Exporting methods
-            const exportCtxFunction = (name, fn) => {
-                const withCachedError = (...args) => {
-                    // QuickJS strips all fields from errors apart from 'name' and 'message'.
-                    // That's why here we need to store them, and rethrow them when we exit
-                    // from QuickJS code.
-                    try {
-                        return fn(...args);
-                    }
-                    catch (e) {
-                        const newErr = parent.errorRepo.setAndRecreateForQuickJS(e);
-                        throw vm.newError(newErr);
-                    }
-                };
-                vm.newFunction(name, withCachedError).consume((fnh) => vm.setProp(configCtx, name, fnh));
-                vm.newFunction(name, fn).consume((fnh) => vm.setProp(configCtx, name + "__internal__", fnh));
-            };
-            // Check if this is a v1/v2 block (requiresModelAPIVersion !== 2)
-            // For v1/v2 blocks, state is {args, uiState} and we need to inject uiState separately
-            const isLegacyBlock = !checkBlockFlag(this.featureFlags, "requiresModelAPIVersion", 2);
-            // Helper to extract uiState from legacy state format {args, uiState}
-            const extractUiState = (stateJson) => {
-                if (!stateJson)
-                    return "{}";
-                try {
-                    const parsed = JSON.parse(stateJson);
-                    return JSON.stringify(parsed?.uiState ?? {});
-                }
-                catch {
-                    return "{}";
-                }
-            };
-            if (checkBlockFlag(this.featureFlags, "supportsLazyState")) {
-                // injecting lazy state functions
-                exportCtxFunction("args", () => {
-                    if (this.computableCtx === undefined)
-                        throw new Error(`Add dummy call to ctx.args outside the future lambda. Can't be directly used in this context.`);
-                    const args = this.blockCtx.args(this.computableCtx);
-                    return args === undefined ? vm.undefined : vm.newString(args);
-                });
-                exportCtxFunction("blockStorage", () => {
-                    if (this.computableCtx === undefined)
-                        throw new Error(`Add dummy call to ctx.blockStorage outside the future lambda. Can't be directly used in this context.`);
-                    return vm.newString(this.blockCtx.blockStorage(this.computableCtx) ?? "{}");
-                });
-                exportCtxFunction("data", () => {
-                    if (this.computableCtx === undefined)
-                        throw new Error(`Add dummy call to ctx.data outside the future lambda. Can't be directly used in this context.`);
-                    return vm.newString(this.blockCtx.data(this.computableCtx) ?? "{}");
-                });
-                exportCtxFunction("activeArgs", () => {
-                    if (this.computableCtx === undefined)
-                        throw new Error(`Add dummy call to ctx.activeArgs outside the future lambda. Can't be directly used in this context.`);
-                    const res = this.blockCtx.activeArgs(this.computableCtx);
-                    return res === undefined ? vm.undefined : vm.newString(res);
-                });
-                // For v1/v2 blocks, also inject uiState (extracted from state.uiState)
-                if (isLegacyBlock) {
-                    exportCtxFunction("uiState", () => {
-                        if (this.computableCtx === undefined)
-                            throw new Error(`Add dummy call to ctx.uiState outside the future lambda. Can't be directly used in this context.`);
-                        return vm.newString(extractUiState(this.blockCtx.data(this.computableCtx)));
-                    });
-                }
-            }
-            else {
-                const args = this.blockCtx.args(this.computableCtx);
-                const activeArgs = this.blockCtx.activeArgs(this.computableCtx);
-                const data = this.blockCtx.data(this.computableCtx);
-                if (args !== undefined) {
-                    vm.setProp(configCtx, "args", localScope.manage(vm.newString(args)));
-                }
-                vm.setProp(configCtx, "data", localScope.manage(vm.newString(data ?? "{}")));
-                if (activeArgs !== undefined)
-                    vm.setProp(configCtx, "activeArgs", localScope.manage(vm.newString(activeArgs)));
-                // For v1/v2 blocks, also inject uiState (extracted from state.uiState)
-                if (isLegacyBlock) {
-                    vm.setProp(configCtx, "uiState", localScope.manage(vm.newString(extractUiState(data))));
-                }
-            }
-            //
-            // Methods for injected ctx object
-            //
-            exportCtxFunction("getAccessorHandleByName", (name) => {
-                return parent.exportSingleValue(this.getAccessorHandleByName(vm.getString(name)), undefined);
-            });
-            //
-            // Accessors
-            //
-            exportCtxFunction("resolveWithCommon", (handle, commonOptions, ...steps) => {
-                return parent.exportSingleValue(this.resolveWithCommon(vm.getString(handle), parent.importObjectViaJson(commonOptions), ...steps.map((step) => parent.importObjectViaJson(step))), undefined);
-            });
-            exportCtxFunction("getResourceType", (handle) => {
-                return parent.exportObjectViaJson(this.getResourceType(vm.getString(handle)), undefined);
-            });
-            exportCtxFunction("getInputsLocked", (handle) => {
-                return parent.exportSingleValue(this.getInputsLocked(vm.getString(handle)), undefined);
-            });
-            exportCtxFunction("getOutputsLocked", (handle) => {
-                return parent.exportSingleValue(this.getOutputsLocked(vm.getString(handle)), undefined);
-            });
-            exportCtxFunction("getIsReadyOrError", (handle) => {
-                return parent.exportSingleValue(this.getIsReadyOrError(vm.getString(handle)), undefined);
-            });
-            exportCtxFunction("getIsFinal", (handle) => {
-                return parent.exportSingleValue(this.getIsFinal(vm.getString(handle)), undefined);
-            });
-            exportCtxFunction("getError", (handle) => {
-                return parent.exportSingleValue(this.getError(vm.getString(handle)), undefined);
-            });
-            exportCtxFunction("listInputFields", (handle) => {
-                return parent.exportObjectViaJson(this.listInputFields(vm.getString(handle)), undefined);
-            });
-            exportCtxFunction("listOutputFields", (handle) => {
-                return parent.exportObjectViaJson(this.listInputFields(vm.getString(handle)), undefined);
-            });
-            exportCtxFunction("listDynamicFields", (handle) => {
-                return parent.exportObjectViaJson(this.listInputFields(vm.getString(handle)), undefined);
-            });
-            exportCtxFunction("getKeyValueBase64", (handle, key) => {
-                return parent.exportSingleValue(this.getKeyValueBase64(vm.getString(handle), vm.getString(key)), undefined);
-            });
-            exportCtxFunction("getKeyValueAsString", (handle, key) => {
-                return parent.exportSingleValue(this.getKeyValueAsString(vm.getString(handle), vm.getString(key)), undefined);
-            });
-            exportCtxFunction("getDataBase64", (handle) => {
-                return parent.exportSingleValue(this.getDataBase64(vm.getString(handle)), undefined);
-            });
-            exportCtxFunction("getDataAsString", (handle) => {
-                return parent.exportSingleValue(this.getDataAsString(vm.getString(handle)), undefined);
-            });
-            //
-            // Accessor helpers
-            //
-            exportCtxFunction("parsePObjectCollection", (handle, errorOnUnknownField, prefix, ...resolveSteps) => {
-                return parent.exportObjectUniversal(this.parsePObjectCollection(vm.getString(handle), vm.dump(errorOnUnknownField), vm.getString(prefix), ...resolveSteps.map((stepHandle) => vm.getString(stepHandle))), undefined);
-            });
-            //
-            // Blobs
-            //
-            exportCtxFunction("getBlobContentAsBase64", (handle, range) => {
-                return parent.exportSingleValue(this.getBlobContentAsBase64(vm.getString(handle), parent.importObjectUniversal(range)), undefined);
-            });
-            exportCtxFunction("getBlobContentAsString", (handle, range) => {
-                return parent.exportSingleValue(this.getBlobContentAsString(vm.getString(handle), parent.importObjectUniversal(range)), undefined);
-            });
-            exportCtxFunction("getDownloadedBlobContentHandle", (handle) => {
-                return parent.exportSingleValue(this.getDownloadedBlobContentHandle(vm.getString(handle)), undefined);
-            });
-            exportCtxFunction("getOnDemandBlobContentHandle", (handle) => {
-                return parent.exportSingleValue(this.getOnDemandBlobContentHandle(vm.getString(handle)), undefined);
-            });
-            //
-            // Blobs to URLs
-            //
-            exportCtxFunction("extractArchiveAndGetURL", (handle, format) => {
-                return parent.exportSingleValue(this.extractArchiveAndGetURL(vm.getString(handle), vm.getString(format)), undefined);
-            });
-            //
-            // ImportProgress
-            //
-            exportCtxFunction("getImportProgress", (handle) => {
-                return parent.exportSingleValue(this.getImportProgress(vm.getString(handle)), undefined);
-            });
-            //
-            // Logs
-            //
-            exportCtxFunction("getLastLogs", (handle, nLines) => {
-                return parent.exportSingleValue(this.getLastLogs(vm.getString(handle), vm.getNumber(nLines)), undefined);
-            });
-            exportCtxFunction("getProgressLog", (handle, patternToSearch) => {
-                return parent.exportSingleValue(this.getProgressLog(vm.getString(handle), vm.getString(patternToSearch)), undefined);
-            });
-            exportCtxFunction("getProgressLogWithInfo", (handle, patternToSearch) => {
-                return parent.exportSingleValue(this.getProgressLogWithInfo(vm.getString(handle), vm.getString(patternToSearch)), undefined);
-            });
-            exportCtxFunction("getLogHandle", (handle) => {
-                return parent.exportSingleValue(this.getLogHandle(vm.getString(handle)), undefined);
-            });
-            //
-            // Blocks
-            //
-            exportCtxFunction("getBlockLabel", (blockId) => {
-                return parent.exportSingleValue(this.getBlockLabel(vm.getString(blockId)), undefined);
-            });
-            //
-            // Result pool
-            //
-            exportCtxFunction("getDataFromResultPool", () => {
-                return parent.exportObjectUniversal(this.getDataFromResultPool(), undefined);
-            });
-            exportCtxFunction("getDataWithErrorsFromResultPool", () => {
-                return parent.exportObjectUniversal(this.getDataWithErrorsFromResultPool(), undefined);
-            });
-            exportCtxFunction("getSpecsFromResultPool", () => {
-                return parent.exportObjectUniversal(this.getSpecsFromResultPool(), undefined);
-            });
-            exportCtxFunction("calculateOptions", (predicate) => {
-                return parent.exportObjectUniversal(this.calculateOptions(parent.importObjectViaJson(predicate)), undefined);
-            });
-            exportCtxFunction("getSpecFromResultPoolByRef", (blockId, exportName) => {
-                return parent.exportObjectUniversal(this.getSpecFromResultPoolByRef(vm.getString(blockId), vm.getString(exportName)), undefined);
-            });
-            exportCtxFunction("getDataFromResultPoolByRef", (blockId, exportName) => {
-                return parent.exportObjectUniversal(this.getDataFromResultPoolByRef(vm.getString(blockId), vm.getString(exportName)), undefined);
-            });
-            //
-            // PFrames / PTables
-            //
-            exportCtxFunction("createPFrame", (def) => {
-                return parent.exportSingleValue(this.createPFrame(parent.importObjectViaJson(def)), undefined);
-            });
-            exportCtxFunction("createPTable", (def) => {
-                return parent.exportSingleValue(this.createPTable(parent.importObjectViaJson(def)), undefined);
-            });
-            exportCtxFunction("createPTableV2", (def) => {
-                return parent.exportSingleValue(this.createPTableV2(parent.importObjectViaJson(def)), undefined);
-            });
-            //
-            // Computable
-            //
-            exportCtxFunction("getCurrentUnstableMarker", () => {
-                return parent.exportSingleValue(this.getCurrentUnstableMarker(), undefined);
-            });
-            //
-            // Logging
-            //
-            exportCtxFunction("logInfo", (message) => {
-                this.logInfo(vm.getString(message));
-            });
-            exportCtxFunction("logWarn", (message) => {
-                this.logWarn(vm.getString(message));
-            });
-            exportCtxFunction("logError", (message) => {
-                this.logError(vm.getString(message));
-            });
-        });
-    }
+	return data !== void 0 ? Buffer.from(data).toString("base64") : void 0;
 }
+var ComputableContextHelper = class {
+	computablesToResolve = {};
+	computableCtx;
+	accessors = /* @__PURE__ */ new Map();
+	meta;
+	constructor(parent, blockCtx, env, featureFlags, computableCtx) {
+		this.parent = parent;
+		this.blockCtx = blockCtx;
+		this.env = env;
+		this.featureFlags = featureFlags;
+		this.computableCtx = computableCtx;
+		this.meta = blockCtx.blockMeta(computableCtx);
+	}
+	resetComputableCtx() {
+		this.computableCtx = void 0;
+		this.accessors.clear();
+	}
+	getAccessorHandleByName(name) {
+		if (this.computableCtx === void 0) throw new Error("Accessors can't be used in this context");
+		const wellKnownAccessor = (name, ctxKey) => {
+			if (!this.accessors.has(name)) {
+				const lambda = this.blockCtx[ctxKey];
+				if (lambda === void 0) throw new Error("Staging context not available");
+				const entry = lambda(this.computableCtx);
+				if (!entry) this.accessors.set(name, void 0);
+				else this.accessors.set(name, this.computableCtx.accessor(entry).node({ ignoreError: true }));
+			}
+			return this.accessors.get(name) ? name : void 0;
+		};
+		if (name === "staging") return wellKnownAccessor("staging", "staging");
+		else if (name === "main") return wellKnownAccessor("main", "prod");
+	}
+	resolveWithCommon(handle, commonOptions, ...steps) {
+		return this.wrapAccessor(this.getAccessor(handle).traverseWithCommon(commonOptions, ...steps));
+	}
+	getResourceType(handle) {
+		return this.getAccessor(handle).resourceType;
+	}
+	getInputsLocked(handle) {
+		return this.getAccessor(handle).getInputsLocked();
+	}
+	getOutputsLocked(handle) {
+		return this.getAccessor(handle).getOutputsLocked();
+	}
+	getIsReadyOrError(handle) {
+		return this.getAccessor(handle).getIsReadyOrError();
+	}
+	getIsFinal(handle) {
+		return this.getAccessor(handle).getIsFinal();
+	}
+	getError(handle) {
+		return this.wrapAccessor(this.getAccessor(handle).getError());
+	}
+	listInputFields(handle) {
+		return this.getAccessor(handle).listInputFields();
+	}
+	listOutputFields(handle) {
+		return this.getAccessor(handle).listOutputFields();
+	}
+	listDynamicFields(handle) {
+		return this.getAccessor(handle).listDynamicFields();
+	}
+	getKeyValueBase64(handle, key) {
+		return bytesToBase64(this.getAccessor(handle).getKeyValue(key));
+	}
+	getKeyValueAsString(handle, key) {
+		return this.getAccessor(handle).getKeyValueAsString(key);
+	}
+	getDataBase64(handle) {
+		return bytesToBase64(this.getAccessor(handle).getData());
+	}
+	getDataAsString(handle) {
+		return this.getAccessor(handle).getDataAsString();
+	}
+	parsePObjectCollection(handle, errorOnUnknownField, prefix, ...resolveSteps) {
+		const acc = this.getAccessor(handle);
+		if (!acc.getIsReadyOrError()) return void 0;
+		const accResult = parseFinalPObjectCollection(acc, errorOnUnknownField, prefix, resolveSteps);
+		const result = {};
+		for (const [key, obj] of Object.entries(accResult)) result[key] = mapPObjectData(obj, (d) => this.wrapAccessor(d));
+		return result;
+	}
+	registerComputable(hPrefix, computable) {
+		const fHandle = `${hPrefix}_${randomUUID()}`;
+		this.computablesToResolve[fHandle] = computable;
+		return fHandle;
+	}
+	getBlobContentAsString(handle, range) {
+		const resourceInfo = this.getAccessor(handle).resourceInfo;
+		return this.registerComputable("getBlobContentAsString", Computable.make((ctx) => this.env.driverKit.blobDriver.getDownloadedBlob(resourceInfo, ctx), { postprocessValue: async (value) => {
+			if (value === void 0) return void 0;
+			return Buffer.from(await this.env.driverKit.blobDriver.getContent(value.handle, range)).toString("utf-8");
+		} }));
+	}
+	getBlobContentAsBase64(handle, range) {
+		const resourceInfo = this.getAccessor(handle).resourceInfo;
+		return this.registerComputable("getBlobContentAsBase64", Computable.make((ctx) => this.env.driverKit.blobDriver.getDownloadedBlob(resourceInfo, ctx), { postprocessValue: async (value) => {
+			if (value === void 0) return void 0;
+			return Buffer.from(await this.env.driverKit.blobDriver.getContent(value.handle, range)).toString("base64");
+		} }));
+	}
+	getDownloadedBlobContentHandle(handle) {
+		const resourceInfo = this.getAccessor(handle).resourceInfo;
+		return this.registerComputable("getDownloadedBlobContentHandle", this.env.driverKit.blobDriver.getDownloadedBlob(resourceInfo));
+	}
+	getOnDemandBlobContentHandle(handle) {
+		const resource = this.getAccessor(handle).persist();
+		return this.registerComputable("getOnDemandBlobContentHandle", this.env.driverKit.blobDriver.getOnDemandBlob(resource));
+	}
+	extractArchiveAndGetURL(handle, format) {
+		const resource = this.getAccessor(handle).persist();
+		return this.registerComputable("extractArchiveAndGetURL", this.env.driverKit.blobToURLDriver.extractArchiveAndGetURL(resource, format));
+	}
+	getImportProgress(handle) {
+		const resource = this.getAccessor(handle).persist();
+		return this.registerComputable("getImportProgress", this.env.driverKit.uploadDriver.getProgressId(resource));
+	}
+	getLastLogs(handle, nLines) {
+		const resource = this.getAccessor(handle).persist();
+		return this.registerComputable("getLastLogs", this.env.driverKit.logDriver.getLastLogs(resource, nLines));
+	}
+	getProgressLog(handle, patternToSearch) {
+		const resource = this.getAccessor(handle).persist();
+		return this.registerComputable("getProgressLog", this.env.driverKit.logDriver.getProgressLog(resource, patternToSearch));
+	}
+	getProgressLogWithInfo(handle, patternToSearch) {
+		const resource = this.getAccessor(handle).persist();
+		return this.registerComputable("getProgressLogWithInfo", this.env.driverKit.logDriver.getProgressLogWithInfo(resource, patternToSearch));
+	}
+	getLogHandle(handle) {
+		const resource = this.getAccessor(handle).persist();
+		return this.registerComputable("getLogHandle", this.env.driverKit.logDriver.getLogHandle(resource));
+	}
+	getBlockLabel(blockId) {
+		const b = this.meta.get(blockId);
+		if (b === void 0) throw new Error(`Block ${blockId} not found.`);
+		return b.label;
+	}
+	_resultPool = void 0;
+	get resultPool() {
+		if (this._resultPool === void 0) {
+			if (this.computableCtx === void 0) throw new Error("can't use result pool in this context (most porbably called from the future mapper)");
+			this._resultPool = notEmpty(this.blockCtx.getResultsPool, "getResultsPool")(this.computableCtx);
+		}
+		return this._resultPool;
+	}
+	calculateOptions(predicate) {
+		return this.resultPool.calculateOptions(predicate);
+	}
+	getDataFromResultPool() {
+		const collection = this.resultPool.getData();
+		if (collection.instabilityMarker !== void 0) this.computableCtx.markUnstable(`incomplete_result_pool:${collection.instabilityMarker}`);
+		return {
+			isComplete: collection.isComplete,
+			entries: collection.entries.map((e) => ({
+				ref: e.ref,
+				obj: mapPObjectData(e.obj, (d) => this.wrapAccessor(d))
+			}))
+		};
+	}
+	getDataWithErrorsFromResultPool() {
+		const collection = this.resultPool.getDataWithErrors();
+		if (collection.instabilityMarker !== void 0) this.computableCtx.markUnstable(`incomplete_result_pool:${collection.instabilityMarker}`);
+		return {
+			isComplete: collection.isComplete,
+			entries: collection.entries.map((e) => ({
+				ref: e.ref,
+				obj: {
+					id: e.obj.id,
+					spec: e.obj.spec,
+					data: mapValueInVOE(e.obj.data, (d) => this.wrapAccessor(d))
+				}
+			}))
+		};
+	}
+	getSpecsFromResultPool() {
+		const specs = this.resultPool.getSpecs();
+		if (specs.instabilityMarker !== void 0) this.computableCtx.markUnstable(`specs_from_pool_incomplete:${specs.instabilityMarker}`);
+		return specs;
+	}
+	getSpecFromResultPoolByRef(blockId, exportName) {
+		return this.resultPool.getSpecByRef(blockId, exportName);
+	}
+	getDataFromResultPoolByRef(blockId, exportName) {
+		return mapPObjectData(this.resultPool.getDataByRef(blockId, exportName), (acc) => this.wrapAccessor(acc));
+	}
+	createPFrame(def) {
+		if (this.computableCtx === void 0) throw new Error("can't instantiate PFrames from this context (most porbably called from the future mapper)");
+		const { key, unref } = this.env.driverKit.pFrameDriver.createPFrame(def.map((c) => mapPObjectData(c, (d) => this.transformInputPData(d))));
+		this.computableCtx.addOnDestroy(unref);
+		return key;
+	}
+	createPTable(def) {
+		if (this.computableCtx === void 0) throw new Error("can't instantiate PTable from this context (most porbably called from the future mapper)");
+		const { key, unref } = this.env.driverKit.pFrameDriver.createPTable(mapPTableDef(def, (c) => mapPObjectData(c, (d) => this.transformInputPData(d))));
+		this.computableCtx.addOnDestroy(unref);
+		return key;
+	}
+	createPTableV2(def) {
+		if (this.computableCtx === void 0) throw new Error("can't instantiate PTable from this context (most porbably called from the future mapper)");
+		const { key, unref } = this.env.driverKit.pFrameDriver.createPTableV2(mapPTableDefV2(def, (c) => mapPObjectData(c, (d) => this.transformInputPData(d))));
+		this.computableCtx.addOnDestroy(unref);
+		return key;
+	}
+	/**
+	* Transforms input data for PFrame/PTable creation
+	* - Converts string handles to accessors
+	* - Maps accessors in DataInfo objects
+	* - Passes through other values
+	*/
+	transformInputPData(d) {
+		if (typeof d === "string") return this.getAccessor(d);
+		else if (isDataInfo(d)) return mapDataInfo(d, (a) => this.getAccessor(a));
+		else return d;
+	}
+	getCurrentUnstableMarker() {
+		return this.computableCtx?.unstableMarker;
+	}
+	logInfo(message) {
+		this.env.blockEventDispatcher.logInfo(this.blockCtx.blockId, message);
+	}
+	logWarn(message) {
+		this.env.blockEventDispatcher.logWarn(this.blockCtx.blockId, message);
+	}
+	logError(message) {
+		this.env.blockEventDispatcher.logError(this.blockCtx.blockId, message);
+	}
+	getAccessor(handle) {
+		const accessor = this.accessors.get(handle);
+		if (accessor === void 0) throw new Error("No such accessor");
+		return accessor;
+	}
+	wrapAccessor(accessor) {
+		if (accessor === void 0) return void 0;
+		else {
+			const nextHandle = randomUUID();
+			this.accessors.set(nextHandle, accessor);
+			return nextHandle;
+		}
+	}
+	injectCtx(configCtx) {
+		const parent = this.parent;
+		const vm = parent.vm;
+		Scope.withScope((localScope) => {
+			const exportCtxFunction = (name, fn) => {
+				const withCachedError = (...args) => {
+					try {
+						return fn(...args);
+					} catch (e) {
+						const newErr = parent.errorRepo.setAndRecreateForQuickJS(e);
+						throw vm.newError(newErr);
+					}
+				};
+				vm.newFunction(name, withCachedError).consume((fnh) => vm.setProp(configCtx, name, fnh));
+				vm.newFunction(name, fn).consume((fnh) => vm.setProp(configCtx, name + "__internal__", fnh));
+			};
+			const isLegacyBlock = !checkBlockFlag(this.featureFlags, "requiresModelAPIVersion", 2);
+			const extractUiState = (stateJson) => {
+				if (!stateJson) return "{}";
+				try {
+					const parsed = JSON.parse(stateJson);
+					return JSON.stringify(parsed?.uiState ?? {});
+				} catch {
+					return "{}";
+				}
+			};
+			if (checkBlockFlag(this.featureFlags, "supportsLazyState")) {
+				exportCtxFunction("args", () => {
+					if (this.computableCtx === void 0) throw new Error(`Add dummy call to ctx.args outside the future lambda. Can't be directly used in this context.`);
+					const args = this.blockCtx.args(this.computableCtx);
+					return args === void 0 ? vm.undefined : vm.newString(args);
+				});
+				exportCtxFunction("blockStorage", () => {
+					if (this.computableCtx === void 0) throw new Error(`Add dummy call to ctx.blockStorage outside the future lambda. Can't be directly used in this context.`);
+					return vm.newString(this.blockCtx.blockStorage(this.computableCtx) ?? "{}");
+				});
+				exportCtxFunction("data", () => {
+					if (this.computableCtx === void 0) throw new Error(`Add dummy call to ctx.data outside the future lambda. Can't be directly used in this context.`);
+					return vm.newString(this.blockCtx.data(this.computableCtx) ?? "{}");
+				});
+				exportCtxFunction("activeArgs", () => {
+					if (this.computableCtx === void 0) throw new Error(`Add dummy call to ctx.activeArgs outside the future lambda. Can't be directly used in this context.`);
+					const res = this.blockCtx.activeArgs(this.computableCtx);
+					return res === void 0 ? vm.undefined : vm.newString(res);
+				});
+				if (isLegacyBlock) exportCtxFunction("uiState", () => {
+					if (this.computableCtx === void 0) throw new Error(`Add dummy call to ctx.uiState outside the future lambda. Can't be directly used in this context.`);
+					return vm.newString(extractUiState(this.blockCtx.data(this.computableCtx)));
+				});
+			} else {
+				const args = this.blockCtx.args(this.computableCtx);
+				const activeArgs = this.blockCtx.activeArgs(this.computableCtx);
+				const data = this.blockCtx.data(this.computableCtx);
+				if (args !== void 0) vm.setProp(configCtx, "args", localScope.manage(vm.newString(args)));
+				vm.setProp(configCtx, "data", localScope.manage(vm.newString(data ?? "{}")));
+				if (activeArgs !== void 0) vm.setProp(configCtx, "activeArgs", localScope.manage(vm.newString(activeArgs)));
+				if (isLegacyBlock) vm.setProp(configCtx, "uiState", localScope.manage(vm.newString(extractUiState(data))));
+			}
+			exportCtxFunction("getAccessorHandleByName", (name) => {
+				return parent.exportSingleValue(this.getAccessorHandleByName(vm.getString(name)), void 0);
+			});
+			exportCtxFunction("resolveWithCommon", (handle, commonOptions, ...steps) => {
+				return parent.exportSingleValue(this.resolveWithCommon(vm.getString(handle), parent.importObjectViaJson(commonOptions), ...steps.map((step) => parent.importObjectViaJson(step))), void 0);
+			});
+			exportCtxFunction("getResourceType", (handle) => {
+				return parent.exportObjectViaJson(this.getResourceType(vm.getString(handle)), void 0);
+			});
+			exportCtxFunction("getInputsLocked", (handle) => {
+				return parent.exportSingleValue(this.getInputsLocked(vm.getString(handle)), void 0);
+			});
+			exportCtxFunction("getOutputsLocked", (handle) => {
+				return parent.exportSingleValue(this.getOutputsLocked(vm.getString(handle)), void 0);
+			});
+			exportCtxFunction("getIsReadyOrError", (handle) => {
+				return parent.exportSingleValue(this.getIsReadyOrError(vm.getString(handle)), void 0);
+			});
+			exportCtxFunction("getIsFinal", (handle) => {
+				return parent.exportSingleValue(this.getIsFinal(vm.getString(handle)), void 0);
+			});
+			exportCtxFunction("getError", (handle) => {
+				return parent.exportSingleValue(this.getError(vm.getString(handle)), void 0);
+			});
+			exportCtxFunction("listInputFields", (handle) => {
+				return parent.exportObjectViaJson(this.listInputFields(vm.getString(handle)), void 0);
+			});
+			exportCtxFunction("listOutputFields", (handle) => {
+				return parent.exportObjectViaJson(this.listInputFields(vm.getString(handle)), void 0);
+			});
+			exportCtxFunction("listDynamicFields", (handle) => {
+				return parent.exportObjectViaJson(this.listInputFields(vm.getString(handle)), void 0);
+			});
+			exportCtxFunction("getKeyValueBase64", (handle, key) => {
+				return parent.exportSingleValue(this.getKeyValueBase64(vm.getString(handle), vm.getString(key)), void 0);
+			});
+			exportCtxFunction("getKeyValueAsString", (handle, key) => {
+				return parent.exportSingleValue(this.getKeyValueAsString(vm.getString(handle), vm.getString(key)), void 0);
+			});
+			exportCtxFunction("getDataBase64", (handle) => {
+				return parent.exportSingleValue(this.getDataBase64(vm.getString(handle)), void 0);
+			});
+			exportCtxFunction("getDataAsString", (handle) => {
+				return parent.exportSingleValue(this.getDataAsString(vm.getString(handle)), void 0);
+			});
+			exportCtxFunction("parsePObjectCollection", (handle, errorOnUnknownField, prefix, ...resolveSteps) => {
+				return parent.exportObjectUniversal(this.parsePObjectCollection(vm.getString(handle), vm.dump(errorOnUnknownField), vm.getString(prefix), ...resolveSteps.map((stepHandle) => vm.getString(stepHandle))), void 0);
+			});
+			exportCtxFunction("getBlobContentAsBase64", (handle, range) => {
+				return parent.exportSingleValue(this.getBlobContentAsBase64(vm.getString(handle), parent.importObjectUniversal(range)), void 0);
+			});
+			exportCtxFunction("getBlobContentAsString", (handle, range) => {
+				return parent.exportSingleValue(this.getBlobContentAsString(vm.getString(handle), parent.importObjectUniversal(range)), void 0);
+			});
+			exportCtxFunction("getDownloadedBlobContentHandle", (handle) => {
+				return parent.exportSingleValue(this.getDownloadedBlobContentHandle(vm.getString(handle)), void 0);
+			});
+			exportCtxFunction("getOnDemandBlobContentHandle", (handle) => {
+				return parent.exportSingleValue(this.getOnDemandBlobContentHandle(vm.getString(handle)), void 0);
+			});
+			exportCtxFunction("extractArchiveAndGetURL", (handle, format) => {
+				return parent.exportSingleValue(this.extractArchiveAndGetURL(vm.getString(handle), vm.getString(format)), void 0);
+			});
+			exportCtxFunction("getImportProgress", (handle) => {
+				return parent.exportSingleValue(this.getImportProgress(vm.getString(handle)), void 0);
+			});
+			exportCtxFunction("getLastLogs", (handle, nLines) => {
+				return parent.exportSingleValue(this.getLastLogs(vm.getString(handle), vm.getNumber(nLines)), void 0);
+			});
+			exportCtxFunction("getProgressLog", (handle, patternToSearch) => {
+				return parent.exportSingleValue(this.getProgressLog(vm.getString(handle), vm.getString(patternToSearch)), void 0);
+			});
+			exportCtxFunction("getProgressLogWithInfo", (handle, patternToSearch) => {
+				return parent.exportSingleValue(this.getProgressLogWithInfo(vm.getString(handle), vm.getString(patternToSearch)), void 0);
+			});
+			exportCtxFunction("getLogHandle", (handle) => {
+				return parent.exportSingleValue(this.getLogHandle(vm.getString(handle)), void 0);
+			});
+			exportCtxFunction("getBlockLabel", (blockId) => {
+				return parent.exportSingleValue(this.getBlockLabel(vm.getString(blockId)), void 0);
+			});
+			exportCtxFunction("getDataFromResultPool", () => {
+				return parent.exportObjectUniversal(this.getDataFromResultPool(), void 0);
+			});
+			exportCtxFunction("getDataWithErrorsFromResultPool", () => {
+				return parent.exportObjectUniversal(this.getDataWithErrorsFromResultPool(), void 0);
+			});
+			exportCtxFunction("getSpecsFromResultPool", () => {
+				return parent.exportObjectUniversal(this.getSpecsFromResultPool(), void 0);
+			});
+			exportCtxFunction("calculateOptions", (predicate) => {
+				return parent.exportObjectUniversal(this.calculateOptions(parent.importObjectViaJson(predicate)), void 0);
+			});
+			exportCtxFunction("getSpecFromResultPoolByRef", (blockId, exportName) => {
+				return parent.exportObjectUniversal(this.getSpecFromResultPoolByRef(vm.getString(blockId), vm.getString(exportName)), void 0);
+			});
+			exportCtxFunction("getDataFromResultPoolByRef", (blockId, exportName) => {
+				return parent.exportObjectUniversal(this.getDataFromResultPoolByRef(vm.getString(blockId), vm.getString(exportName)), void 0);
+			});
+			exportCtxFunction("createPFrame", (def) => {
+				return parent.exportSingleValue(this.createPFrame(parent.importObjectViaJson(def)), void 0);
+			});
+			exportCtxFunction("createPTable", (def) => {
+				return parent.exportSingleValue(this.createPTable(parent.importObjectViaJson(def)), void 0);
+			});
+			exportCtxFunction("createPTableV2", (def) => {
+				return parent.exportSingleValue(this.createPTableV2(parent.importObjectViaJson(def)), void 0);
+			});
+			exportCtxFunction("getCurrentUnstableMarker", () => {
+				return parent.exportSingleValue(this.getCurrentUnstableMarker(), void 0);
+			});
+			exportCtxFunction("logInfo", (message) => {
+				this.logInfo(vm.getString(message));
+			});
+			exportCtxFunction("logWarn", (message) => {
+				this.logWarn(vm.getString(message));
+			});
+			exportCtxFunction("logError", (message) => {
+				this.logError(vm.getString(message));
+			});
+		});
+	}
+};
 
+//#endregion
 export { ComputableContextHelper };
-//# sourceMappingURL=computable_context.js.map
+//# sourceMappingURL=computable_context.js.map