core-3nweb-client-lib 0.49.7 → 0.50.0

package/build/core/asmail/sending-params/params-from-others.d.ts

@@ -1,17 +1,7 @@
 import { SendingParamsHolder } from '../sending-params';
-export { SendingParams } from '../msg/common';
-type ExposedFuncs = SendingParamsHolder['otherSides'];
-type WritableFile = web3n.files.WritableFile;
-type FileEvent = web3n.files.FileEvent;
-export declare class ParamsFromOthers {
-    private readonly params;
-    private readonly fileProc;
-    private constructor();
-    static makeAndInit(file: WritableFile): Promise<ParamsFromOthers>;
-    private absorbRemoteChanges;
-    protected onFileEvent(ev: FileEvent): Promise<void>;
-    getFor: ExposedFuncs['get'];
-    setFor: ExposedFuncs['set'];
-    private persist;
-    close(): Promise<void>;
-}
+export type { SendingParams } from '../msg/common';
+type WritableFS = web3n.files.WritableFS;
+export type ParamsFromOthers = Awaited<ReturnType<typeof makeParamsFromOthers>>;
+export declare function makeParamsFromOthers(fs: WritableFS, fileName: string): Promise<SendingParamsHolder['otherSides'] & {
+    close: () => Promise<void>;
+}>;

package/build/core/asmail/sending-params/params-from-others.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2017 - 2018, 2025 3NSoft Inc.
+ Copyright (C) 2017 - 2018, 2025 - 2026 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
@@ -16,73 +16,103 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParamsFromOthers = void 0;
-const file_based_json_1 = require("../../../lib-client/xsp-fs/util/file-based-json");
-class ParamsFromOthers {
-    constructor() {
-        this.params = new Map();
-        this.getFor = (address) => {
-            const p = this.params.get(address);
-            if (!p) {
-                return;
+exports.makeParamsFromOthers = makeParamsFromOthers;
+const single_file_1 = require("../../../lib-common/dataset-sync/single-file");
+async function makeParamsFromOthers(fs, fileName) {
+    const { file: paramsFile, changeProc } = await (0, single_file_1.initSyncedFile)(fs, fileName, newFile => newFile.writeJSON([]));
+    function parseParamsFromJSON(json) {
+        if (Array.isArray(json)) {
+            // older serialization form
+            const p = {};
+            for (const paramsForSending of json) {
+                const { address, timestamp, auth, invitation } = paramsForSending;
+                p[address] = { timestamp, auth, invitation };
             }
-            return copyParams(p);
-        };
-        this.setFor = (address, params) => {
-            return this.fileProc.order.startOrChain(async () => {
-                const existing = this.params.get(address);
-                if (existing && (existing.timestamp >= params.timestamp)) {
-                    return;
-                }
-                const p = { address };
-                copyParams(params, p);
-                this.params.set(p.address, p);
-                await this.persist();
-            });
-        };
-        this.fileProc = new file_based_json_1.JsonFileProc(this.onFileEvent.bind(this));
-        Object.seal(this);
-    }
-    static async makeAndInit(file) {
-        const paramsFromOthers = new ParamsFromOthers();
-        await paramsFromOthers.fileProc.start(file, []);
-        await paramsFromOthers.absorbRemoteChanges();
-        return paramsFromOthers;
+            return p;
+        }
+        else if (json && (typeof json === 'object')) {
+            return json;
+        }
+        else {
+            return {};
+        }
     }
-    async absorbRemoteChanges() {
-        // XXX
-        //  - check for changes: what is needed here from fileProc, and what is
-        //    generic in absorbing remote changes to refactor it into JsonFileProc
-        //  - absorb and sync, if needed: what can be in JsonFileProc
-        // Code from pre-v.sync:
-        // const { json } = await this.fileProc.get();
-        // this.setFromJSON(json);
+    let params = parseParamsFromJSON(await paramsFile.readJSON());
+    async function onChangeFromOtherDevices(newVersion) {
+        changeProc.startOrChain(async () => {
+            const { version, json } = await paramsFile.v.readJSON();
+            if (version === newVersion) {
+                const incomingParams = parseParamsFromJSON(json);
+                mergeIncomingParams(incomingParams);
+            }
+        });
     }
-    async onFileEvent(ev) {
-        if (ev.src === 'local') {
-            return;
+    function mergeIncomingParams(incomingParams) {
+        for (const [address, inP] of Object.entries(incomingParams)) {
+            const existing = params[address];
+            if (existing && (existing.timestamp >= inP.timestamp)) {
+                return;
+            }
+            params[address] = inP;
         }
-        switch (ev.type) {
-            case 'file-change':
-                await this.fileProc.order.startOrChain(() => this.absorbRemoteChanges());
-                break;
-            case 'removed':
-                throw new Error(`Unexpected removal of file with invites info`);
-            default:
+    }
+    function doOnConflict() {
+        return changeProc.startOrChain(async () => {
+            const { remote, state } = await paramsFile.v.sync.status(false);
+            if ((state !== 'conflicting') || !(remote === null || remote === void 0 ? void 0 : remote.latest)) {
                 return;
+            }
+            const onRemote = parseParamsFromJSON((await paramsFile.v.readJSON({ remoteVersion: remote.latest })).json);
+            const numRemRecs = Object.keys(onRemote).length;
+            const numExistingRecs = Object.keys(params).length;
+            let paramsWhereUpdated = (numExistingRecs > numRemRecs);
+            for (const [address, inP] of Object.entries(onRemote)) {
+                const existing = params[address];
+                if (existing.timestamp < inP.timestamp) {
+                    params[address] = inP;
+                    paramsWhereUpdated = true;
+                }
+                else if (existing.timestamp > inP.timestamp) {
+                    paramsWhereUpdated = true;
+                }
+            }
+            if (paramsWhereUpdated) {
+                await paramsFile.v.sync.upload({ uploadVersion: remote.latest + 1 });
+            }
+            else {
+                await paramsFile.v.sync.adoptRemote({ remoteVersion: remote.latest });
+            }
+        });
+    }
+    const { stopFileWatching, triggerUpload } = (0, single_file_1.watchAndApplyChangesFromOtherDevices)(paramsFile, changeProc, onChangeFromOtherDevices, doOnConflict);
+    function get(address) {
+        const p = params[address];
+        if (!p) {
+            return;
         }
+        return copyParams(p);
     }
-    async persist() {
-        const json = Array.from(this.params.values());
-        await this.fileProc.save(json, false);
+    ;
+    async function set(address, params) {
+        return changeProc.startOrChain(async () => {
+            const existing = params[address];
+            if (existing && (existing.timestamp >= params.timestamp)) {
+                return;
+            }
+            params[address] = copyParams(params);
+            await paramsFile.writeJSON(params);
+            triggerUpload();
+        });
     }
-    async close() {
-        await this.fileProc.close();
+    async function close() {
+        stopFileWatching();
     }
+    return {
+        get,
+        set,
+        close
+    };
 }
-exports.ParamsFromOthers = ParamsFromOthers;
-Object.freeze(ParamsFromOthers.prototype);
-Object.freeze(ParamsFromOthers);
 /**
  * This copies SendingParams' fields, returning a copy, which was either
  * created, or given.

package/build/core/index.d.ts

@@ -7,6 +7,7 @@ export type { makeCryptor } from 'ecma-nacl-cryptors';
 type RequestedCAPs = web3n.caps.common.RequestedCAPs;
 type W3N = web3n.caps.common.W3N;
 type ProgressCB = web3n.startup.ProgressCB;
+type FSItem = web3n.files.FSItem;
 export interface CoreConf {
     dataDir: string;
     signUpUrl: string;
@@ -27,7 +28,7 @@ export declare class Core {
     private closingProc;
     private isInitialized;
     private constructor();
-    static make(conf: CoreConf, makeNet: MakeNet, makeResolver: ServiceLocatorMaker, makeCryptor: makeCryptor, random: AsyncRNG): Core;
+    static make(conf: CoreConf, makeNet: MakeNet, makeResolver: ServiceLocatorMaker, sysFilesOnDevice: () => Promise<FSItem>, makeCryptor: makeCryptor, random: AsyncRNG): Core;
     start(saveStorageKeyForAutologin?: (storageKey: Uint8Array) => void): {
         capsForStartup: web3n.startup.W3N;
         coreInit: Promise<string>;

package/build/core/index.js

@@ -31,7 +31,7 @@ const constants_1 = require("./storage/common/constants");
 const config_1 = require("./asmail/config");
 const deferred_1 = require("../lib-common/processes/deferred");
 class Core {
-    constructor(makeNet, makeResolver, makeCryptor, random, appDirs, logger, signUpUrl) {
+    constructor(makeNet, makeResolver, makeCryptor, random, appDirs, sysFilesOnDevice, logger, signUpUrl) {
         this.makeNet = makeNet;
         this.makeResolver = makeResolver;
         this.random = random;
@@ -43,14 +43,14 @@ class Core {
         this.closingProc = undefined;
         this.isInitialized = false;
         this.cryptor = makeCryptor(this.logger.logError, this.logger.logWarning);
-        this.storages = new storage_1.Storages(this.cryptor.cryptor.sbox, this.random, this.appDirs.storagePathFor);
+        this.storages = new storage_1.Storages(this.cryptor.cryptor.sbox, this.random, this.appDirs.storagePathFor, sysFilesOnDevice);
         this.asmail = new asmail_1.ASMail(this.cryptor.cryptor.sbox, this.random, this.makeNet, this.appDirs.inboxPathFor, this.logger);
         Object.seal(this);
     }
-    static make(conf, makeNet, makeResolver, makeCryptor, random) {
+    static make(conf, makeNet, makeResolver, sysFilesOnDevice, makeCryptor, random) {
         const dirs = (0, app_files_1.appDirs)(conf.dataDir);
         const logger = (0, log_to_file_1.makeLogger)(dirs.getUtilFS());
-        const core = new Core(makeNet, makeResolver, makeCryptor, random, dirs, logger, conf.signUpUrl);
+        const core = new Core(makeNet, makeResolver, makeCryptor, random, dirs, sysFilesOnDevice, logger, conf.signUpUrl);
         return core;
     }
     start(saveStorageKeyForAutologin) {

package/build/core/keyring/index.js

@@ -31,11 +31,10 @@ const buffer_utils_1 = require("../../lib-common/buffer-utils");
 var common_2 = require("./common");
 Object.defineProperty(exports, "KEY_USE", { enumerable: true, get: function () { return common_2.KEY_USE; } });
 const INTRO_KEYS_FOLDER = 'introductory-keys';
-const INTRO_KEY_ON_SERVER_FILE = `published-on-server.json`;
 async function makeKeyrings(cryptor, random, logger, fs, localFS, getSigner, pkeyOnServer) {
     const workLabel = cryptor_work_labels_1.cryptoWorkLabels.makeRandom('asmail');
-    const introKeysFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(fs, INTRO_KEYS_FOLDER);
-    const publishedKeys = await (0, published_intro_key_1.makeHolderOfPublishedIntroKey)(await introKeysFS.writableFile(INTRO_KEY_ON_SERVER_FILE), getSigner, random, pkeyOnServer);
+    const introKeysFS = await (0, fs_sync_utils_1.getOrMakeDirOnInit)(fs, INTRO_KEYS_FOLDER);
+    const publishedKeys = await (0, published_intro_key_1.makeHolderOfPublishedIntroKey)(introKeysFS, getSigner, random, pkeyOnServer);
     const peerKeys = await (0, peer_keys_1.makePeersKeyring)(fs, localFS, random, logger);
     async function generateIntroKeysToSendMsg(address, introPKeyFromServer) {
         if (introPKeyFromServer.alg !== ecma_nacl_1.box.JWK_ALG_NAME) {

package/build/core/keyring/introductory-keys/published-intro-key.d.ts

@@ -2,9 +2,9 @@ import { ParamOnServer } from '../../../lib-client/asmail/service-config';
 import { AsyncRNG } from '../../../lib-common/rng-def';
 import { GetSigner } from '../../id-manager';
 import { JWKeyPair, MsgKeyRole } from '../common';
-type WritableFile = web3n.files.WritableFile;
+type WritableFS = web3n.files.WritableFS;
 type IntroKeyCAP = web3n.keys.Keyrings['introKeyOnASMailServer'];
-export declare function makeHolderOfPublishedIntroKey(file: WritableFile, getSigner: GetSigner, random: AsyncRNG, pkeyOnServer: ParamOnServer<'init-pub-key'>): Promise<{
+export declare function makeHolderOfPublishedIntroKey(introKeysFS: WritableFS, getSigner: GetSigner, random: AsyncRNG, pkeyOnServer: ParamOnServer<'init-pub-key'>): Promise<{
     startExpiryCheckProcess: () => void;
     close: () => Promise<void>;
     makeIntroKeyCAP: () => IntroKeyCAP;

package/build/core/keyring/introductory-keys/published-intro-key.js

@@ -17,53 +17,34 @@
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeHolderOfPublishedIntroKey = makeHolderOfPublishedIntroKey;
-const file_based_json_1 = require("../../../lib-client/xsp-fs/util/file-based-json");
+const single_file_1 = require("../../../lib-common/dataset-sync/single-file");
 const jwkeys_1 = require("../../../lib-common/jwkeys");
 const common_1 = require("../common");
 const INTRO_KEY_VALIDITY = 31 * 24 * 60 * 60;
 const UPDATE_BEFORE_EXPIRY = 7 * 24 * 60 * 60;
-async function makeHolderOfPublishedIntroKey(file, getSigner, random, pkeyOnServer) {
+const MAX_NUM_OF_PREV = 3;
+const INTRO_KEY_ON_SERVER_FILE = `published-on-server.json`;
+async function makeHolderOfPublishedIntroKey(introKeysFS, getSigner, random, pkeyOnServer) {
     var _a;
-    let published = {
-        previous: []
-    };
-    // XXX JsonFileProc is too little, in comparison to operations syn, and watching file
-    const fileProc = new file_based_json_1.JsonFileProc(onFileEvent);
-    async function onFileEvent(ev) {
-        if (ev.src === 'local') {
-            return;
-        }
-        switch (ev.type) {
-            case 'file-change':
-                await fileProc.order.startOrChain(() => absorbRemoteChanges());
-                break;
-            case 'removed':
-                throw new Error(`Unexpected removal of file with parameter "anon-sender/invites"`);
-            default:
-                return;
-        }
-    }
-    function setFromJSON(json) {
-        if (!Array.isArray(json.previous)) { // migration part
-            json.previous = (json.previous ? [json.previous] : []);
-        }
-        published = json;
+    const { file: keysFile, changeProc } = await (0, single_file_1.initSyncedFile)(introKeysFS, INTRO_KEY_ON_SERVER_FILE, newFile => newFile.writeJSON({ previous: [] }));
+    let keys = await keysFile.readJSON();
+    async function onChangeFromOtherDevices(newVersion) {
+        changeProc.startOrChain(async () => {
+            const { version, json } = await keysFile.v.readJSON();
+            if (version === newVersion) {
+                keys = json;
+            }
+        });
     }
-    function toFileJSON() {
-        return published;
+    const { stopFileWatching, triggerUpload } = (0, single_file_1.watchAndApplyChangesFromOtherDevices)(keysFile, changeProc, onChangeFromOtherDevices, doOnConflict);
+    if (keysFile.isNew) {
+        await update();
     }
-    // private toServerParam(): PKeyCertChain|undefined {
-    // 	return published.current?.certs;
-    // }
-    async function absorbRemoteChanges() {
-        // XXX
-        //  - check for changes: what is needed here from fileProc, and what is
-        //    generic in absorbing remote changes to refactor it into JsonFileProc
-        //  - absorb and sync, if needed: what can be in JsonFileProc
-        // Code from pre-v.sync:
-        // const { json } = await fileProc.get();
-        // setFromJSON(json);
+    else {
+        updateIfCurrentExpired();
     }
+    let periodicExpiryCheck = setTimeout(updateIfCurrentExpired, UPDATE_BEFORE_EXPIRY * 1000 / 20);
+    (_a = periodicExpiryCheck.unref) === null || _a === void 0 ? void 0 : _a.call(periodicExpiryCheck);
     async function makeNewIntroKey() {
         const signer = await getSigner();
         const pair = await (0, common_1.generateKeyPair)(random);
@@ -76,24 +57,54 @@ async function makeHolderOfPublishedIntroKey(file, getSigner, random, pkeyOnServ
         return { pair, certs };
     }
     function update() {
-        return fileProc.order.startOrChain(async () => {
+        return changeProc.startOrChain(async () => {
             const { certs, pair: keyPair } = await makeNewIntroKey();
             await pkeyOnServer.setOnServer(certs);
             retireCurrent(keyPair.createdAt);
-            published.current = { keyPair, certs };
-            await fileProc.save(toFileJSON(), false);
+            keys.current = { keyPair, certs };
+            await keysFile.writeJSON(keys);
+            triggerUpload();
             return certs;
         });
     }
     ;
     function retireCurrent(retiredAt) {
-        if (!published.current) {
+        if (!keys.current) {
             return;
         }
-        const current = published.current;
+        const current = keys.current;
         current.keyPair.retiredAt = retiredAt;
-        published.previous.push(current.keyPair);
-        published.current = undefined;
+        keys.previous.push(current.keyPair);
+        if (keys.previous.length > MAX_NUM_OF_PREV) {
+            keys.previous.splice(0, keys.previous.length - MAX_NUM_OF_PREV);
+        }
+        keys.current = undefined;
+    }
+    function doOnConflict() {
+        return changeProc.startOrChain(async () => {
+            var _a, _b, _c, _d, _e, _f;
+            const { remote, state } = await keysFile.v.sync.status(false);
+            if ((state !== 'conflicting') || !(remote === null || remote === void 0 ? void 0 : remote.latest)) {
+                return;
+            }
+            const onRemote = (await keysFile.v.readJSON({ remoteVersion: remote.latest })).json;
+            if (((_a = onRemote.current) === null || _a === void 0 ? void 0 : _a.keyPair.pkey.kid) === ((_b = keys.current) === null || _b === void 0 ? void 0 : _b.keyPair.pkey.kid)) {
+                await keysFile.v.sync.adoptRemote();
+                return;
+            }
+            const certsOnServer = await pkeyOnServer.getFromServer();
+            const currentOnServer = (certsOnServer ? (0, jwkeys_1.getPubKey)(certsOnServer.pkeyCert) : undefined);
+            if ((currentOnServer === null || currentOnServer === void 0 ? void 0 : currentOnServer.kid) === ((_c = keys.current) === null || _c === void 0 ? void 0 : _c.keyPair.pkey.kid)) {
+                await keysFile.v.sync.upload({ uploadVersion: remote.latest + 1 });
+            }
+            else if ((currentOnServer === null || currentOnServer === void 0 ? void 0 : currentOnServer.kid) === ((_d = onRemote.current) === null || _d === void 0 ? void 0 : _d.keyPair.pkey.kid)) {
+                await keysFile.v.sync.adoptRemote({ remoteVersion: remote.latest });
+            }
+            else {
+                await pkeyOnServer.setOnServer((_f = (_e = keys.current) === null || _e === void 0 ? void 0 : _e.certs) !== null && _f !== void 0 ? _f : null);
+                await keysFile.v.sync.upload({ uploadVersion: remote.latest + 1 });
+            }
+        });
     }
     /**
      * This looks for a published key with a given key id. If it is found, an
@@ -108,15 +119,15 @@ async function makeHolderOfPublishedIntroKey(file, getSigner, random, pkeyOnServ
      */
     function find(kid) {
         // check current key
-        if (published.current
-            && (published.current.keyPair.skey.kid === kid)) {
+        if (keys.current
+            && (keys.current.keyPair.skey.kid === kid)) {
             return {
                 role: 'published_intro',
-                pair: published.current.keyPair
+                pair: keys.current.keyPair
             };
         }
         // check previous key
-        const pair = published.previous.find(({ skey }) => (skey.kid === kid));
+        const pair = keys.previous.find(({ skey }) => (skey.kid === kid));
         if (pair) {
             return {
                 role: 'prev_published_intro',
@@ -137,24 +148,25 @@ async function makeHolderOfPublishedIntroKey(file, getSigner, random, pkeyOnServ
     }
     async function getCurrent() {
         var _a;
-        const certs = (_a = published.current) === null || _a === void 0 ? void 0 : _a.certs;
+        const certs = (_a = keys.current) === null || _a === void 0 ? void 0 : _a.certs;
         return (certs ? certs : null);
     }
     async function removeCurrent() {
-        if (!published.current) {
+        if (!keys.current) {
             return;
         }
-        return fileProc.order.startOrChain(async () => {
+        return changeProc.startOrChain(async () => {
             await pkeyOnServer.setOnServer(null);
             retireCurrent(Math.floor(Date.now() / 1000));
+            await keysFile.writeJSON(keys);
+            triggerUpload();
         });
     }
-    let periodicExpiryCheck = undefined;
-    function startExpiryCheckProcess() {
-        if (!published.current) {
+    function updateIfCurrentExpired() {
+        if (!keys.current) {
             return;
         }
-        const { pkeyCert } = published.current.certs;
+        const { pkeyCert } = keys.current.certs;
         const expiryInSeconds = (0, jwkeys_1.getKeyCert)(pkeyCert).expiresAt;
         const now = Math.floor(Date.now() / 1000);
         if (expiryInSeconds < (now + UPDATE_BEFORE_EXPIRY)) {
@@ -162,26 +174,14 @@ async function makeHolderOfPublishedIntroKey(file, getSigner, random, pkeyOnServ
         }
     }
     async function close() {
+        stopFileWatching();
         if (periodicExpiryCheck) {
             clearTimeout(periodicExpiryCheck);
             periodicExpiryCheck = undefined;
         }
-        await fileProc.close();
-    }
-    if (file.isNew) {
-        await fileProc.start(file, toFileJSON);
-        await update();
-    }
-    else {
-        await fileProc.start(file, undefined);
-        setFromJSON((await fileProc.get()).json);
-        await absorbRemoteChanges();
-        startExpiryCheckProcess();
-        periodicExpiryCheck = setTimeout(startExpiryCheckProcess, UPDATE_BEFORE_EXPIRY * 1000 / 20);
-        (_a = periodicExpiryCheck.unref) === null || _a === void 0 ? void 0 : _a.call(periodicExpiryCheck);
     }
     return {
-        startExpiryCheckProcess,
+        startExpiryCheckProcess: updateIfCurrentExpired,
         close,
         makeIntroKeyCAP,
         find

package/build/core/keyring/peer-keys/index.js

@@ -30,9 +30,9 @@ const LOGS_DIR = 'peer-keys-logs';
 const PEER_KEYS_FOLDER = 'peer-keys-db';
 const NUM_OF_LOGS_TO_START_CUT = 200;
 async function makePeersKeyring(keyringFS, localFS, random, logger) {
-    const logsFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(keyringFS, LOGS_DIR);
+    const logsFS = await (0, fs_sync_utils_1.getOrMakeDirOnInit)(keyringFS, LOGS_DIR);
     const logsLocalFS = await localFS.writableSubRoot(LOGS_DIR);
-    const peerKeysFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(keyringFS, PEER_KEYS_FOLDER);
+    const peerKeysFS = await (0, fs_sync_utils_1.getOrMakeDirOnInit)(keyringFS, PEER_KEYS_FOLDER);
     // XXX log and saving reduction(!):
     //  - we don't need to log message counts
     //  - we don't have to immediately save changes in message counts
@@ -165,11 +165,10 @@ async function makePeersKeyring(keyringFS, localFS, random, logger) {
         await logs.recordGettingCryptoFromPeer(entryToLog, peerAddr);
     }
     async function periodicCheckAndUploadOfData() {
-        // XXX disable uploading for a moment by commenting out
-        // if (logs.numOfLogs() >= NUM_OF_LOGS_TO_START_CUT) {
-        // 	const syncedIndexDbVersion = await keysDB.saveAndSync();
-        // 	await logs.cutLogOnDatasetSyncAndUpload(syncedIndexDbVersion);
-        // }
+        if (logs.numOfLogs() >= NUM_OF_LOGS_TO_START_CUT) {
+            const syncedIndexDbVersion = await keysDB.saveAndSync();
+            await logs.cutLogOnDatasetSyncAndUpload(syncedIndexDbVersion);
+        }
     }
     function millisBeforeNextRun() {
         return 30 * 60 * 1000 + Math.floor(10 * 60 * 1000 * Math.random());

package/build/core/storage/index.d.ts

@@ -17,10 +17,11 @@ export declare class Storages implements FactoryOfFSs {
     private readonly cryptor;
     private readonly random;
     private readonly storageDirForUser;
+    private readonly sysFilesOnDevice;
     private synced;
     private local;
     private preCloseWaits;
-    constructor(cryptor: AsyncSBoxCryptor, random: AsyncRNG, storageDirForUser: StoragePathForUser);
+    constructor(cryptor: AsyncSBoxCryptor, random: AsyncRNG, storageDirForUser: StoragePathForUser, sysFilesOnDevice: () => Promise<FSItem>);
     makeStorageCAP(appDomain: string, policy: StoragePolicy): {
         cap: Service;
         close: () => void;

package/build/core/storage/index.js

@@ -216,10 +216,11 @@ class StorageAndFS {
 Object.freeze(StorageAndFS.prototype);
 Object.freeze(StorageAndFS);
 class Storages {
-    constructor(cryptor, random, storageDirForUser) {
+    constructor(cryptor, random, storageDirForUser, sysFilesOnDevice) {
         this.cryptor = cryptor;
         this.random = random;
         this.storageDirForUser = storageDirForUser;
+        this.sysFilesOnDevice = sysFilesOnDevice;
         this.synced = undefined;
         this.local = undefined;
         this.preCloseWaits = new Set();
@@ -349,7 +350,7 @@ class Storages {
             fs = await this.local.userFS();
         }
         else if (type === 'device') {
-            fs = await (0, system_folders_1.userFilesOnDevice)();
+            return await (0, system_folders_1.userFilesOnDevice)();
         }
         else {
             throw new Error(`Unknown storage type ${type}`);
@@ -375,7 +376,7 @@ class Storages {
             };
         }
         else if (type === 'device') {
-            return (0, system_folders_1.sysFilesOnDevice)();
+            return this.sysFilesOnDevice();
         }
         else {
             throw new Error(`Unknown storage type ${type}`);

package/build/core/storage/system-folders/index.d.ts

@@ -13,6 +13,5 @@ export declare const sysFolders: {
  * @param root
  */
 export declare function initSysFolders(root: WritableFS): Promise<void>;
-export declare function userFilesOnDevice(): Promise<WritableFS>;
-export declare function sysFilesOnDevice(): Promise<FSItem>;
+export declare function userFilesOnDevice(): Promise<FSItem>;
 export {};

package/build/core/storage/system-folders/index.js

@@ -19,7 +19,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.sysFolders = void 0;
 exports.initSysFolders = initSysFolders;
 exports.userFilesOnDevice = userFilesOnDevice;
-exports.sysFilesOnDevice = sysFilesOnDevice;
 const fs_collection_1 = require("../../../lib-client/fs-utils/fs-collection");
 const lib_index_1 = require("../../../lib-index");
 exports.sysFolders = {
@@ -40,38 +39,35 @@ async function initSysFolders(root) {
     for (const sysFolder of Object.values(exports.sysFolders)) {
         await root.makeFolder(sysFolder);
         if ((_a = root.v) === null || _a === void 0 ? void 0 : _a.sync) {
-            // XXX must add work with not-online condition
+            // XXX need not-online condition, but it runs only on first install, when network is required
             await root.v.sync.upload(sysFolder);
         }
     }
     if ((_b = root.v) === null || _b === void 0 ? void 0 : _b.sync) {
-        // XXX must add work with not-online condition
+        // XXX need not-online condition, but it runs only on first install, when network is required
         await root.v.sync.upload('.');
     }
 }
 async function userFilesOnDevice() {
     if (process.platform === 'win32') {
-        return lib_index_1.DeviceFS.makeWritable(process.env.USERPROFILE);
-    }
-    else {
-        return lib_index_1.DeviceFS.makeWritable(process.env.HOME);
-    }
-}
-async function sysFilesOnDevice() {
-    const c = (0, fs_collection_1.makeFSCollection)();
-    if (process.platform === 'win32') {
-        const sysDrive = process.env.SystemDrive;
-        await c.set(sysDrive, {
-            isFolder: true,
-            item: await lib_index_1.DeviceFS.makeWritable(sysDrive)
-        });
+        if (process.env.USERPROFILE) {
+            return {
+                isFolder: true,
+                item: await lib_index_1.DeviceFS.makeWritable(process.env.USERPROFILE)
+            };
+        }
     }
     else {
-        await c.set('', {
-            isFolder: true,
-            item: await lib_index_1.DeviceFS.makeWritable('/')
-        });
+        if (process.env.HOME) {
+            return {
+                isFolder: true,
+                item: await lib_index_1.DeviceFS.makeWritable(process.env.HOME)
+            };
+        }
     }
-    return { isCollection: true, item: c };
+    return {
+        isCollection: true,
+        item: (0, fs_collection_1.makeFSCollection)()
+    };
 }
 Object.freeze(exports);

package/build/lib-client/asmail/recipient.d.ts

@@ -5,6 +5,7 @@ import { SubscribingClient } from '../../lib-common/ipc/ws-ipc';
 type InboxException = web3n.asmail.InboxException;
 type Observer<T> = web3n.Observer<T>;
 export declare function makeMsgNotFoundException(msgId: string): InboxException;
+export declare function makeFailToDecryptMsgException(msgId: string): InboxException;
 export declare function makeObjNotFoundException(msgId: string, objId: string): InboxException;
 export declare function makeMsgIsBrokenException(msgId: string): InboxException;
 export declare class MailRecipient extends ServiceUser {