core-3nweb-client-lib 0.27.4 → 0.27.6

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

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2020 3NSoft Inc.
+ Copyright (C) 2020, 2022 3NSoft Inc.
 
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -18,7 +18,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeInProcessCryptor = void 0;
 const ecma_nacl_1 = require("ecma-nacl");
-function inNextTick(f) {
+const cryptor_work_labels_1 = require("../cryptor-work-labels");
+function onNextTick(f) {
     return new Promise((resolve, reject) => process.nextTick(() => {
         try {
             resolve(f());
@@ -30,24 +31,26 @@ function inNextTick(f) {
 }
 function makeInProcessCryptor() {
     const arrFactory = ecma_nacl_1.arrays.makeFactory();
+    const workExecutor = new cryptor_work_labels_1.InProcAsyncExecutor();
     return {
-        scrypt: (passwd, salt, logN, r, p, dkLen, progressCB) => inNextTick(() => (0, ecma_nacl_1.scrypt)(passwd, salt, logN, r, p, dkLen, progressCB, arrFactory)),
+        scrypt: (passwd, salt, logN, r, p, dkLen, progressCB) => onNextTick(() => (0, ecma_nacl_1.scrypt)(passwd, salt, logN, r, p, dkLen, progressCB, arrFactory)),
         box: {
-            calc_dhshared_key: (pk, sk) => inNextTick(() => ecma_nacl_1.box.calc_dhshared_key(pk, sk, arrFactory)),
-            generate_pubkey: sk => inNextTick(() => ecma_nacl_1.box.generate_pubkey(sk, arrFactory))
+            calc_dhshared_key: (pk, sk) => onNextTick(() => ecma_nacl_1.box.calc_dhshared_key(pk, sk, arrFactory)),
+            generate_pubkey: sk => onNextTick(() => ecma_nacl_1.box.generate_pubkey(sk, arrFactory))
         },
         sbox: {
-            open: (c, n, k) => inNextTick(() => ecma_nacl_1.secret_box.open(c, n, k, arrFactory)),
-            pack: (m, n, k) => inNextTick(() => ecma_nacl_1.secret_box.pack(m, n, k, arrFactory)),
+            canStartUnderWorkLabel: l => workExecutor.canStartUnderWorkLabel(l),
+            open: (c, n, k, workLabel) => workExecutor.execOpOnNextTick(workLabel, () => ecma_nacl_1.secret_box.open(c, n, k, arrFactory)),
+            pack: (m, n, k, workLabel) => workExecutor.execOpOnNextTick(workLabel, () => ecma_nacl_1.secret_box.pack(m, n, k, arrFactory)),
             formatWN: {
-                open: (cn, k) => inNextTick(() => ecma_nacl_1.secret_box.formatWN.open(cn, k, arrFactory)),
-                pack: (m, n, k) => inNextTick(() => ecma_nacl_1.secret_box.formatWN.pack(m, n, k, arrFactory))
+                open: (cn, k, workLabel) => workExecutor.execOpOnNextTick(workLabel, () => ecma_nacl_1.secret_box.formatWN.open(cn, k, arrFactory)),
+                pack: (m, n, k, workLabel) => workExecutor.execOpOnNextTick(workLabel, () => ecma_nacl_1.secret_box.formatWN.pack(m, n, k, arrFactory))
             }
         },
         signing: {
-            generate_keypair: seed => inNextTick(() => ecma_nacl_1.signing.generate_keypair(seed, arrFactory)),
-            signature: (m, sk) => inNextTick(() => ecma_nacl_1.signing.signature(m, sk, arrFactory)),
-            verify: (sig, m, pk) => inNextTick(() => ecma_nacl_1.signing.verify(sig, m, pk, arrFactory))
+            generate_keypair: seed => onNextTick(() => ecma_nacl_1.signing.generate_keypair(seed, arrFactory)),
+            signature: (m, sk) => onNextTick(() => ecma_nacl_1.signing.signature(m, sk, arrFactory)),
+            verify: (sig, m, pk) => onNextTick(() => ecma_nacl_1.signing.verify(sig, m, pk, arrFactory))
         }
     };
 }

package/build/lib-client/cryptor/in-proc-wasm.js

@@ -25,6 +25,7 @@ const cryptor_proto_1 = require("../../protos/cryptor.proto");
 const deferred_1 = require("../../lib-common/processes/deferred");
 const assert_1 = require("../../lib-common/assert");
 const error_1 = require("../../lib-common/exceptions/error");
+const cryptor_work_labels_1 = require("../cryptor-work-labels");
 function wasmBytes() {
     // There is a bug with electrons 12, 13, that doesn't let
     // worker_thread read this file from asar pack, even though main thread
@@ -68,6 +69,7 @@ function makeInProcessWasmCryptor() {
     const wasmInstance = (0, wasm_mp1_modules_1.startWasmFrom)(wasmBytes());
     let deferred = undefined;
     let interimSink = undefined;
+    const execCounter = new cryptor_work_labels_1.ExecCounter(() => (deferred ? 0 : 1));
     async function call(req, interim) {
         // In LiquidCore on iOS call was able to get before completion of
         // previous call, therefore, the following await loop is needed.
@@ -129,23 +131,24 @@ function makeInProcessWasmCryptor() {
             })
         },
         sbox: {
-            open: (c, n, k) => call({
+            canStartUnderWorkLabel: l => execCounter.canStartUnderWorkLabel(l),
+            open: (c, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, call({
                 func: 4,
                 byteArgs: toArgs(c, n, k)
-            }),
-            pack: (m, n, k) => call({
+            })),
+            pack: (m, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, call({
                 func: 5,
                 byteArgs: toArgs(m, n, k)
-            }),
+            })),
             formatWN: {
-                open: (cn, k) => call({
+                open: (cn, k, workLabel) => execCounter.wrapOpPromise(workLabel, call({
                     func: 6,
                     byteArgs: toArgs(cn, k)
-                }),
-                pack: (m, n, k) => call({
+                })),
+                pack: (m, n, k, workLabel) => execCounter.wrapOpPromise(workLabel, call({
                     func: 7,
                     byteArgs: toArgs(m, n, k)
-                })
+                }))
             }
         },
         signing: {

package/build/lib-client/cryptor/serialization-for-wasm.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import { signing } from 'ecma-nacl';
+export interface WasmScryptRequest {
+    func: 1;
+    scryptArgs: {
+        passwd: Uint8Array;
+        salt: Uint8Array;
+        logN: number;
+        r: number;
+        p: number;
+        dkLen: number;
+    };
+}
+export interface WasmBinArgsRequest {
+    func: 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+    byteArgs: ByteArg[];
+}
+export interface ByteArg {
+    val: Uint8Array;
+}
+export declare function toArgs(...args: Uint8Array[]): ByteArg[];
+export declare type WasmRequest = WasmScryptRequest | WasmBinArgsRequest;
+export interface WasmReply {
+    res?: ByteArg;
+    interim?: ByteArg;
+    err?: ReplyError;
+}
+export interface ReplyError {
+    condition: 'cipher-verification' | 'signature-verification' | 'configuration-error' | 'message-passing-error';
+    message: string;
+}
+export declare function toLocalErr(replyErr: ReplyError): Error | web3n.EncryptionException;
+export declare function packRequestToWASM(req: WasmRequest): Buffer;
+export declare function unpackReplyFromWASM(replyBytes: Buffer): WasmReply;
+export declare function unpackSigningKeyPair(bytes: Buffer): signing.Keypair;
+export declare function unpackBoolVal(bytes: Buffer): boolean;

package/build/lib-client/cryptor/serialization-for-wasm.js

@@ -0,0 +1,58 @@
+"use strict";
+/*
+ Copyright (C) 2021 - 2022 3NSoft Inc.
+
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unpackBoolVal = exports.unpackSigningKeyPair = exports.unpackReplyFromWASM = exports.packRequestToWASM = exports.toLocalErr = exports.toArgs = void 0;
+const protobuf_type_1 = require("../protobuf-type");
+const cryptor_proto_1 = require("../../protos/cryptor.proto");
+function toArgs(...args) {
+    return args.map(val => ({ val }));
+}
+exports.toArgs = toArgs;
+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}`);
+    }
+}
+exports.toLocalErr = toLocalErr;
+const wasmRequestProtoType = protobuf_type_1.ProtoType.for(cryptor_proto_1.cryptor.Request);
+const wasmReplyProtoType = protobuf_type_1.ProtoType.for(cryptor_proto_1.cryptor.Reply);
+function packRequestToWASM(req) {
+    return wasmRequestProtoType.pack(req);
+}
+exports.packRequestToWASM = packRequestToWASM;
+function unpackReplyFromWASM(replyBytes) {
+    return wasmReplyProtoType.unpack(replyBytes);
+}
+exports.unpackReplyFromWASM = unpackReplyFromWASM;
+const boolValType = protobuf_type_1.ProtoType.for(cryptor_proto_1.cryptor.BoolVal);
+const kpairType = protobuf_type_1.ProtoType.for(cryptor_proto_1.cryptor.Keypair);
+function unpackSigningKeyPair(bytes) {
+    return kpairType.unpack(bytes);
+}
+exports.unpackSigningKeyPair = unpackSigningKeyPair;
+function unpackBoolVal(bytes) {
+    return boolValType.unpack(bytes).val;
+}
+exports.unpackBoolVal = unpackBoolVal;
+Object.freeze(exports);

package/build/lib-client/cryptor-work-labels.d.ts

@@ -0,0 +1,26 @@
+export declare namespace cryptoWorkLabels {
+    type LabelType = 'asmail' | 'storage';
+    function makeFor(type: LabelType, id: string): number;
+    function typeOf(label: number): LabelType | undefined;
+    function makeForNonce(type: LabelType, n: Uint8Array): number;
+    function makeRandom(type: LabelType): number;
+}
+export declare abstract class LabeledWorkQueues {
+    private readonly workQueues;
+    protected addToWorkQueue(workLabel: number): void;
+    protected removeFromWorkQueue(workLabel: number): void;
+    protected abstract idleWorkers(): number;
+    canStartUnderWorkLabel(workLabel: number): number;
+    wrapOpPromise<T>(workLabel: number, workOp: Promise<T>): Promise<T>;
+}
+export declare class InProcAsyncExecutor extends LabeledWorkQueues {
+    private readonly maxOfRunning;
+    private opsInExec;
+    constructor(maxOfRunning?: number);
+    idleWorkers(): number;
+    execOpOnNextTick<T>(workLabel: number, op: () => T): Promise<T>;
+}
+export declare class ExecCounter extends LabeledWorkQueues {
+    protected readonly idleWorkers: () => number;
+    constructor(idleWorkers: () => number);
+}

package/build/lib-client/cryptor-work-labels.js

@@ -0,0 +1,152 @@
+"use strict";
+/*
+ Copyright (C) 2022 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecCounter = exports.InProcAsyncExecutor = exports.LabeledWorkQueues = exports.cryptoWorkLabels = void 0;
+var cryptoWorkLabels;
+(function (cryptoWorkLabels) {
+    function makeFor(type, id) {
+        const low = charsToNumber(id, 0, 5);
+        const high = labelToHighNum(type) + charsToNumber(id, 0, 3) & 0x1ffff;
+        return (low + (high * 0x100000000));
+    }
+    cryptoWorkLabels.makeFor = makeFor;
+    function labelToHighNum(type) {
+        switch (type) {
+            case 'storage':
+                return 1 << 17;
+            case 'asmail':
+                return 2 << 17;
+        }
+    }
+    function typeOf(label) {
+        switch ((label / 0x100000000) >> 17) {
+            case 1:
+                return 'storage';
+            case 2:
+                return 'asmail';
+            default:
+                return;
+        }
+    }
+    cryptoWorkLabels.typeOf = typeOf;
+    function charsToNumber(s, start, len) {
+        const rounds = Math.max(Math.min(s.length - start, len), 0);
+        let num = 0;
+        for (let i = 0; i < rounds; i += 1) {
+            num ^= s.charCodeAt(i) << (i * 7);
+        }
+        return num;
+    }
+    function makeForNonce(type, n) {
+        const low = n[0] + (n[1] << 8) + (n[2] << 16) + (n[3] << 24);
+        const high = labelToHighNum(type) +
+            (n[4] + (n[5] << 8) + (n[6] << 16)) & 0x1ffff;
+        return (low + (high * 0x100000000));
+    }
+    cryptoWorkLabels.makeForNonce = makeForNonce;
+    function makeRandom(type) {
+        const low = (Math.random() * 0xffffffff) & 0xffffffff;
+        const high = labelToHighNum(type) +
+            (Math.random() * 0x1ffff) & 0x1ffff;
+        return (low + (high * 0x100000000));
+    }
+    cryptoWorkLabels.makeRandom = makeRandom;
+})(cryptoWorkLabels = exports.cryptoWorkLabels || (exports.cryptoWorkLabels = {}));
+Object.freeze(cryptoWorkLabels);
+class LabeledWorkQueues {
+    constructor() {
+        this.workQueues = new Map();
+    }
+    addToWorkQueue(workLabel) {
+        const inQueue = this.workQueues.get(workLabel);
+        this.workQueues.set(workLabel, (inQueue ? inQueue + 1 : 1));
+    }
+    removeFromWorkQueue(workLabel) {
+        const inQueue = this.workQueues.get(workLabel);
+        if (inQueue && (inQueue > 1)) {
+            this.workQueues.set(workLabel, inQueue - 1);
+        }
+        else {
+            this.workQueues.delete(workLabel);
+        }
+    }
+    canStartUnderWorkLabel(workLabel) {
+        const maxIdle = this.idleWorkers() - this.workQueues.size;
+        if (maxIdle <= 0) {
+            return (this.workQueues.has(workLabel) ? 0 : 1);
+        }
+        const inQueue = this.workQueues.get(workLabel);
+        return (inQueue ? Math.max(0, inQueue) : maxIdle);
+    }
+    async wrapOpPromise(workLabel, workOp) {
+        this.addToWorkQueue(workLabel);
+        try {
+            return await workOp;
+        }
+        finally {
+            this.removeFromWorkQueue(workLabel);
+        }
+    }
+}
+exports.LabeledWorkQueues = LabeledWorkQueues;
+Object.freeze(LabeledWorkQueues.prototype);
+Object.freeze(LabeledWorkQueues);
+class InProcAsyncExecutor extends LabeledWorkQueues {
+    constructor(maxOfRunning = 1) {
+        super();
+        this.maxOfRunning = maxOfRunning;
+        this.opsInExec = 0;
+        Object.seal(this);
+    }
+    idleWorkers() {
+        return Math.max((this.maxOfRunning - this.opsInExec), 0);
+    }
+    async execOpOnNextTick(workLabel, op) {
+        this.opsInExec += 1;
+        try {
+            return await this.wrapOpPromise(workLabel, onNextTick(op));
+        }
+        finally {
+            this.opsInExec -= 1;
+        }
+    }
+}
+exports.InProcAsyncExecutor = InProcAsyncExecutor;
+Object.freeze(InProcAsyncExecutor.prototype);
+Object.freeze(InProcAsyncExecutor);
+class ExecCounter extends LabeledWorkQueues {
+    constructor(idleWorkers) {
+        super();
+        this.idleWorkers = idleWorkers;
+        Object.seal(this);
+    }
+}
+exports.ExecCounter = ExecCounter;
+Object.freeze(ExecCounter.prototype);
+Object.freeze(ExecCounter);
+async function onNextTick(action) {
+    return new Promise((resolve, reject) => process.nextTick(() => {
+        try {
+            resolve(action());
+        }
+        catch (err) {
+            reject(err);
+        }
+    }));
+}
+Object.freeze(exports);

package/build/lib-client/fs-sync-utils.d.ts

@@ -1,5 +1,11 @@
+import { Observable } from "rxjs";
 declare type WritableFS = web3n.files.WritableFS;
-export declare function getRemoteFolderChanges(fs: WritableFS): Promise<void>;
+declare type ReadonlyFS = web3n.files.ReadonlyFS;
+declare type RemoteEvent = web3n.files.RemoteEvent;
+declare type FileEvent = web3n.files.FileEvent;
+declare type FolderEvent = web3n.files.FolderEvent;
+export declare function getRemoteFolderChanges(fs: WritableFS, forceServerCheck?: boolean): Promise<void>;
 export declare function getOrMakeAndUploadFolderIn(fs: WritableFS, folder: string): Promise<WritableFS>;
 export declare function uploadFolderChangesIfAny(fs: WritableFS): Promise<void>;
+export declare function observableFromTreeEvents(fs: ReadonlyFS, rootPath: string): Observable<RemoteEvent | FileEvent | FolderEvent>;
 export {};

package/build/lib-client/fs-sync-utils.js

@@ -16,11 +16,18 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadFolderChangesIfAny = exports.getOrMakeAndUploadFolderIn = exports.getRemoteFolderChanges = void 0;
+exports.observableFromTreeEvents = exports.uploadFolderChangesIfAny = exports.getOrMakeAndUploadFolderIn = exports.getRemoteFolderChanges = void 0;
+const rxjs_1 = require("rxjs");
 const exceptions_1 = require("./3nstorage/exceptions");
-async function getRemoteFolderChanges(fs) {
-    const { state } = await fs.v.sync.updateStatusInfo('');
+async function getRemoteFolderChanges(fs, forceServerCheck = false) {
+    if (forceServerCheck) {
+        await fs.v.sync.updateStatusInfo('');
+    }
+    let { state } = await fs.v.sync.status('');
     if (state === 'behind') {
+        if (!forceServerCheck) {
+            await fs.v.sync.updateStatusInfo('');
+        }
         await fs.v.sync.adoptRemote('');
     }
     else if (state === 'conflicting') {
@@ -51,11 +58,15 @@ async function getOrMakeAndUploadFolderIn(fs, folder) {
 }
 exports.getOrMakeAndUploadFolderIn = getOrMakeAndUploadFolderIn;
 async function uploadFolderChangesIfAny(fs) {
-    const { state } = await fs.v.sync.updateStatusInfo('');
-    if ((state === 'synced') || (state === 'behind')) {
-        return;
+    const { state } = await fs.v.sync.status('');
+    if (state === 'unsynced') {
+        await fs.v.sync.updateStatusInfo('');
+        await fs.v.sync.upload('');
     }
-    await fs.v.sync.upload('');
 }
 exports.uploadFolderChangesIfAny = uploadFolderChangesIfAny;
+function observableFromTreeEvents(fs, rootPath) {
+    return new rxjs_1.Observable(obs => fs.watchTree(rootPath, undefined, obs));
+}
+exports.observableFromTreeEvents = observableFromTreeEvents;
 Object.freeze(exports);

package/build/lib-client/local-files/dev-file-src.d.ts

@@ -12,7 +12,8 @@ export declare class DevFileByteSource implements ByteSource {
         size: number;
         isEndless: boolean;
     }>;
-    read(len: number): Promise<Uint8Array | undefined>;
+    readNext(len: number): Promise<Uint8Array | undefined>;
     seek(offset: number): Promise<void>;
+    readAt(pos: number, len: number): Promise<Uint8Array | undefined>;
     getPosition(): Promise<number>;
 }

package/build/lib-client/local-files/dev-file-src.js

@@ -34,7 +34,7 @@ class DevFileByteSource {
     async getSize() {
         return { size: this.size, isEndless: false };
     }
-    async read(len) {
+    async readNext(len) {
         if (this.offset >= this.size) {
             return;
         }
@@ -68,6 +68,10 @@ class DevFileByteSource {
         }
         this.offset = offset;
     }
+    async readAt(pos, len) {
+        await this.seek(pos);
+        return await this.readNext(len);
+    }
     async getPosition() {
         return this.offset;
     }

package/build/lib-client/local-files/device-fs.js

@@ -413,7 +413,8 @@ class DeviceFS {
         return {
             getPosition: byteSrc.getPosition,
             getSize: async () => (await byteSrc.getSize()).size,
-            read: byteSrc.read,
+            readNext: byteSrc.readNext,
+            readAt: byteSrc.readAt,
             seek: byteSrc.seek
         };
     }

package/build/lib-client/objs-on-disk/obj-on-disk.js

@@ -217,7 +217,7 @@ class ByteSourceFromObjOnDisk {
         this.segsPointer = 0;
         Object.seal(this);
     }
-    async read(len) {
+    async readNext(len) {
         (0, assert_1.assert)((Number.isInteger(len) && (len >= 0)) || (len === undefined), 'Illegal length parameter given: ' + len);
         const start = this.segsPointer;
         if (len === undefined) {
@@ -250,6 +250,10 @@ class ByteSourceFromObjOnDisk {
             this.segsPointer = Math.min(offset, segsLen);
         }
     }
+    async readAt(pos, len) {
+        await this.seek(pos);
+        return await this.readNext(len);
+    }
     async getPosition() {
         return this.segsPointer;
     }

package/build/lib-client/request-utils.js

@@ -72,7 +72,7 @@ function formHttpsReqOpts(opts, contentType, reqBody) {
     return netReqOpts;
 }
 exports.formHttpsReqOpts = formHttpsReqOpts;
-function attachRequestReaders(clReq, opts) {
+async function attachRequestReaders(clReq, opts) {
     // XXX do something for timeouts, that doesn't break good long connections
     // const timeout = (opts.timeout ? opts.timeout : DEFAULT_TIMEOUT);
     // note that we attach reading of body to response as close as possible to
@@ -80,23 +80,23 @@ function attachRequestReaders(clReq, opts) {
     // next tick occurs in between.
     const response$ = (0, rxjs_1.fromEvent)(clReq, 'response', (res) => ({ res, resBodyPromise: readAllBytesFrom(res) }))
         .pipe((0, operators_1.take)(1));
-    const err$ = (0, rxjs_1.fromEvent)(clReq, 'error')
-        .pipe((0, operators_1.map)(e => {
-        throw (0, http_1.makeConnectionException)(opts.url, opts.method, 'Cannot connect', e);
-    }), (0, operators_1.takeUntil)(response$));
-    return (0, rxjs_1.merge)(response$, err$)
-        .pipe((0, operators_1.mergeMap)(async (resAndBodyProm) => {
-        const { res, resBodyPromise } = resAndBodyProm;
-        const resBody = await resBodyPromise;
-        return { res, resBody };
-    }, 1))
-        .toPromise()
-        .catch((exc) => {
+    const err$ = (0, rxjs_1.fromEvent)(clReq, 'error', e => (0, http_1.makeConnectionException)(opts.url, opts.method, 'Cannot connect', e))
+        .pipe((0, operators_1.map)(exc => { throw exc; }), (0, operators_1.takeUntil)(response$));
+    try {
+        const reply = await (0, rxjs_1.lastValueFrom)((0, rxjs_1.merge)(response$, err$)
+            .pipe((0, operators_1.mergeMap)(async (resAndBodyProm) => {
+            const { res, resBodyPromise } = resAndBodyProm;
+            const resBody = await resBodyPromise;
+            return { res, resBody };
+        }, 1)));
+        return reply;
+    }
+    catch (exc) {
         if (exc.cause === TIMEOUT_FLAG) {
             clReq.abort();
         }
         throw exc;
-    });
+    }
 }
 const TIMEOUT_FLAG = 'Request Timeout';
 function isTimeoutErr(err, opts, currentAttempt) {

package/build/lib-common/async-cryptor-wrap.d.ts

@@ -41,6 +41,7 @@ export interface Decryptor {
  * This returns an encryptor that packs bytes according to "with-nonce" format,
  * keeping track and automatically advancing nonce.
  * @param cryptor is an async cryptor that will be used by created encryptor.
+ * @param workLabel
  * @param key for new encryptor.
  * Note that key will be copied, thus, if given array shall never be used
  * anywhere, it should be wiped after this call.
@@ -51,16 +52,15 @@ export interface Decryptor {
  * @param delta is a number between 1 and 255 inclusive, used to advance nonce.
  * When missing, it defaults to one.
  */
-export declare function makeEncryptor(cryptor: AsyncSBoxCryptor, key: Uint8Array, nextNonce: Uint8Array, delta?: number): Encryptor;
+export declare function makeEncryptor(cryptor: AsyncSBoxCryptor, workLabel: number, key: Uint8Array, nextNonce: Uint8Array, delta?: number): Encryptor;
 /**
- *
+ * @param cryptor
+ * @param workLabel
  * @param key for new decryptor.
- * @param arrFactory is typed arrays factory, used to allocated/find an array for use.
- * It may be undefined, in which case an internally created one is used.
- * Note that key will be copied, thus, if given array shall never be used anywhere,
- * it should be wiped after this call.
+ * Note that key will be copied, thus, if given array shall never be used
+ * anywhere, it should be wiped after this call.
  * @return a frozen object with pack & open and destroy functions.
  */
-export declare function makeDecryptor(cryptor: AsyncSBoxCryptor, key: Uint8Array): Decryptor;
-export declare function makeDecryptorForKeyPair(cryptor: AsyncSBoxCryptor, pkey: Uint8Array, skey: Uint8Array): Decryptor;
-export declare function makeEncryptorWithKeyPair(cryptor: AsyncSBoxCryptor, pkey: Uint8Array, skey: Uint8Array, nextNonce: Uint8Array, delta?: number): Encryptor;
+export declare function makeDecryptor(cryptor: AsyncSBoxCryptor, workLabel: number, key: Uint8Array): Decryptor;
+export declare function makeDecryptorForKeyPair(cryptor: AsyncSBoxCryptor, workLabel: number, pkey: Uint8Array, skey: Uint8Array): Decryptor;
+export declare function makeEncryptorWithKeyPair(cryptor: AsyncSBoxCryptor, workLabel: number, pkey: Uint8Array, skey: Uint8Array, nextNonce: Uint8Array, delta?: number): Encryptor;

package/build/lib-common/async-cryptor-wrap.js

@@ -23,6 +23,7 @@ const buffer_utils_1 = require("./buffer-utils");
  * This returns an encryptor that packs bytes according to "with-nonce" format,
  * keeping track and automatically advancing nonce.
  * @param cryptor is an async cryptor that will be used by created encryptor.
+ * @param workLabel
  * @param key for new encryptor.
  * Note that key will be copied, thus, if given array shall never be used
  * anywhere, it should be wiped after this call.
@@ -33,7 +34,7 @@ const buffer_utils_1 = require("./buffer-utils");
  * @param delta is a number between 1 and 255 inclusive, used to advance nonce.
  * When missing, it defaults to one.
  */
-function makeEncryptor(cryptor, key, nextNonce, delta) {
+function makeEncryptor(cryptor, workLabel, key, nextNonce, delta) {
     if (!(nextNonce instanceof Uint8Array)) {
         throw new TypeError("Nonce array nextNonce must be Uint8Array.");
     }
@@ -64,7 +65,7 @@ function makeEncryptor(cryptor, key, nextNonce, delta) {
             if (counter > counterMax) {
                 throw new Error(`This encryptor has been used too many times. Further use may lead to duplication of nonces.`);
             }
-            const c = await cryptor.formatWN.pack(m, nextNonce, key);
+            const c = await cryptor.formatWN.pack(m, nextNonce, key, workLabel);
             (0, xsp_files_1.advanceNonce)(nextNonce, delta);
             counter += 1;
             return c;
@@ -86,15 +87,14 @@ function makeEncryptor(cryptor, key, nextNonce, delta) {
 }
 exports.makeEncryptor = makeEncryptor;
 /**
- *
+ * @param cryptor
+ * @param workLabel
  * @param key for new decryptor.
- * @param arrFactory is typed arrays factory, used to allocated/find an array for use.
- * It may be undefined, in which case an internally created one is used.
- * Note that key will be copied, thus, if given array shall never be used anywhere,
- * it should be wiped after this call.
+ * Note that key will be copied, thus, if given array shall never be used
+ * anywhere, it should be wiped after this call.
  * @return a frozen object with pack & open and destroy functions.
  */
-function makeDecryptor(cryptor, key) {
+function makeDecryptor(cryptor, workLabel, key) {
     if (!(key instanceof Uint8Array)) {
         throw new TypeError("Key array key must be Uint8Array.");
     }
@@ -107,7 +107,7 @@ function makeDecryptor(cryptor, key) {
             if (!key) {
                 throw new Error(`This decryptor cannot be used, as it had already been destroyed.`);
             }
-            return cryptor.formatWN.open(c, key);
+            return cryptor.formatWN.open(c, key, workLabel);
         },
         destroy: () => {
             if (!key) {
@@ -120,16 +120,16 @@ function makeDecryptor(cryptor, key) {
     return Object.freeze(decryptor);
 }
 exports.makeDecryptor = makeDecryptor;
-function makeDecryptorForKeyPair(cryptor, pkey, skey) {
+function makeDecryptorForKeyPair(cryptor, workLabel, pkey, skey) {
     const dhSharedKey = ecma_nacl_1.box.calc_dhshared_key(pkey, skey);
-    const decryptor = makeDecryptor(cryptor, dhSharedKey);
+    const decryptor = makeDecryptor(cryptor, workLabel, dhSharedKey);
     dhSharedKey.fill(0);
     return decryptor;
 }
 exports.makeDecryptorForKeyPair = makeDecryptorForKeyPair;
-function makeEncryptorWithKeyPair(cryptor, pkey, skey, nextNonce, delta) {
+function makeEncryptorWithKeyPair(cryptor, workLabel, pkey, skey, nextNonce, delta) {
     const dhSharedKey = ecma_nacl_1.box.calc_dhshared_key(pkey, skey);
-    const decryptor = makeEncryptor(cryptor, dhSharedKey, nextNonce, delta);
+    const decryptor = makeEncryptor(cryptor, workLabel, dhSharedKey, nextNonce, delta);
     dhSharedKey.fill(0);
     return decryptor;
 }