core-3nweb-client-lib 0.27.4 → 0.27.6

package/build/ipc-via-protobuf/startup-cap.js

@@ -72,7 +72,7 @@ var getAvailableAddresses;
     }
     getAvailableAddresses.wrapService = wrapService;
     function makeCaller(caller, objPath) {
-        const path = objPath.concat('getAvailableAddresses');
+        const path = (0, protobuf_msg_1.methodPathFor)(objPath, 'getAvailableAddresses');
         return (name, token) => caller
             .startPromiseCall(path, requestType.pack({ name, token: (0, protobuf_msg_1.toOptVal)(token) }))
             .then(buf => (0, protobuf_msg_1.fixArray)(protobuf_msg_1.strArrValType.unpack(buf).values));
@@ -93,7 +93,7 @@ var addUser;
     }
     addUser.wrapService = wrapService;
     function makeCaller(caller, objPath) {
-        const path = objPath.concat('addUser');
+        const path = (0, protobuf_msg_1.methodPathFor)(objPath, 'addUser');
         return (userId, token) => caller
             .startPromiseCall(path, requestType.pack({ userId, token: (0, protobuf_msg_1.toOptVal)(token) }))
             .then(buf => protobuf_msg_1.boolValType.unpack(buf).value);
@@ -114,7 +114,7 @@ var isActivated;
     }
     isActivated_1.wrapService = wrapService;
     function makeCaller(caller, objPath) {
-        const path = objPath.concat('isActivated');
+        const path = (0, protobuf_msg_1.methodPathFor)(objPath, 'isActivated');
         return userId => caller
             .startPromiseCall(path, requestType.pack({ userId }))
             .then(buf => protobuf_msg_1.boolValType.unpack(buf).value);
@@ -137,7 +137,7 @@ var createUserParams;
     }
     createUserParams.wrapService = wrapService;
     function makeCaller(caller, objPath) {
-        const path = objPath.concat('createUserParams');
+        const path = (0, protobuf_msg_1.methodPathFor)(objPath, 'createUserParams');
         return (pass, progressCB) => {
             const s = new rxjs_1.Subject();
             const completion = (0, deferred_1.defer)();
@@ -167,7 +167,7 @@ var getUsersOnDisk;
     }
     getUsersOnDisk.wrapService = wrapService;
     function makeCaller(caller, objPath) {
-        const path = objPath.concat('getUsersOnDisk');
+        const path = (0, protobuf_msg_1.methodPathFor)(objPath, 'getUsersOnDisk');
         return () => caller
             .startPromiseCall(path, undefined)
             .then(buf => (0, protobuf_msg_1.fixArray)(protobuf_msg_1.strArrValType.unpack(buf).values));
@@ -188,7 +188,7 @@ var startLoginToRemoteStorage;
     }
     startLoginToRemoteStorage.wrapService = wrapService;
     function makeCaller(caller, objPath) {
-        const path = objPath.concat('startLoginToRemoteStorage');
+        const path = (0, protobuf_msg_1.methodPathFor)(objPath, 'startLoginToRemoteStorage');
         return address => caller
             .startPromiseCall(path, requestType.pack({ address }))
             .then(buf => protobuf_msg_1.boolValType.unpack(buf).value);
@@ -214,7 +214,7 @@ var completeLoginAndLocalSetup;
     }
     completeLoginAndLocalSetup.wrapService = wrapService;
     function makeCaller(caller, objPath) {
-        const path = objPath.concat('completeLoginAndLocalSetup');
+        const path = (0, protobuf_msg_1.methodPathFor)(objPath, 'completeLoginAndLocalSetup');
         return (pass, progressCB) => {
             const s = new rxjs_1.Subject();
             const completion = (0, deferred_1.defer)();
@@ -256,7 +256,7 @@ var useExistingStorage;
     }
     useExistingStorage.wrapService = wrapService;
     function makeCaller(caller, objPath) {
-        const path = objPath.concat('useExistingStorage');
+        const path = (0, protobuf_msg_1.methodPathFor)(objPath, 'useExistingStorage');
         return (address, pass, progressCB) => {
             const s = new rxjs_1.Subject();
             const completion = (0, deferred_1.defer)();

package/build/ipc-via-protobuf/storage-cap.js

@@ -76,7 +76,7 @@ var getAppLocalFS;
     }
     getAppLocalFS.wrapService = wrapService;
     function makeCaller(caller, objPath) {
-        const path = objPath.concat('getAppLocalFS');
+        const path = (0, protobuf_msg_1.methodPathFor)(objPath, 'getAppLocalFS');
         return appName => caller
             .startPromiseCall(path, requestType.pack({ appName: (0, protobuf_msg_1.toOptVal)(appName) }))
             .then(buf => {
@@ -103,7 +103,7 @@ var getAppSyncedFS;
     }
     getAppSyncedFS.wrapService = wrapService;
     function makeCaller(caller, objPath) {
-        const path = objPath.concat('getAppSyncedFS');
+        const path = (0, protobuf_msg_1.methodPathFor)(objPath, 'getAppSyncedFS');
         return appName => caller
             .startPromiseCall(path, requestType.pack({ appName: (0, protobuf_msg_1.toOptVal)(appName) }))
             .then(buf => {
@@ -130,7 +130,7 @@ var getSysFS;
     }
     getSysFS.wrapService = wrapService;
     function makeCaller(caller, objPath) {
-        const ipcPath = objPath.concat('getSysFS');
+        const ipcPath = (0, protobuf_msg_1.methodPathFor)(objPath, 'getSysFS');
         return (type, path) => caller
             .startPromiseCall(ipcPath, requestType.pack({
             type, path: (0, protobuf_msg_1.toOptVal)(path)
@@ -159,7 +159,7 @@ var getUserFS;
     }
     getUserFS.wrapService = wrapService;
     function makeCaller(caller, objPath) {
-        const ipcPath = objPath.concat('getUserFS');
+        const ipcPath = (0, protobuf_msg_1.methodPathFor)(objPath, 'getUserFS');
         return (type, path) => caller
             .startPromiseCall(ipcPath, requestType.pack({
             type, path: (0, protobuf_msg_1.toOptVal)(path)

package/build/ipc.d.ts

@@ -4,3 +4,4 @@ export * from "./ipc-via-protobuf/connector";
 export { FileMsg, makeFileCaller, exposeFileService } from "./ipc-via-protobuf/file";
 export { FSMsg, makeFSCaller, exposeFSService } from "./ipc-via-protobuf/fs";
 export { makeLogCaller, exposeLogger } from "./ipc-via-protobuf/log-cap";
+export * as rxjs from 'rxjs';

package/build/ipc.js

@@ -30,7 +30,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.exposeLogger = exports.makeLogCaller = exports.exposeFSService = exports.makeFSCaller = exports.exposeFileService = exports.makeFileCaller = void 0;
+exports.rxjs = exports.exposeLogger = exports.makeLogCaller = exports.exposeFSService = exports.makeFSCaller = exports.exposeFileService = exports.makeFileCaller = void 0;
 __exportStar(require("./core-ipc/common-caps"), exports);
 __exportStar(require("./core-ipc/startup-caps"), exports);
 __exportStar(require("./ipc-via-protobuf/connector"), exports);
@@ -43,4 +43,6 @@ Object.defineProperty(exports, "exposeFSService", { enumerable: true, get: funct
 var log_cap_1 = require("./ipc-via-protobuf/log-cap");
 Object.defineProperty(exports, "makeLogCaller", { enumerable: true, get: function () { return log_cap_1.makeLogCaller; } });
 Object.defineProperty(exports, "exposeLogger", { enumerable: true, get: function () { return log_cap_1.exposeLogger; } });
+// Reexport of rxjs to use with ipc implementation.
+exports.rxjs = require("rxjs");
 Object.freeze(exports);

package/build/lib-client/3nstorage/xsp-fs/common.js

@@ -71,6 +71,7 @@ class NodesContainer {
             }
         })();
         this.promises.set(objId, envelopedPromise);
+        envelopedPromise.catch(noop);
     }
     delete(node) {
         const existing = this.get(node.objId);
@@ -93,6 +94,7 @@ class NodesContainer {
     }
 }
 exports.NodesContainer = NodesContainer;
+function noop() { }
 function wrapStorageImplementation(impl) {
     const wrap = {
         type: impl.type,

package/build/lib-client/3nstorage/xsp-fs/file-node.js

@@ -159,23 +159,6 @@ class FileNode extends node_in_fs_1.NodeInFS {
         }
         const bytes = await this.crypto.readBytes(objSrc, start, end);
         return { bytes, version };
-        // if ((this.storage.type === 'synced') || (this.storage.type === 'local')) {
-        // 	const version = objSrc.version;
-        // 	if (this.version < version) {
-        // 		const {
-        // 			bytes, fileAttrs
-        // 		} = await this.crypto.readBytes(objSrc, start, end, true);
-        // 		// this.setUpdatedState(version, fileAttrs!);
-        // 		return { bytes, version };
-        // 	} else {
-        // 		const { bytes } = await this.crypto.readBytes(objSrc, start, end);
-        // 		return { bytes, version };
-        // 	}
-        // } else {
-        // 	const { bytes } = await this.crypto.readBytes(objSrc, start, end);
-        // 	// unversioned storage passes undefined version
-        // 	return { bytes, version: (undefined as any) };
-        // }
     }
     async writeSink(truncate, currentVersion, changes) {
         const deferredSink = (0, deferred_1.defer)();

package/build/lib-client/3nstorage/xsp-fs/file.d.ts

@@ -97,7 +97,7 @@ declare class V implements WritableFileVersionedAPI, N {
 declare class S implements WritableFileSyncAPI {
     private readonly n;
     constructor(n: N);
-    upload(opts?: OptionsToUploadLocal): Promise<void>;
+    upload(opts?: OptionsToUploadLocal): Promise<number | undefined>;
     status(): Promise<SyncStatus>;
     updateStatusInfo(): Promise<SyncStatus>;
     isRemoteVersionOnDisk(version: number): Promise<'complete' | 'partial' | 'none'>;

package/build/lib-client/3nstorage/xsp-fs/folder-node.d.ts

@@ -142,7 +142,7 @@ export declare class FolderNode extends NodeInFS<FolderPersistance> {
     private removeChildrenObjsInSyncedStorage;
     private uploadRemovalOfObjs;
     getParamsForLink(): LinkParameters<FolderLinkParams>;
-    upload(opts: OptionsToUploadLocal | undefined): Promise<void>;
+    upload(opts: OptionsToUploadLocal | undefined): Promise<number | undefined>;
     private uploadRemovalOf;
     private listRemovedInTreeToUploadRm;
     protected needUpload(localVersion: number | undefined): Promise<{

package/build/lib-client/3nstorage/xsp-fs/folder-node.js

@@ -311,14 +311,14 @@ class FolderNode extends node_in_fs_1.NodeInFS {
                 throw new Error(`Unknown type of fs node`);
             }
             deferred.resolve(node);
-            return node;
+            return deferred.promise;
         }
         catch (exc) {
-            deferred.reject(exc);
             if (exc.objNotFound) {
                 await this.fixMissingChildAndThrow(exc, info);
             }
-            throw (0, error_1.errWithCause)(exc, `Failed to instantiate fs node '${this.name}/${info.name}'`);
+            deferred.reject((0, error_1.errWithCause)(exc, `Failed to instantiate fs node '${this.name}/${info.name}'`));
+            return deferred.promise;
         }
     }
     getFolder(name, undefOnMissing = false) {
@@ -665,11 +665,14 @@ class FolderNode extends node_in_fs_1.NodeInFS {
     }
     async removeFolderObj(src, passIdsForRmUpload = false) {
         const childrenNodes = await this.doChange(true, async () => {
+            if (this.version < 0) {
+                return;
+            }
             const childrenNodes = await this.getAllNodes();
-            await this.removeThisNodeAsLeaf(src);
+            await this.removeThisFromStorageNodes(src);
             return childrenNodes;
         });
-        if (childrenNodes.length === 0) {
+        if (!childrenNodes || (childrenNodes.length === 0)) {
             return;
         }
         if (this.isInSyncedStorage) {
@@ -690,6 +693,9 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         }
     }
     async removeChildrenObjsInSyncedStorage(childrenNodes, src, passIdsForRmUpload) {
+        if (this.version < 0) {
+            return;
+        }
         let uploadRmsHere;
         let collectedIds;
         if (passIdsForRmUpload) {
@@ -771,8 +777,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
                 return;
             }
             if (toUpload.createOnRemote) {
-                await super.upload(opts);
-                return;
+                return await super.upload(opts);
             }
             const storage = this.syncedStorage();
             const { localVersion, uploadVersion } = toUpload;
@@ -784,6 +789,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
                 // we also don't await for chidren removal
                 this.uploadRemovalOf(removedNodes);
             }
+            return uploadVersion;
         }
         catch (exc) {
             throw (0, common_1.setPathInExc)(exc, this.name);

package/build/lib-client/3nstorage/xsp-fs/fs.d.ts

@@ -161,7 +161,7 @@ declare class V implements WritableFSVersionedAPI, N {
 declare class S implements WritableFSSyncAPI {
     private readonly n;
     constructor(n: N);
-    upload(path: string, opts?: OptionsToUploadLocal): Promise<void>;
+    upload(path: string, opts?: OptionsToUploadLocal): Promise<number | undefined>;
     status(path: string): Promise<SyncStatus>;
     updateStatusInfo(path: string): Promise<SyncStatus>;
     isRemoteVersionOnDisk(path: string, version: number): Promise<'complete' | 'partial' | 'none'>;

package/build/lib-client/3nstorage/xsp-fs/fs.js

@@ -722,7 +722,7 @@ class S {
         this.n.ensureIsWritable();
         const node = await this.n.get(path);
         try {
-            await node.upload(opts);
+            return await node.upload(opts);
         }
         catch (exc) {
             throw (0, common_1.setPathInExc)(exc, path);

package/build/lib-client/3nstorage/xsp-fs/node-in-fs.d.ts

@@ -49,7 +49,7 @@ export declare abstract class NodeInFS<P extends NodePersistance> implements Nod
     }>;
     archiveCurrent(version?: number): Promise<number>;
     removeNonFolderObj(src: FSChangeSrc): Promise<void>;
-    protected removeThisNodeAsLeaf(src: FSChangeSrc): Promise<void>;
+    protected removeThisFromStorageNodes(src: FSChangeSrc): Promise<void>;
     /**
      * This method runs node changing function in an exclusive manner.
      * Returned promise resolves to whatever change function returns.
@@ -82,7 +82,7 @@ export declare abstract class NodeInFS<P extends NodePersistance> implements Nod
         uploadVersion: number;
         createOnRemote: boolean;
     } | undefined>;
-    upload(opts: OptionsToUploadLocal | undefined): Promise<void>;
+    upload(opts: OptionsToUploadLocal | undefined): Promise<number | undefined>;
     protected uploadHeaderChange(localVersion: number, uploadVersion: number): Promise<UploadHeaderChange | undefined>;
 }
 export declare function shouldReadCurrentVersion(flags: VersionedReadFlags | undefined): boolean;

package/build/lib-client/3nstorage/xsp-fs/node-in-fs.js

@@ -179,9 +179,12 @@ class NodeInFS {
     }
     removeNonFolderObj(src) {
         (0, assert_1.assert)(this.type !== 'folder');
-        return this.doChange(true, () => this.removeThisNodeAsLeaf(src));
+        return this.doChange(true, () => this.removeThisFromStorageNodes(src));
     }
-    async removeThisNodeAsLeaf(src) {
+    async removeThisFromStorageNodes(src) {
+        if (this.currentVersion < 0) {
+            return;
+        }
         await this.storage.removeObj(this.objId);
         this.storage.nodes.delete(this);
         this.currentVersion = -1;
@@ -391,11 +394,12 @@ class NodeInFS {
             const uploadHeader = await this.uploadHeaderChange(localVersion, uploadVersion);
             const storage = this.syncedStorage();
             await storage.upload(this.objId, localVersion, uploadVersion, uploadHeader, createOnRemote);
-            await this.doChange(true, async () => {
+            return await this.doChange(true, async () => {
                 storage.dropCachedLocalObjVersionsLessOrEqual(this.objId, localVersion);
                 if (this.currentVersion === localVersion) {
                     this.currentVersion = uploadVersion;
                 }
+                return uploadVersion;
             });
         }
         catch (exc) {

package/build/lib-client/3nstorage/xsp-fs/node-persistence.d.ts

@@ -12,6 +12,7 @@ export declare abstract class NodePersistance {
     private zerothHeaderNonce;
     private key;
     private cryptor;
+    private workLabel;
     protected constructor(zerothHeaderNonce: Uint8Array, key: Uint8Array, cryptor: AsyncSBoxCryptor);
     wipe(): void;
     compareKey(keyB64: string): boolean;

package/build/lib-client/3nstorage/xsp-fs/node-persistence.js

@@ -25,6 +25,7 @@ const xsp_files_1 = require("xsp-files");
 const buffer_utils_1 = require("../../../lib-common/buffer-utils");
 const deferred_1 = require("../../../lib-common/processes/deferred");
 const random = require("../../../lib-common/random-node");
+const cryptor_work_labels_1 = require("../../cryptor-work-labels");
 const pv1 = require("./xsp-payload-v1");
 const pv2 = require("./xsp-payload-v2");
 const SEG_SIZE = 16; // in 256-byte blocks = 4K in bytes
@@ -37,6 +38,7 @@ class NodePersistance {
         this.zerothHeaderNonce = zerothHeaderNonce;
         this.key = key;
         this.cryptor = cryptor;
+        this.workLabel = cryptor_work_labels_1.cryptoWorkLabels.makeForNonce('storage', this.zerothHeaderNonce);
     }
     wipe() {
         if (this.key) {
@@ -60,13 +62,13 @@ class NodePersistance {
         if (!this.key) {
             throw new Error("Cannot use wiped object.");
         }
-        return (0, xsp_files_1.makeSegmentsWriter)(this.key, this.zerothHeaderNonce, version, { type: 'new', segSize: SEG_SIZE, payloadFormat: 2 }, random.bytes, this.cryptor);
+        return (0, xsp_files_1.makeSegmentsWriter)(this.key, this.zerothHeaderNonce, version, { type: 'new', segSize: SEG_SIZE, payloadFormat: 2 }, random.bytes, this.cryptor, this.workLabel);
     }
     async segWriterWithBase(newVersion, base) {
         if (!this.key) {
             throw new Error("Cannot use wiped object.");
         }
-        return (0, xsp_files_1.makeSegmentsWriter)(this.key, this.zerothHeaderNonce, newVersion, { type: 'update', base, payloadFormat: 2 }, random.bytes, this.cryptor);
+        return (0, xsp_files_1.makeSegmentsWriter)(this.key, this.zerothHeaderNonce, newVersion, { type: 'update', base, payloadFormat: 2 }, random.bytes, this.cryptor, this.workLabel);
     }
     async decryptedByteSrc(src) {
         if (!this.key) {
@@ -74,7 +76,7 @@ class NodePersistance {
         }
         const version = src.version;
         const header = await src.readHeader();
-        const segReader = await (0, xsp_files_1.makeSegmentsReader)(this.key, this.zerothHeaderNonce, version, header, this.cryptor);
+        const segReader = await (0, xsp_files_1.makeSegmentsReader)(this.key, this.zerothHeaderNonce, version, header, this.cryptor, this.workLabel);
         return {
             version,
             byteSrc: (0, xsp_files_1.makeDecryptedByteSource)(src.segSrc, segReader),
@@ -169,9 +171,9 @@ class NodePersistance {
         if (!this.key) {
             throw new Error("Cannot use wiped object.");
         }
-        const headerContent = await this.cryptor.formatWN.open(initHeader, this.key);
+        const headerContent = await this.cryptor.formatWN.open(initHeader, this.key, this.workLabel);
         const n = (0, xsp_files_1.calculateNonce)(this.zerothHeaderNonce, newVersion);
-        return this.cryptor.formatWN.pack(headerContent, n, this.key);
+        return this.cryptor.formatWN.pack(headerContent, n, this.key, this.workLabel);
     }
 }
 exports.NodePersistance = NodePersistance;

package/build/lib-client/3nstorage/xsp-fs/xsp-payload-v1.js

@@ -67,14 +67,13 @@ class ReadonlyPayloadV1 {
             return;
         }
         return await this.syncProc.startOrChain(async () => {
-            await this.src.seek(start);
-            return await this.src.read(end - start);
+            return await this.src.readAt(start, end - start);
         });
     }
     makeFileByteSource() {
-        const { getPosition, seek, read } = this.src;
+        const { getPosition, seek, readNext, readAt } = this.src;
         return {
-            seek, getPosition, read,
+            seek, getPosition, readNext, readAt,
             getSize: async () => this.size,
         };
     }

package/build/lib-client/3nstorage/xsp-fs/xsp-payload-v2.js

@@ -140,22 +140,28 @@ class ReadonlyPayloadV2 {
     }
     makeFileByteSource() {
         let pos = 0;
+        const seek = async (ofs) => {
+            (0, assert_1.assert)(Number.isInteger(ofs) && (ofs >= 0) && (ofs <= this.size), `Offset must be an integer from 0 to size value, inclusive`);
+            pos = ofs;
+        };
+        const readNext = async (len) => {
+            if (len === undefined) {
+                len = this.size - pos;
+            }
+            const bytes = await this.readSomeContentBytes(pos, pos + len);
+            if (bytes) {
+                pos += bytes.length;
+            }
+            return bytes;
+        };
         return (0, wrapping_1.wrapAndSyncFileSource)({
-            seek: async (ofs) => {
-                (0, assert_1.assert)(Number.isInteger(ofs) && (ofs >= 0) && (ofs <= this.size), `Offset must be an integer from 0 to size value, inclusive`);
-                pos = ofs;
-            },
+            seek,
             getSize: async () => this.size,
             getPosition: async () => pos,
-            read: async (len) => {
-                if (len === undefined) {
-                    len = this.size - pos;
-                }
-                const bytes = await this.readSomeContentBytes(pos, pos + len);
-                if (bytes) {
-                    pos += bytes.length;
-                }
-                return bytes;
+            readNext,
+            readAt: async (pos, len) => {
+                await seek(pos);
+                return await readNext(len);
             }
         });
     }
@@ -784,8 +790,7 @@ function payloadLayoutException(msg, cause) {
     };
 }
 async function sureReadOfBytesFrom(src, ofs, len) {
-    await src.seek(ofs);
-    const bytes = await src.read(len);
+    const bytes = await src.readAt(ofs, len);
     (0, assert_1.assert)(!!bytes && (bytes.length === len));
     return bytes;
 }

package/build/lib-client/cryptor/cryptor-in-worker.js

@@ -22,9 +22,9 @@ const os_1 = require("os");
 const deferred_1 = require("../../lib-common/processes/deferred");
 const error_1 = require("../../lib-common/exceptions/error");
 const path_1 = require("path");
-const protobuf_type_1 = require("../protobuf-type");
-const cryptor_proto_1 = require("../../protos/cryptor.proto");
 const assert_1 = require("../../lib-common/assert");
+const serialization_for_wasm_1 = require("./serialization-for-wasm");
+const cryptor_work_labels_1 = require("../cryptor-work-labels");
 const MAX_IDLE_MILLIS = 60 * 1000;
 const jsWorkerFName = 'worker-js.js';
 const wasmWorkerFName = 'worker-wasm.js';
@@ -73,6 +73,10 @@ class Workers {
         this.maxThreads = Math.max(1, ((typeof maxThreads === 'number') ?
             maxThreads : (0, os_1.cpus)().length - 1));
     }
+    numOfIdle() {
+        return this.idleWorkers.length +
+            Math.max(this.maxThreads - this.allWorkers.size, 0);
+    }
     async getIdleWorker() {
         const idle = this.idleWorkers.pop();
         if (idle) {
@@ -90,7 +94,7 @@ class Workers {
     }
     async doRequest(request, trans, d) {
         if (this.isClosed) {
-            new Error(`Async cryptor is already closed`);
+            throw new Error(`Async cryptor is already closed`);
         }
         const worker = await this.getIdleWorker();
         this.replySinks.set(worker, d);
@@ -240,6 +244,7 @@ const makeInWorkerCryptor = (logErr, logWarning, maxThreads) => {
     (0, assert_1.assert)(typeof logWarning === 'function');
     const workers = new JsWorkers(logErr, logWarning, maxThreads);
     const close = workers.close.bind(workers);
+    const execCounter = new cryptor_work_labels_1.ExecCounter(() => workers.numOfIdle());
     const cryptor = {
         scrypt: (passwd, salt, logN, r, p, dkLen, progressCB) => workers.call('scrypt', [passwd, salt, logN, r, p, dkLen], undefined, progressCB),
         box: {
@@ -247,11 +252,12 @@ const makeInWorkerCryptor = (logErr, logWarning, maxThreads) => {
             generate_pubkey: (sk) => workers.call('box.generate_pubkey', [sk])
         },
         sbox: {
-            open: (c, n, k) => workers.call('sbox.open', [c, n, k]),
-            pack: (m, n, k) => workers.call('sbox.pack', [m, n, k]),
+            canStartUnderWorkLabel: l => execCounter.canStartUnderWorkLabel(l),
+            open: (c, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call('sbox.open', [c, n, k])),
+            pack: (m, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call('sbox.pack', [m, n, k])),
             formatWN: {
-                open: (cn, k) => workers.call('sbox.formatWN.open', [cn, k]),
-                pack: (m, n, k) => workers.call('sbox.formatWN.pack', [m, n, k])
+                open: (cn, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call('sbox.formatWN.open', [cn, k])),
+                pack: (m, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call('sbox.formatWN.pack', [m, n, k]))
             }
         },
         signing: {
@@ -266,45 +272,28 @@ exports.makeInWorkerCryptor = makeInWorkerCryptor;
 class WasmWorkers extends Workers {
     constructor(logErr, logWarning, maxThreads) {
         super(workerScriptFor('wasm'), logErr, logWarning, maxThreads);
-        this.reqType = protobuf_type_1.ProtoType.for(cryptor_proto_1.cryptor.Request);
-        this.replyType = protobuf_type_1.ProtoType.for(cryptor_proto_1.cryptor.Reply);
     }
     call(req, interim) {
-        const msg = this.reqType.pack(req);
+        const msg = (0, serialization_for_wasm_1.packRequestToWASM)(req);
         return this.doRequest(msg, undefined, { res: (0, deferred_1.defer)(), interim });
     }
     processReply(replyBytes) {
-        const { res, interim, err } = this.replyType.unpack(replyBytes);
+        const { res, interim, err } = (0, serialization_for_wasm_1.unpackReplyFromWASM)(replyBytes);
         return {
             res: res ? res.val : undefined,
             interim: interim ? interim.val : undefined,
-            err: err ? toLocalErr(err) : undefined,
+            err: err ? (0, serialization_for_wasm_1.toLocalErr)(err) : undefined,
         };
     }
 }
 Object.freeze(WasmWorkers.prototype);
 Object.freeze(WasmWorkers);
-function toArgs(...args) {
-    return args.map(val => ({ val }));
-}
-function toLocalErr(replyErr) {
-    if (replyErr.condition === 'cipher-verification') {
-        return { failedCipherVerification: true };
-    }
-    else if (replyErr.condition === 'signature-verification') {
-        return { failedSignatureVerification: true };
-    }
-    else {
-        return new Error(`WASM cryptor ${replyErr.condition}: ${replyErr.message}`);
-    }
-}
 const makeInWorkerWasmCryptor = (logErr, logWarning, maxThreads) => {
     (0, assert_1.assert)(typeof logErr === 'function');
     (0, assert_1.assert)(typeof logWarning === 'function');
     const workers = new WasmWorkers(logErr, logWarning, maxThreads);
     const close = workers.close.bind(workers);
-    const boolValType = protobuf_type_1.ProtoType.for(cryptor_proto_1.cryptor.BoolVal);
-    const kpairType = protobuf_type_1.ProtoType.for(cryptor_proto_1.cryptor.Keypair);
+    const execCounter = new cryptor_work_labels_1.ExecCounter(() => workers.numOfIdle());
     const cryptor = {
         scrypt: (passwd, salt, logN, r, p, dkLen, progressCB) => workers.call({
             func: 1,
@@ -313,51 +302,52 @@ const makeInWorkerWasmCryptor = (logErr, logWarning, maxThreads) => {
         box: {
             calc_dhshared_key: (pk, sk) => workers.call({
                 func: 2,
-                byteArgs: toArgs(pk, sk)
+                byteArgs: (0, serialization_for_wasm_1.toArgs)(pk, sk)
             }),
             generate_pubkey: (sk) => workers.call({
                 func: 3,
-                byteArgs: toArgs(sk)
+                byteArgs: (0, serialization_for_wasm_1.toArgs)(sk)
             })
         },
         sbox: {
-            open: (c, n, k) => workers.call({
+            canStartUnderWorkLabel: l => execCounter.canStartUnderWorkLabel(l),
+            open: (c, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call({
                 func: 4,
-                byteArgs: toArgs(c, n, k)
-            }),
-            pack: (m, n, k) => workers.call({
+                byteArgs: (0, serialization_for_wasm_1.toArgs)(c, n, k)
+            })),
+            pack: (m, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call({
                 func: 5,
-                byteArgs: toArgs(m, n, k)
-            }),
+                byteArgs: (0, serialization_for_wasm_1.toArgs)(m, n, k)
+            })),
             formatWN: {
-                open: (cn, k) => workers.call({
+                open: (cn, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call({
                     func: 6,
-                    byteArgs: toArgs(cn, k)
-                }),
-                pack: (m, n, k) => workers.call({
+                    byteArgs: (0, serialization_for_wasm_1.toArgs)(cn, k)
+                })),
+                pack: (m, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, workers.call({
                     func: 7,
-                    byteArgs: toArgs(m, n, k)
-                })
+                    byteArgs: (0, serialization_for_wasm_1.toArgs)(m, n, k)
+                }))
             }
         },
         signing: {
             generate_keypair: async (seed) => {
                 const rep = await workers.call({
                     func: 8,
-                    byteArgs: toArgs(seed)
+                    byteArgs: (0, serialization_for_wasm_1.toArgs)(seed)
                 });
-                return kpairType.unpack(rep);
+                return (0, serialization_for_wasm_1.unpackSigningKeyPair)(rep);
             },
             signature: (m, sk) => workers.call({
                 func: 9,
-                byteArgs: toArgs(m, sk)
+                byteArgs: (0, serialization_for_wasm_1.toArgs)(m, sk)
             }),
             verify: async (sig, m, pk) => {
                 const rep = await workers.call({
                     func: 10,
-                    byteArgs: toArgs(sig, m, pk)
+                    byteArgs: (0, serialization_for_wasm_1.toArgs)(sig, m, pk)
                 });
-                return boolValType.unpack(rep).val;
+                return (0, serialization_for_wasm_1.unpackBoolVal)(rep);
             }
         }
     };