@milaboratories/pl-client 2.17.6 → 2.17.8

package/dist/core/transaction.cjs

@@ -1,678 +1,641 @@
-'use strict';
-
-var tslib_es6 = require('../__external/.pnpm/@rollup_plugin-typescript@12.3.0_rollup@4.52.4_tslib@2.8.1_typescript@5.6.3/__external/tslib/tslib.es6.cjs');
-var types = require('./types.cjs');
-var api = require('../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api.cjs');
-var util = require('../util/util.cjs');
-var type_conversion = require('./type_conversion.cjs');
-var tsHelpers = require('@milaboratories/ts-helpers');
-var errors = require('./errors.cjs');
-var stat = require('./stat.cjs');
-var error_resource = require('./error_resource.cjs');
-var pl = require('../helpers/pl.cjs');
-var PromiseTracker = require('./PromiseTracker.cjs');
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+const require_types = require('./types.cjs');
+const require_api = require('../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api.cjs');
+const require_util = require('../util/util.cjs');
+const require_errors = require('./errors.cjs');
+const require_type_conversion = require('./type_conversion.cjs');
+const require_stat = require('./stat.cjs');
+const require_error_resource = require('./error_resource.cjs');
+const require_PromiseTracker = require('./PromiseTracker.cjs');
+const require_pl = require('../helpers/pl.cjs');
+let _milaboratories_ts_helpers = require("@milaboratories/ts-helpers");
 
+//#region src/core/transaction.ts
 function isField(ref) {
-    return ref.hasOwnProperty("resourceId") && ref.hasOwnProperty("fieldName");
+	return ref.hasOwnProperty("resourceId") && ref.hasOwnProperty("fieldName");
 }
 function isResource(ref) {
-    return (typeof ref === "bigint" || (ref.hasOwnProperty("globalId") && ref.hasOwnProperty("localId")));
+	return typeof ref === "bigint" || ref.hasOwnProperty("globalId") && ref.hasOwnProperty("localId");
 }
 function isResourceId(ref) {
-    return typeof ref === "bigint" && !types.isLocalResourceId(ref) && !types.isNullResourceId(ref);
+	return typeof ref === "bigint" && !require_types.isLocalResourceId(ref) && !require_types.isNullResourceId(ref);
 }
 function isFieldRef(ref) {
-    return isResourceRef(ref.resourceId);
+	return isResourceRef(ref.resourceId);
 }
 function isResourceRef(ref) {
-    return ref.hasOwnProperty("globalId") && ref.hasOwnProperty("localId");
+	return ref.hasOwnProperty("globalId") && ref.hasOwnProperty("localId");
 }
 function toFieldId(ref) {
-    if (isFieldRef(ref))
-        return { resourceId: ref.resourceId.localId, fieldName: ref.fieldName };
-    else
-        return ref;
+	if (isFieldRef(ref)) return {
+		resourceId: ref.resourceId.localId,
+		fieldName: ref.fieldName
+	};
+	else return ref;
 }
 async function toGlobalFieldId(ref) {
-    if (isFieldRef(ref))
-        return { resourceId: await ref.resourceId.globalId, fieldName: ref.fieldName };
-    else
-        return ref;
+	if (isFieldRef(ref)) return {
+		resourceId: await ref.resourceId.globalId,
+		fieldName: ref.fieldName
+	};
+	else return ref;
 }
 function toResourceId(ref) {
-    if (isResourceRef(ref))
-        return ref.localId;
-    else
-        return ref;
+	if (isResourceRef(ref)) return ref.localId;
+	else return ref;
 }
 async function toGlobalResourceId(ref) {
-    if (isResourceRef(ref))
-        return await ref.globalId;
-    else
-        return ref;
+	if (isResourceRef(ref)) return await ref.globalId;
+	else return ref;
 }
 function field(resourceId, fieldName) {
-    return { resourceId, fieldName };
+	return {
+		resourceId,
+		fieldName
+	};
 }
 /** If transaction commit failed due to write conflicts */
-class TxCommitConflict extends Error {
-    name = "TxCommitConflict";
-}
+var TxCommitConflict = class extends Error {
+	name = "TxCommitConflict";
+};
 async function notFoundToUndefined(cb) {
-    try {
-        return await cb();
-    }
-    catch (e) {
-        if (errors.isNotFoundError(e))
-            return undefined;
-        throw e;
-    }
-}
-/**
- * Decorator that wraps the method's returned promise with this.track()
- * This ensures that the promise will be awaited before the transaction is completed.
- */
-function tracked(value, _context) {
-    return function (...args) {
-        return this.track(value.apply(this, args));
-    };
+	try {
+		return await cb();
+	} catch (e) {
+		if (require_errors.isNotFoundError(e)) return void 0;
+		throw e;
+	}
 }
 /**
- * Each platform transaction has 3 stages:
- *   - initialization (txOpen message -> txInfo response)
- *   - communication (create resources, fields, references and so on)
- *   - finalization (txCommit or txDiscard message)
- *
- * This class encapsulates finalization stage and provides ready-to-communication transaction object.
- * */
-let PlTransaction = (() => {
-    let _instanceExtraInitializers = [];
-    let _getResourceData_decorators;
-    let _getResourceDataIfExists_decorators;
-    let _getFieldIfExists_decorators;
-    let _listKeyValues_decorators;
-    let _listKeyValuesString_decorators;
-    let _listKeyValuesIfResourceExists_decorators;
-    let _listKeyValuesStringIfResourceExists_decorators;
-    let _getKValue_decorators;
-    let _getKValueString_decorators;
-    let _getKValueJson_decorators;
-    let _getKValueIfExists_decorators;
-    let _getKValueStringIfExists_decorators;
-    let _getKValueJsonIfExists_decorators;
-    return class PlTransaction {
-        static {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _getResourceData_decorators = [tracked];
-            _getResourceDataIfExists_decorators = [tracked];
-            _getFieldIfExists_decorators = [tracked];
-            _listKeyValues_decorators = [tracked];
-            _listKeyValuesString_decorators = [tracked];
-            _listKeyValuesIfResourceExists_decorators = [tracked];
-            _listKeyValuesStringIfResourceExists_decorators = [tracked];
-            _getKValue_decorators = [tracked];
-            _getKValueString_decorators = [tracked];
-            _getKValueJson_decorators = [tracked];
-            _getKValueIfExists_decorators = [tracked];
-            _getKValueStringIfExists_decorators = [tracked];
-            _getKValueJsonIfExists_decorators = [tracked];
-            tslib_es6.__esDecorate(this, null, _getResourceData_decorators, { kind: "method", name: "getResourceData", static: false, private: false, access: { has: obj => "getResourceData" in obj, get: obj => obj.getResourceData }, metadata: _metadata }, null, _instanceExtraInitializers);
-            tslib_es6.__esDecorate(this, null, _getResourceDataIfExists_decorators, { kind: "method", name: "getResourceDataIfExists", static: false, private: false, access: { has: obj => "getResourceDataIfExists" in obj, get: obj => obj.getResourceDataIfExists }, metadata: _metadata }, null, _instanceExtraInitializers);
-            tslib_es6.__esDecorate(this, null, _getFieldIfExists_decorators, { kind: "method", name: "getFieldIfExists", static: false, private: false, access: { has: obj => "getFieldIfExists" in obj, get: obj => obj.getFieldIfExists }, metadata: _metadata }, null, _instanceExtraInitializers);
-            tslib_es6.__esDecorate(this, null, _listKeyValues_decorators, { kind: "method", name: "listKeyValues", static: false, private: false, access: { has: obj => "listKeyValues" in obj, get: obj => obj.listKeyValues }, metadata: _metadata }, null, _instanceExtraInitializers);
-            tslib_es6.__esDecorate(this, null, _listKeyValuesString_decorators, { kind: "method", name: "listKeyValuesString", static: false, private: false, access: { has: obj => "listKeyValuesString" in obj, get: obj => obj.listKeyValuesString }, metadata: _metadata }, null, _instanceExtraInitializers);
-            tslib_es6.__esDecorate(this, null, _listKeyValuesIfResourceExists_decorators, { kind: "method", name: "listKeyValuesIfResourceExists", static: false, private: false, access: { has: obj => "listKeyValuesIfResourceExists" in obj, get: obj => obj.listKeyValuesIfResourceExists }, metadata: _metadata }, null, _instanceExtraInitializers);
-            tslib_es6.__esDecorate(this, null, _listKeyValuesStringIfResourceExists_decorators, { kind: "method", name: "listKeyValuesStringIfResourceExists", static: false, private: false, access: { has: obj => "listKeyValuesStringIfResourceExists" in obj, get: obj => obj.listKeyValuesStringIfResourceExists }, metadata: _metadata }, null, _instanceExtraInitializers);
-            tslib_es6.__esDecorate(this, null, _getKValue_decorators, { kind: "method", name: "getKValue", static: false, private: false, access: { has: obj => "getKValue" in obj, get: obj => obj.getKValue }, metadata: _metadata }, null, _instanceExtraInitializers);
-            tslib_es6.__esDecorate(this, null, _getKValueString_decorators, { kind: "method", name: "getKValueString", static: false, private: false, access: { has: obj => "getKValueString" in obj, get: obj => obj.getKValueString }, metadata: _metadata }, null, _instanceExtraInitializers);
-            tslib_es6.__esDecorate(this, null, _getKValueJson_decorators, { kind: "method", name: "getKValueJson", static: false, private: false, access: { has: obj => "getKValueJson" in obj, get: obj => obj.getKValueJson }, metadata: _metadata }, null, _instanceExtraInitializers);
-            tslib_es6.__esDecorate(this, null, _getKValueIfExists_decorators, { kind: "method", name: "getKValueIfExists", static: false, private: false, access: { has: obj => "getKValueIfExists" in obj, get: obj => obj.getKValueIfExists }, metadata: _metadata }, null, _instanceExtraInitializers);
-            tslib_es6.__esDecorate(this, null, _getKValueStringIfExists_decorators, { kind: "method", name: "getKValueStringIfExists", static: false, private: false, access: { has: obj => "getKValueStringIfExists" in obj, get: obj => obj.getKValueStringIfExists }, metadata: _metadata }, null, _instanceExtraInitializers);
-            tslib_es6.__esDecorate(this, null, _getKValueJsonIfExists_decorators, { kind: "method", name: "getKValueJsonIfExists", static: false, private: false, access: { has: obj => "getKValueJsonIfExists" in obj, get: obj => obj.getKValueJsonIfExists }, metadata: _metadata }, null, _instanceExtraInitializers);
-            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        }
-        ll = tslib_es6.__runInitializers(this, _instanceExtraInitializers);
-        name;
-        writable;
-        _clientRoot;
-        finalPredicate;
-        sharedResourceDataCache;
-        enableFormattedErrors;
-        globalTxId;
-        localTxId = PlTransaction.nextLocalTxId();
-        /** Used in caching */
-        txOpenTimestamp = Date.now();
-        localResourceIdCounter = 0;
-        /** Store logical tx open / closed state to prevent invalid sequence of requests.
-         * True means output stream was completed.
-         * Contract: there must be no async operations between setting this field to true and sending complete signal to stream. */
-        _completed = false;
-        globalTxIdWasAwaited = false;
-        pending = new PromiseTracker.PromiseTracker();
-        _startTime = Date.now();
-        _stat = stat.initialTxStatWithoutTime();
-        get stat() {
-            return {
-                ...this._stat,
-                timeMs: Date.now() - this._startTime,
-            };
-        }
-        constructor(ll, name, writable, _clientRoot, finalPredicate, sharedResourceDataCache, enableFormattedErrors = false) {
-            this.ll = ll;
-            this.name = name;
-            this.writable = writable;
-            this._clientRoot = _clientRoot;
-            this.finalPredicate = finalPredicate;
-            this.sharedResourceDataCache = sharedResourceDataCache;
-            this.enableFormattedErrors = enableFormattedErrors;
-            // initiating transaction
-            this.globalTxId = this.sendSingleAndParse({
-                oneofKind: "txOpen",
-                txOpen: {
-                    name,
-                    enableFormattedErrors,
-                    writable: writable
-                        ? api.TxAPI_Open_Request_WritableTx.WRITABLE
-                        : api.TxAPI_Open_Request_WritableTx.NOT_WRITABLE,
-                },
-            }, (r) => tsHelpers.notEmpty(r.txOpen.tx?.id));
-            void this.track(this.globalTxId);
-            // To avoid floating promise
-            this.globalTxId.catch((err) => {
-                if (!this.globalTxIdWasAwaited) {
-                    console.warn(err);
-                }
-            });
-            // Adding stats
-            this._stat.txCount++;
-        }
-        /**
-         * Collect all pending promises for the transaction finalization.
-         */
-        track(promiseOrCallback) {
-            return this.pending.track(promiseOrCallback);
-        }
-        async drainAndAwaitPendingOps() {
-            // awaiting these pending operations first, to catch any errors
-            await this.pending.awaitAll();
-        }
-        sendSingleAndParse(r, parser) {
-            return this.pending.track(async () => {
-                const rawResponsePromise = this.ll.send(r, false);
-                void this.pending.track(rawResponsePromise);
-                await this.drainAndAwaitPendingOps();
-                // awaiting our result, and parsing the response
-                return parser(await rawResponsePromise);
-            });
-        }
-        sendMultiAndParse(r, parser) {
-            return this.pending.track(async () => {
-                const rawResponsePromise = this.ll.send(r, true);
-                void this.pending.track(rawResponsePromise);
-                await this.drainAndAwaitPendingOps();
-                // awaiting our result, and parsing the response
-                return parser(await rawResponsePromise);
-            });
-        }
-        async sendVoidSync(r) {
-            await this.ll.send(r, false);
-        }
-        /** Requests sent with this method should never produce recoverable errors */
-        sendVoidAsync(r) {
-            void this.track(this.sendVoidSync(r));
-        }
-        checkTxOpen() {
-            if (this._completed)
-                throw new Error("Transaction already closed");
-        }
-        get completed() {
-            return this._completed;
-        }
-        /** Commit & closes transaction. {@link TxCommitConflict} is thrown on
-         * commit conflicts. */
-        async commit() {
-            this.checkTxOpen();
-            // tx will accept no requests after this one
-            this._completed = true;
-            if (!this.writable) {
-                // no need to explicitly commit or reject read-only tx
-                const completeResult = this.track(this.ll.complete());
-                await this.drainAndAwaitPendingOps();
-                await completeResult;
-                await this.ll.await();
-            }
-            else {
-                const commitResponse = this.track(this.sendSingleAndParse({ oneofKind: "txCommit", txCommit: {} }, (r) => r.txCommit.success));
-                // send closing frame right after commit to save some time on round-trips
-                const completeResult = this.track(this.ll.complete());
-                // now when we pushed all packets into the stream, we should wait for any
-                // pending void operations from before, to catch any errors
-                await this.drainAndAwaitPendingOps();
-                if (!(await commitResponse))
-                    throw new TxCommitConflict();
-                await completeResult;
-                // await event-loop completion
-                await this.ll.await();
-            }
-        }
-        async discard() {
-            this.checkTxOpen();
-            // tx will accept no requests after this one
-            this._completed = true;
-            const discardResponse = this.sendVoidSync({ oneofKind: "txDiscard", txDiscard: {} });
-            void this.track(discardResponse);
-            // send closing frame right after commit to save some time on round-trips
-            const completeResult = this.track(this.ll.complete());
-            // now when we pushed all packets into the stream, we should wait for any
-            // pending void operations from before, to catch any errors
-            await this.drainAndAwaitPendingOps();
-            await discardResponse;
-            await completeResult;
-            await this.ll.await();
-        }
-        //
-        // Main tx methods
-        //
-        get clientRoot() {
-            return types.ensureResourceIdNotNull(this._clientRoot);
-        }
-        //
-        // Resources
-        //
-        createSingleton(name, type, errorIfExists = false) {
-            const localId = this.nextLocalResourceId(false);
-            const globalId = this.sendSingleAndParse({
-                oneofKind: "resourceCreateSingleton",
-                resourceCreateSingleton: {
-                    type,
-                    id: localId,
-                    data: Buffer.from(name),
-                    errorIfExists,
-                },
-            }, (r) => r.resourceCreateSingleton.resourceId);
-            void this.track(globalId);
-            return { globalId, localId };
-        }
-        getSingleton(name, loadFields = true) {
-            return this.sendSingleAndParse({
-                oneofKind: "resourceGetSingleton",
-                resourceGetSingleton: {
-                    data: Buffer.from(name),
-                    loadFields,
-                },
-            }, (r) => type_conversion.protoToResource(tsHelpers.notEmpty(r.resourceGetSingleton.resource)));
-        }
-        createResource(root, req, parser) {
-            const localId = this.nextLocalResourceId(root);
-            const globalId = this.sendSingleAndParse(req(localId), (r) => parser(r));
-            void this.track(globalId);
-            return { globalId, localId };
-        }
-        createRoot(type) {
-            this._stat.rootsCreated++;
-            return this.createResource(true, (localId) => ({ oneofKind: "resourceCreateRoot", resourceCreateRoot: { type, id: localId } }), (r) => r.resourceCreateRoot.resourceId);
-        }
-        createStruct(type, data) {
-            this._stat.structsCreated++;
-            this._stat.structsCreatedDataBytes += data?.length ?? 0;
-            return this.createResource(false, (localId) => ({
-                oneofKind: "resourceCreateStruct",
-                resourceCreateStruct: {
-                    type,
-                    id: localId,
-                    data: data === undefined ? undefined : typeof data === "string" ? Buffer.from(data) : data,
-                },
-            }), (r) => r.resourceCreateStruct.resourceId);
-        }
-        createEphemeral(type, data) {
-            this._stat.ephemeralsCreated++;
-            this._stat.ephemeralsCreatedDataBytes += data?.length ?? 0;
-            return this.createResource(false, (localId) => ({
-                oneofKind: "resourceCreateEphemeral",
-                resourceCreateEphemeral: {
-                    type,
-                    id: localId,
-                    data: data === undefined ? undefined : typeof data === "string" ? Buffer.from(data) : data,
-                },
-            }), (r) => r.resourceCreateEphemeral.resourceId);
-        }
-        createValue(type, data, errorIfExists = false) {
-            this._stat.valuesCreated++;
-            this._stat.valuesCreatedDataBytes += data?.length ?? 0;
-            return this.createResource(false, (localId) => ({
-                oneofKind: "resourceCreateValue",
-                resourceCreateValue: {
-                    type,
-                    id: localId,
-                    data: typeof data === "string" ? Buffer.from(data) : data,
-                    errorIfExists,
-                },
-            }), (r) => r.resourceCreateValue.resourceId);
-        }
-        createJsonValue(data) {
-            const jsonData = tsHelpers.canonicalJsonBytes(data);
-            return this.createValue(pl.JsonObject, jsonData, false);
-        }
-        createJsonGzValue(data, minSizeToGzip = 16_384) {
-            const { data: jsonData, isGzipped } = tsHelpers.canonicalJsonGzBytes(data, minSizeToGzip);
-            return this.createValue(isGzipped ? pl.JsonGzObject : pl.JsonObject, jsonData, false);
-        }
-        createError(message) {
-            return this.createValue(error_resource.ErrorResourceType, JSON.stringify({ message }));
-        }
-        setResourceName(name, rId) {
-            this.sendVoidAsync({
-                oneofKind: "resourceNameSet",
-                resourceNameSet: { resourceId: toResourceId(rId), name },
-            });
-        }
-        deleteResourceName(name) {
-            this.sendVoidAsync({ oneofKind: "resourceNameDelete", resourceNameDelete: { name } });
-        }
-        getResourceByName(name) {
-            return this.sendSingleAndParse({ oneofKind: "resourceNameGet", resourceNameGet: { name } }, (r) => types.ensureResourceIdNotNull(r.resourceNameGet.resourceId));
-        }
-        checkResourceNameExists(name) {
-            return this.sendSingleAndParse({ oneofKind: "resourceNameExists", resourceNameExists: { name } }, (r) => r.resourceNameExists.exists);
-        }
-        removeResource(rId) {
-            this.sendVoidAsync({ oneofKind: "resourceRemove", resourceRemove: { id: rId } });
-        }
-        resourceExists(rId) {
-            return this.sendSingleAndParse({ oneofKind: "resourceExists", resourceExists: { resourceId: rId } }, (r) => r.resourceExists.exists);
-        }
-        async getResourceData(rId, loadFields = true, ignoreCache = false) {
-            if (!ignoreCache && !isResourceRef(rId) && !types.isLocalResourceId(rId)) {
-                // checking if we can return result from cache
-                const fromCache = this.sharedResourceDataCache.get(rId);
-                if (fromCache && fromCache.cacheTxOpenTimestamp < this.txOpenTimestamp) {
-                    if (!loadFields) {
-                        this._stat.rGetDataCacheHits++;
-                        this._stat.rGetDataCacheBytes += fromCache.basicData.data?.length ?? 0;
-                        return fromCache.basicData;
-                    }
-                    else if (fromCache.data) {
-                        this._stat.rGetDataCacheHits++;
-                        this._stat.rGetDataCacheBytes += fromCache.basicData.data?.length ?? 0;
-                        this._stat.rGetDataCacheFields += fromCache.data.fields.length;
-                        return fromCache.data;
-                    }
-                }
-            }
-            const result = await this.sendSingleAndParse({
-                oneofKind: "resourceGet",
-                resourceGet: { resourceId: toResourceId(rId), loadFields: loadFields },
-            }, (r) => type_conversion.protoToResource(tsHelpers.notEmpty(r.resourceGet.resource)));
-            this._stat.rGetDataNetRequests++;
-            this._stat.rGetDataNetBytes += result.data?.length ?? 0;
-            this._stat.rGetDataNetFields += result.fields.length;
-            // we will cache only final resource data states
-            // caching result even if we were ignore the cache
-            if (!isResourceRef(rId) && !types.isLocalResourceId(rId) && this.finalPredicate(result)) {
-                tsHelpers.deepFreeze(result);
-                const fromCache = this.sharedResourceDataCache.get(rId);
-                if (fromCache) {
-                    if (loadFields && !fromCache.data) {
-                        fromCache.data = result;
-                        // updating timestamp because we updated the record
-                        fromCache.cacheTxOpenTimestamp = this.txOpenTimestamp;
-                    }
-                }
-                else {
-                    const basicData = types.extractBasicResourceData(result);
-                    tsHelpers.deepFreeze(basicData);
-                    if (loadFields)
-                        this.sharedResourceDataCache.set(rId, {
-                            basicData,
-                            data: result,
-                            cacheTxOpenTimestamp: this.txOpenTimestamp,
-                        });
-                    else
-                        this.sharedResourceDataCache.set(rId, {
-                            basicData,
-                            data: undefined,
-                            cacheTxOpenTimestamp: this.txOpenTimestamp,
-                        });
-                }
-            }
-            return result;
-        }
-        async getResourceDataIfExists(rId, loadFields = true) {
-            // calling this method will ignore cache, because user intention is to detect resource absence
-            // which cache will prevent
-            const result = await notFoundToUndefined(async () => await this.getResourceData(rId, loadFields, true));
-            // cleaning cache record if resource was removed from the db
-            if (result === undefined && !isResourceRef(rId) && !types.isLocalResourceId(rId))
-                this.sharedResourceDataCache.delete(rId);
-            return result;
-        }
-        /**
-         * Inform platform that resource will not get any new input fields.
-         * This is required, when client creates resource without schema and wants
-         * controller to start calculations.
-         * Most controllers will not start calculations even when all inputs
-         * have their values, if inputs list is not locked.
-         */
-        lockInputs(rId) {
-            this._stat.inputsLocked++;
-            this.sendVoidAsync({
-                oneofKind: "resourceLockInputs",
-                resourceLockInputs: { resourceId: toResourceId(rId) },
-            });
-        }
-        /**
-         * Inform platform that resource will not get any new output fields.
-         * This is required for resource to pass deduplication.
-         */
-        lockOutputs(rId) {
-            this._stat.outputsLocked++;
-            this.sendVoidAsync({
-                oneofKind: "resourceLockOutputs",
-                resourceLockOutputs: { resourceId: toResourceId(rId) },
-            });
-        }
-        lock(rID) {
-            this.lockInputs(rID);
-            this.lockOutputs(rID);
-        }
-        setResourceError(rId, ref) {
-            this.sendVoidAsync({
-                oneofKind: "resourceSetError",
-                resourceSetError: { resourceId: toResourceId(rId), errorResourceId: toResourceId(ref) },
-            });
-        }
-        //
-        // Fields
-        //
-        createField(fId, fieldType, value) {
-            this._stat.fieldsCreated++;
-            this.sendVoidAsync({
-                oneofKind: "fieldCreate",
-                fieldCreate: { type: type_conversion.fieldTypeToProto(fieldType), id: toFieldId(fId) },
-            });
-            if (value !== undefined)
-                this.setField(fId, value);
-        }
-        fieldExists(fId) {
-            return this.sendSingleAndParse({
-                oneofKind: "fieldExists",
-                fieldExists: { field: toFieldId(fId) },
-            }, (r) => r.fieldExists.exists);
-        }
-        setField(fId, ref) {
-            this._stat.fieldsSet++;
-            if (isResource(ref))
-                this.sendVoidAsync({
-                    oneofKind: "fieldSet",
-                    fieldSet: {
-                        field: toFieldId(fId),
-                        value: {
-                            resourceId: toResourceId(ref),
-                            fieldName: "", // default value, read as undefined
-                        },
-                    },
-                });
-            else
-                this.sendVoidAsync({
-                    oneofKind: "fieldSet",
-                    fieldSet: {
-                        field: toFieldId(fId),
-                        value: toFieldId(ref),
-                    },
-                });
-        }
-        setFieldError(fId, ref) {
-            this._stat.fieldsSet++;
-            this.sendVoidAsync({
-                oneofKind: "fieldSetError",
-                fieldSetError: { field: toFieldId(fId), errResourceId: toResourceId(ref) },
-            });
-        }
-        getField(fId) {
-            this._stat.fieldsGet++;
-            return this.sendSingleAndParse({ oneofKind: "fieldGet", fieldGet: { field: toFieldId(fId) } }, (r) => type_conversion.protoToField(tsHelpers.notEmpty(r.fieldGet.field)));
-        }
-        async getFieldIfExists(fId) {
-            return notFoundToUndefined(async () => await this.getField(fId));
-        }
-        resetField(fId) {
-            this.sendVoidAsync({ oneofKind: "fieldReset", fieldReset: { field: toFieldId(fId) } });
-        }
-        removeField(fId) {
-            this.sendVoidAsync({ oneofKind: "fieldRemove", fieldRemove: { field: toFieldId(fId) } });
-        }
-        //
-        // KV
-        //
-        async listKeyValues(rId) {
-            const result = await this.sendMultiAndParse({
-                oneofKind: "resourceKeyValueList",
-                resourceKeyValueList: { resourceId: toResourceId(rId), startFrom: "", limit: 0 },
-            }, (r) => r.map((e) => e.resourceKeyValueList.record));
-            this._stat.kvListRequests++;
-            this._stat.kvListEntries += result.length;
-            for (const kv of result)
-                this._stat.kvListBytes += kv.key.length + kv.value.length;
-            return result;
-        }
-        async listKeyValuesString(rId) {
-            return (await this.listKeyValues(rId)).map(({ key, value }) => ({
-                key,
-                value: Buffer.from(value).toString(),
-            }));
-        }
-        async listKeyValuesIfResourceExists(rId) {
-            return notFoundToUndefined(async () => await this.listKeyValues(rId));
-        }
-        async listKeyValuesStringIfResourceExists(rId) {
-            return notFoundToUndefined(async () => await this.listKeyValuesString(rId));
-        }
-        setKValue(rId, key, value) {
-            this._stat.kvSetRequests++;
-            this._stat.kvSetBytes++;
-            this.sendVoidAsync({
-                oneofKind: "resourceKeyValueSet",
-                resourceKeyValueSet: {
-                    resourceId: toResourceId(rId),
-                    key,
-                    value: util.toBytes(value),
-                },
-            });
-        }
-        deleteKValue(rId, key) {
-            this.sendVoidAsync({
-                oneofKind: "resourceKeyValueDelete",
-                resourceKeyValueDelete: {
-                    resourceId: toResourceId(rId),
-                    key,
-                },
-            });
-        }
-        async getKValue(rId, key) {
-            const result = await this.sendSingleAndParse({
-                oneofKind: "resourceKeyValueGet",
-                resourceKeyValueGet: { resourceId: toResourceId(rId), key },
-            }, (r) => r.resourceKeyValueGet.value);
-            this._stat.kvGetRequests++;
-            this._stat.kvGetBytes += result.length;
-            return result;
-        }
-        async getKValueString(rId, key) {
-            return Buffer.from(await this.getKValue(rId, key)).toString();
-        }
-        async getKValueJson(rId, key) {
-            return JSON.parse(await this.getKValueString(rId, key));
-        }
-        async getKValueIfExists(rId, key) {
-            const result = await this.sendSingleAndParse({
-                oneofKind: "resourceKeyValueGetIfExists",
-                resourceKeyValueGetIfExists: { resourceId: toResourceId(rId), key },
-            }, (r) => r.resourceKeyValueGetIfExists.exists ? r.resourceKeyValueGetIfExists.value : undefined);
-            this._stat.kvGetRequests++;
-            this._stat.kvGetBytes += result?.length ?? 0;
-            return result;
-        }
-        async getKValueStringIfExists(rId, key) {
-            const data = await this.getKValueIfExists(rId, key);
-            return data === undefined ? undefined : Buffer.from(data).toString();
-        }
-        async getKValueJsonIfExists(rId, key) {
-            const str = await this.getKValueString(rId, key);
-            if (str === undefined)
-                return undefined;
-            return JSON.parse(str);
-        }
-        //
-        // Cache
-        //
-        // TODO
-        //
-        // High level ops
-        //
-        /** Resolves existing or create first level resource from */
-        getFutureFieldValue(rId, fieldName, fieldType) {
-            const data = Buffer.from(JSON.stringify({ fieldName, fieldType }));
-            const getFieldResource = this.createEphemeral({ name: "json/getField", version: "1" }, data);
-            this.setField({ resourceId: getFieldResource, fieldName: "resource" }, rId);
-            return { resourceId: getFieldResource, fieldName: "result" };
-        }
-        //
-        // Technical
-        //
-        async getGlobalTxId() {
-            this.globalTxIdWasAwaited = true;
-            return await this.globalTxId;
-        }
-        /** Closes output event stream */
-        async complete() {
-            if (this._completed)
-                return;
-            this._completed = true;
-            const completeResult = this.track(this.ll.complete());
-            await this.drainAndAwaitPendingOps();
-            await completeResult;
-        }
-        /** Await incoming message loop termination and throw
-         * any leftover errors if it was unsuccessful */
-        async await() {
-            await this.ll.await();
-        }
-        //
-        // Helpers
-        //
-        nextLocalResourceId(root) {
-            return types.createLocalResourceId(root, ++this.localResourceIdCounter, this.localTxId);
-        }
-        static localTxIdCounter = 0;
-        static nextLocalTxId() {
-            PlTransaction.localTxIdCounter++;
-            if (PlTransaction.localTxIdCounter === types.MaxTxId)
-                PlTransaction.localTxIdCounter = 1;
-            return PlTransaction.localTxIdCounter;
-        }
-    };
-})();
+* Each platform transaction has 3 stages:
+*   - initialization (txOpen message -> txInfo response)
+*   - communication (create resources, fields, references and so on)
+*   - finalization (txCommit or txDiscard message)
+*
+* This class encapsulates finalization stage and provides ready-to-communication transaction object.
+* */
+var PlTransaction = class PlTransaction {
+	globalTxId;
+	localTxId = PlTransaction.nextLocalTxId();
+	/** Used in caching */
+	txOpenTimestamp = Date.now();
+	localResourceIdCounter = 0;
+	/** Store logical tx open / closed state to prevent invalid sequence of requests.
+	* True means output stream was completed.
+	* Contract: there must be no async operations between setting this field to true and sending complete signal to stream. */
+	_completed = false;
+	globalTxIdWasAwaited = false;
+	pending = new require_PromiseTracker.PromiseTracker();
+	_startTime = Date.now();
+	_stat = require_stat.initialTxStatWithoutTime();
+	get stat() {
+		return {
+			...this._stat,
+			timeMs: Date.now() - this._startTime
+		};
+	}
+	constructor(ll, name, writable, _clientRoot, finalPredicate, sharedResourceDataCache, enableFormattedErrors = false) {
+		this.ll = ll;
+		this.name = name;
+		this.writable = writable;
+		this._clientRoot = _clientRoot;
+		this.finalPredicate = finalPredicate;
+		this.sharedResourceDataCache = sharedResourceDataCache;
+		this.enableFormattedErrors = enableFormattedErrors;
+		this.globalTxId = this.sendSingleAndParse({
+			oneofKind: "txOpen",
+			txOpen: {
+				name,
+				enableFormattedErrors,
+				writable: writable ? require_api.TxAPI_Open_Request_WritableTx.WRITABLE : require_api.TxAPI_Open_Request_WritableTx.NOT_WRITABLE
+			}
+		}, (r) => (0, _milaboratories_ts_helpers.notEmpty)(r.txOpen.tx?.id));
+		this.track(this.globalTxId);
+		this.globalTxId.catch((err) => {
+			if (!this.globalTxIdWasAwaited) console.warn(err);
+		});
+		this._stat.txCount++;
+	}
+	/**
+	* Collect all pending promises for the transaction finalization.
+	*/
+	track(promiseOrCallback) {
+		return this.pending.track(promiseOrCallback);
+	}
+	async drainAndAwaitPendingOps() {
+		await this.pending.awaitAll();
+	}
+	sendSingleAndParse(r, parser) {
+		return this.pending.track(async () => {
+			const rawResponsePromise = this.ll.send(r, false);
+			this.pending.track(rawResponsePromise);
+			await this.drainAndAwaitPendingOps();
+			return parser(await rawResponsePromise);
+		});
+	}
+	sendMultiAndParse(r, parser) {
+		return this.pending.track(async () => {
+			const rawResponsePromise = this.ll.send(r, true);
+			this.pending.track(rawResponsePromise);
+			await this.drainAndAwaitPendingOps();
+			return parser(await rawResponsePromise);
+		});
+	}
+	async sendVoidSync(r) {
+		await this.ll.send(r, false);
+	}
+	/** Requests sent with this method should never produce recoverable errors */
+	sendVoidAsync(r) {
+		this.track(this.sendVoidSync(r));
+	}
+	checkTxOpen() {
+		if (this._completed) throw new Error("Transaction already closed");
+	}
+	get completed() {
+		return this._completed;
+	}
+	/** Commit & closes transaction. {@link TxCommitConflict} is thrown on
+	* commit conflicts. */
+	async commit() {
+		this.checkTxOpen();
+		this._completed = true;
+		if (!this.writable) {
+			const completeResult = this.track(this.ll.complete());
+			await this.drainAndAwaitPendingOps();
+			await completeResult;
+			await this.ll.await();
+		} else {
+			const commitResponse = this.track(this.sendSingleAndParse({
+				oneofKind: "txCommit",
+				txCommit: {}
+			}, (r) => r.txCommit.success));
+			const completeResult = this.track(this.ll.complete());
+			await this.drainAndAwaitPendingOps();
+			if (!await commitResponse) throw new TxCommitConflict();
+			await completeResult;
+			await this.ll.await();
+		}
+	}
+	async discard() {
+		this.checkTxOpen();
+		this._completed = true;
+		const discardResponse = this.sendVoidSync({
+			oneofKind: "txDiscard",
+			txDiscard: {}
+		});
+		this.track(discardResponse);
+		const completeResult = this.track(this.ll.complete());
+		await this.drainAndAwaitPendingOps();
+		await discardResponse;
+		await completeResult;
+		await this.ll.await();
+	}
+	get clientRoot() {
+		return require_types.ensureResourceIdNotNull(this._clientRoot);
+	}
+	createSingleton(name, type, errorIfExists = false) {
+		const localId = this.nextLocalResourceId(false);
+		const globalId = this.sendSingleAndParse({
+			oneofKind: "resourceCreateSingleton",
+			resourceCreateSingleton: {
+				type,
+				id: localId,
+				data: Buffer.from(name),
+				errorIfExists
+			}
+		}, (r) => r.resourceCreateSingleton.resourceId);
+		this.track(globalId);
+		return {
+			globalId,
+			localId
+		};
+	}
+	getSingleton(name, loadFields = true) {
+		return this.sendSingleAndParse({
+			oneofKind: "resourceGetSingleton",
+			resourceGetSingleton: {
+				data: Buffer.from(name),
+				loadFields
+			}
+		}, (r) => require_type_conversion.protoToResource((0, _milaboratories_ts_helpers.notEmpty)(r.resourceGetSingleton.resource)));
+	}
+	createResource(root, req, parser) {
+		const localId = this.nextLocalResourceId(root);
+		const globalId = this.sendSingleAndParse(req(localId), (r) => parser(r));
+		this.track(globalId);
+		return {
+			globalId,
+			localId
+		};
+	}
+	createRoot(type) {
+		this._stat.rootsCreated++;
+		return this.createResource(true, (localId) => ({
+			oneofKind: "resourceCreateRoot",
+			resourceCreateRoot: {
+				type,
+				id: localId
+			}
+		}), (r) => r.resourceCreateRoot.resourceId);
+	}
+	createStruct(type, data) {
+		this._stat.structsCreated++;
+		this._stat.structsCreatedDataBytes += data?.length ?? 0;
+		return this.createResource(false, (localId) => ({
+			oneofKind: "resourceCreateStruct",
+			resourceCreateStruct: {
+				type,
+				id: localId,
+				data: data === void 0 ? void 0 : typeof data === "string" ? Buffer.from(data) : data
+			}
+		}), (r) => r.resourceCreateStruct.resourceId);
+	}
+	createEphemeral(type, data) {
+		this._stat.ephemeralsCreated++;
+		this._stat.ephemeralsCreatedDataBytes += data?.length ?? 0;
+		return this.createResource(false, (localId) => ({
+			oneofKind: "resourceCreateEphemeral",
+			resourceCreateEphemeral: {
+				type,
+				id: localId,
+				data: data === void 0 ? void 0 : typeof data === "string" ? Buffer.from(data) : data
+			}
+		}), (r) => r.resourceCreateEphemeral.resourceId);
+	}
+	createValue(type, data, errorIfExists = false) {
+		this._stat.valuesCreated++;
+		this._stat.valuesCreatedDataBytes += data?.length ?? 0;
+		return this.createResource(false, (localId) => ({
+			oneofKind: "resourceCreateValue",
+			resourceCreateValue: {
+				type,
+				id: localId,
+				data: typeof data === "string" ? Buffer.from(data) : data,
+				errorIfExists
+			}
+		}), (r) => r.resourceCreateValue.resourceId);
+	}
+	createJsonValue(data) {
+		const jsonData = (0, _milaboratories_ts_helpers.canonicalJsonBytes)(data);
+		return this.createValue(require_pl.JsonObject, jsonData, false);
+	}
+	createJsonGzValue(data, minSizeToGzip = 16384) {
+		const { data: jsonData, isGzipped } = (0, _milaboratories_ts_helpers.canonicalJsonGzBytes)(data, minSizeToGzip);
+		return this.createValue(isGzipped ? require_pl.JsonGzObject : require_pl.JsonObject, jsonData, false);
+	}
+	createError(message) {
+		return this.createValue(require_error_resource.ErrorResourceType, JSON.stringify({ message }));
+	}
+	setResourceName(name, rId) {
+		this.sendVoidAsync({
+			oneofKind: "resourceNameSet",
+			resourceNameSet: {
+				resourceId: toResourceId(rId),
+				name
+			}
+		});
+	}
+	deleteResourceName(name) {
+		this.sendVoidAsync({
+			oneofKind: "resourceNameDelete",
+			resourceNameDelete: { name }
+		});
+	}
+	getResourceByName(name) {
+		return this.sendSingleAndParse({
+			oneofKind: "resourceNameGet",
+			resourceNameGet: { name }
+		}, (r) => require_types.ensureResourceIdNotNull(r.resourceNameGet.resourceId));
+	}
+	checkResourceNameExists(name) {
+		return this.sendSingleAndParse({
+			oneofKind: "resourceNameExists",
+			resourceNameExists: { name }
+		}, (r) => r.resourceNameExists.exists);
+	}
+	removeResource(rId) {
+		this.sendVoidAsync({
+			oneofKind: "resourceRemove",
+			resourceRemove: { id: rId }
+		});
+	}
+	resourceExists(rId) {
+		return this.sendSingleAndParse({
+			oneofKind: "resourceExists",
+			resourceExists: { resourceId: rId }
+		}, (r) => r.resourceExists.exists);
+	}
+	async getResourceData(rId, loadFields = true, ignoreCache = false) {
+		return this.track(async () => {
+			if (!ignoreCache && !isResourceRef(rId) && !require_types.isLocalResourceId(rId)) {
+				const fromCache = this.sharedResourceDataCache.get(rId);
+				if (fromCache && fromCache.cacheTxOpenTimestamp < this.txOpenTimestamp) {
+					if (!loadFields) {
+						this._stat.rGetDataCacheHits++;
+						this._stat.rGetDataCacheBytes += fromCache.basicData.data?.length ?? 0;
+						return fromCache.basicData;
+					} else if (fromCache.data) {
+						this._stat.rGetDataCacheHits++;
+						this._stat.rGetDataCacheBytes += fromCache.basicData.data?.length ?? 0;
+						this._stat.rGetDataCacheFields += fromCache.data.fields.length;
+						return fromCache.data;
+					}
+				}
+			}
+			const result = await this.sendSingleAndParse({
+				oneofKind: "resourceGet",
+				resourceGet: {
+					resourceId: toResourceId(rId),
+					loadFields
+				}
+			}, (r) => require_type_conversion.protoToResource((0, _milaboratories_ts_helpers.notEmpty)(r.resourceGet.resource)));
+			this._stat.rGetDataNetRequests++;
+			this._stat.rGetDataNetBytes += result.data?.length ?? 0;
+			this._stat.rGetDataNetFields += result.fields.length;
+			if (!isResourceRef(rId) && !require_types.isLocalResourceId(rId) && this.finalPredicate(result)) {
+				(0, _milaboratories_ts_helpers.deepFreeze)(result);
+				const fromCache = this.sharedResourceDataCache.get(rId);
+				if (fromCache) {
+					if (loadFields && !fromCache.data) {
+						fromCache.data = result;
+						fromCache.cacheTxOpenTimestamp = this.txOpenTimestamp;
+					}
+				} else {
+					const basicData = require_types.extractBasicResourceData(result);
+					(0, _milaboratories_ts_helpers.deepFreeze)(basicData);
+					if (loadFields) this.sharedResourceDataCache.set(rId, {
+						basicData,
+						data: result,
+						cacheTxOpenTimestamp: this.txOpenTimestamp
+					});
+					else this.sharedResourceDataCache.set(rId, {
+						basicData,
+						data: void 0,
+						cacheTxOpenTimestamp: this.txOpenTimestamp
+					});
+				}
+			}
+			return result;
+		});
+	}
+	async getResourceDataIfExists(rId, loadFields = true) {
+		return this.track(async () => {
+			const result = await notFoundToUndefined(async () => await this.getResourceData(rId, loadFields, true));
+			if (result === void 0 && !isResourceRef(rId) && !require_types.isLocalResourceId(rId)) this.sharedResourceDataCache.delete(rId);
+			return result;
+		});
+	}
+	/**
+	* Inform platform that resource will not get any new input fields.
+	* This is required, when client creates resource without schema and wants
+	* controller to start calculations.
+	* Most controllers will not start calculations even when all inputs
+	* have their values, if inputs list is not locked.
+	*/
+	lockInputs(rId) {
+		this._stat.inputsLocked++;
+		this.sendVoidAsync({
+			oneofKind: "resourceLockInputs",
+			resourceLockInputs: { resourceId: toResourceId(rId) }
+		});
+	}
+	/**
+	* Inform platform that resource will not get any new output fields.
+	* This is required for resource to pass deduplication.
+	*/
+	lockOutputs(rId) {
+		this._stat.outputsLocked++;
+		this.sendVoidAsync({
+			oneofKind: "resourceLockOutputs",
+			resourceLockOutputs: { resourceId: toResourceId(rId) }
+		});
+	}
+	lock(rID) {
+		this.lockInputs(rID);
+		this.lockOutputs(rID);
+	}
+	setResourceError(rId, ref) {
+		this.sendVoidAsync({
+			oneofKind: "resourceSetError",
+			resourceSetError: {
+				resourceId: toResourceId(rId),
+				errorResourceId: toResourceId(ref)
+			}
+		});
+	}
+	createField(fId, fieldType, value) {
+		this._stat.fieldsCreated++;
+		this.sendVoidAsync({
+			oneofKind: "fieldCreate",
+			fieldCreate: {
+				type: require_type_conversion.fieldTypeToProto(fieldType),
+				id: toFieldId(fId)
+			}
+		});
+		if (value !== void 0) this.setField(fId, value);
+	}
+	fieldExists(fId) {
+		return this.sendSingleAndParse({
+			oneofKind: "fieldExists",
+			fieldExists: { field: toFieldId(fId) }
+		}, (r) => r.fieldExists.exists);
+	}
+	setField(fId, ref) {
+		this._stat.fieldsSet++;
+		if (isResource(ref)) this.sendVoidAsync({
+			oneofKind: "fieldSet",
+			fieldSet: {
+				field: toFieldId(fId),
+				value: {
+					resourceId: toResourceId(ref),
+					fieldName: ""
+				}
+			}
+		});
+		else this.sendVoidAsync({
+			oneofKind: "fieldSet",
+			fieldSet: {
+				field: toFieldId(fId),
+				value: toFieldId(ref)
+			}
+		});
+	}
+	setFieldError(fId, ref) {
+		this._stat.fieldsSet++;
+		this.sendVoidAsync({
+			oneofKind: "fieldSetError",
+			fieldSetError: {
+				field: toFieldId(fId),
+				errResourceId: toResourceId(ref)
+			}
+		});
+	}
+	getField(fId) {
+		this._stat.fieldsGet++;
+		return this.sendSingleAndParse({
+			oneofKind: "fieldGet",
+			fieldGet: { field: toFieldId(fId) }
+		}, (r) => require_type_conversion.protoToField((0, _milaboratories_ts_helpers.notEmpty)(r.fieldGet.field)));
+	}
+	async getFieldIfExists(fId) {
+		return this.track(notFoundToUndefined(async () => await this.getField(fId)));
+	}
+	resetField(fId) {
+		this.sendVoidAsync({
+			oneofKind: "fieldReset",
+			fieldReset: { field: toFieldId(fId) }
+		});
+	}
+	removeField(fId) {
+		this.sendVoidAsync({
+			oneofKind: "fieldRemove",
+			fieldRemove: { field: toFieldId(fId) }
+		});
+	}
+	async listKeyValues(rId) {
+		return this.track(async () => {
+			const result = await this.sendMultiAndParse({
+				oneofKind: "resourceKeyValueList",
+				resourceKeyValueList: {
+					resourceId: toResourceId(rId),
+					startFrom: "",
+					limit: 0
+				}
+			}, (r) => r.map((e) => e.resourceKeyValueList.record));
+			this._stat.kvListRequests++;
+			this._stat.kvListEntries += result.length;
+			for (const kv of result) this._stat.kvListBytes += kv.key.length + kv.value.length;
+			return result;
+		});
+	}
+	async listKeyValuesString(rId) {
+		return this.track(async () => (await this.listKeyValues(rId)).map(({ key, value }) => ({
+			key,
+			value: Buffer.from(value).toString()
+		})));
+	}
+	async listKeyValuesIfResourceExists(rId) {
+		return this.track(notFoundToUndefined(async () => await this.listKeyValues(rId)));
+	}
+	async listKeyValuesStringIfResourceExists(rId) {
+		return this.track(notFoundToUndefined(async () => await this.listKeyValuesString(rId)));
+	}
+	setKValue(rId, key, value) {
+		this._stat.kvSetRequests++;
+		this._stat.kvSetBytes++;
+		this.sendVoidAsync({
+			oneofKind: "resourceKeyValueSet",
+			resourceKeyValueSet: {
+				resourceId: toResourceId(rId),
+				key,
+				value: require_util.toBytes(value)
+			}
+		});
+	}
+	deleteKValue(rId, key) {
+		this.sendVoidAsync({
+			oneofKind: "resourceKeyValueDelete",
+			resourceKeyValueDelete: {
+				resourceId: toResourceId(rId),
+				key
+			}
+		});
+	}
+	async getKValue(rId, key) {
+		return this.track(async () => {
+			const result = await this.sendSingleAndParse({
+				oneofKind: "resourceKeyValueGet",
+				resourceKeyValueGet: {
+					resourceId: toResourceId(rId),
+					key
+				}
+			}, (r) => r.resourceKeyValueGet.value);
+			this._stat.kvGetRequests++;
+			this._stat.kvGetBytes += result.length;
+			return result;
+		});
+	}
+	async getKValueString(rId, key) {
+		return this.track(async () => Buffer.from(await this.getKValue(rId, key)).toString());
+	}
+	async getKValueJson(rId, key) {
+		return this.track(async () => JSON.parse(await this.getKValueString(rId, key)));
+	}
+	async getKValueIfExists(rId, key) {
+		return this.track(async () => {
+			const result = await this.sendSingleAndParse({
+				oneofKind: "resourceKeyValueGetIfExists",
+				resourceKeyValueGetIfExists: {
+					resourceId: toResourceId(rId),
+					key
+				}
+			}, (r) => r.resourceKeyValueGetIfExists.exists ? r.resourceKeyValueGetIfExists.value : void 0);
+			this._stat.kvGetRequests++;
+			this._stat.kvGetBytes += result?.length ?? 0;
+			return result;
+		});
+	}
+	async getKValueStringIfExists(rId, key) {
+		return this.track(async () => {
+			const data = await this.getKValueIfExists(rId, key);
+			return data === void 0 ? void 0 : Buffer.from(data).toString();
+		});
+	}
+	async getKValueJsonIfExists(rId, key) {
+		return this.track(async () => {
+			const str = await this.getKValueString(rId, key);
+			if (str === void 0) return void 0;
+			return JSON.parse(str);
+		});
+	}
+	/** Resolves existing or create first level resource from */
+	getFutureFieldValue(rId, fieldName, fieldType) {
+		const data = Buffer.from(JSON.stringify({
+			fieldName,
+			fieldType
+		}));
+		const getFieldResource = this.createEphemeral({
+			name: "json/getField",
+			version: "1"
+		}, data);
+		this.setField({
+			resourceId: getFieldResource,
+			fieldName: "resource"
+		}, rId);
+		return {
+			resourceId: getFieldResource,
+			fieldName: "result"
+		};
+	}
+	async getGlobalTxId() {
+		this.globalTxIdWasAwaited = true;
+		return await this.globalTxId;
+	}
+	/** Closes output event stream */
+	async complete() {
+		if (this._completed) return;
+		this._completed = true;
+		const completeResult = this.track(this.ll.complete());
+		await this.drainAndAwaitPendingOps();
+		await completeResult;
+	}
+	/** Await incoming message loop termination and throw
+	* any leftover errors if it was unsuccessful */
+	async await() {
+		await this.ll.await();
+	}
+	nextLocalResourceId(root) {
+		return require_types.createLocalResourceId(root, ++this.localResourceIdCounter, this.localTxId);
+	}
+	static localTxIdCounter = 0;
+	static nextLocalTxId() {
+		PlTransaction.localTxIdCounter++;
+		if (PlTransaction.localTxIdCounter === require_types.MaxTxId) PlTransaction.localTxIdCounter = 1;
+		return PlTransaction.localTxIdCounter;
+	}
+};
 
+//#endregion
 exports.PlTransaction = PlTransaction;
 exports.TxCommitConflict = TxCommitConflict;
 exports.field = field;
@@ -685,4 +648,4 @@ exports.toFieldId = toFieldId;
 exports.toGlobalFieldId = toGlobalFieldId;
 exports.toGlobalResourceId = toGlobalResourceId;
 exports.toResourceId = toResourceId;
-//# sourceMappingURL=transaction.cjs.map
+//# sourceMappingURL=transaction.cjs.map