core-3nweb-client-lib 0.25.6 → 0.27.0

package/build/core/sign-in.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2018, 2020 3NSoft Inc.
+ Copyright (C) 2015 - 2018, 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
@@ -34,8 +34,7 @@ class SignIn {
                 return !!this.completeInitWithoutCache;
             }
             catch (err) {
-                await this.log(err, 'Failing to initialize without cache');
-                throw err;
+                throw await this.logAndWrap(err, 'Fail to start login to remote storage');
             }
         };
         this.completeLoginAndLocalSetup = async (pass, progressCB) => {
@@ -44,9 +43,9 @@ class SignIn {
             }
             try {
                 const midKeyProgressCB = makeKeyGenProgressCB(0, 50, progressCB);
-                const midKeyGen = async (params) => (await key_derivation_1.deriveMidKeyPair(this.cryptor, pass, params, midKeyProgressCB)).skey;
+                const midKeyGen = async (params) => (await (0, key_derivation_1.deriveMidKeyPair)(this.cryptor, pass, params, midKeyProgressCB)).skey;
                 const storeKeyProgressCB = makeKeyGenProgressCB(51, 100, progressCB);
-                const storeKeyGen = params => key_derivation_1.deriveStorageSKey(this.cryptor, pass, params, storeKeyProgressCB);
+                const storeKeyGen = (params) => (0, key_derivation_1.deriveStorageSKey)(this.cryptor, pass, params, storeKeyProgressCB);
                 const idManager = await this.completeInitWithoutCache(midKeyGen, storeKeyGen);
                 if (!idManager) {
                     return false;
@@ -55,8 +54,7 @@ class SignIn {
                 return true;
             }
             catch (err) {
-                await this.log(err, 'Failing to initialize from a state without cache');
-                throw err;
+                throw await this.logAndWrap(err, 'Fail to initialize from a state without cache');
             }
         };
         this.doneBroadcast = new rxjs_1.Subject();
@@ -64,7 +62,7 @@ class SignIn {
         this.useExistingStorage = async (user, pass, progressCB) => {
             try {
                 const storeKeyProgressCB = makeKeyGenProgressCB(0, 99, progressCB);
-                const storeKeyGen = params => key_derivation_1.deriveStorageSKey(this.cryptor, pass, params, storeKeyProgressCB);
+                const storeKeyGen = params => (0, key_derivation_1.deriveStorageSKey)(this.cryptor, pass, params, storeKeyProgressCB);
                 const res = await this.initWithCache(user, storeKeyGen);
                 if (!res) {
                     return false;
@@ -75,7 +73,7 @@ class SignIn {
                 }
                 progressCB(49);
                 const midKeyProgressCB = makeKeyGenProgressCB(50, 99, progressCB);
-                const midKeyGen = async (params) => (await key_derivation_1.deriveMidKeyPair(this.cryptor, pass, params, midKeyProgressCB)).skey;
+                const midKeyGen = async (params) => (await (0, key_derivation_1.deriveMidKeyPair)(this.cryptor, pass, params, midKeyProgressCB)).skey;
                 const idManager = await res(midKeyGen);
                 if (!idManager) {
                     return false;
@@ -84,8 +82,7 @@ class SignIn {
                 return true;
             }
             catch (err) {
-                await this.log(err, 'Failing to start in a state with cache');
-                throw err;
+                throw await this.logAndWrap(err, 'Failing to start in a state with cache');
             }
         };
         Object.seal(this);
@@ -99,8 +96,9 @@ class SignIn {
         };
         return Object.freeze(service);
     }
-    async log(err, msg) {
-        await this.logError(error_1.errWithCause(err, msg));
+    async logAndWrap(err, msg) {
+        await this.logError(err, msg);
+        return (0, error_1.errWithCause)(err, msg);
     }
 }
 exports.SignIn = SignIn;
@@ -113,7 +111,7 @@ function makeKeyGenProgressCB(progressStart, progressEnd, progressCB) {
     let currentProgress = 0;
     let totalProgress = progressStart;
     const progressRange = progressEnd - progressStart;
-    return (p) => {
+    return p => {
         if (currentProgress >= p) {
             return;
         }

package/build/core/sign-up.d.ts

@@ -28,6 +28,7 @@ export declare class SignUp {
     private genStorageParams;
     private genMidParams;
     private addUser;
+    private logAndWrap;
     private forgetKeys;
     private doneBroadcast;
     newUser$: import("rxjs").Observable<CreatedUser>;

package/build/core/sign-up.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2020 3NSoft Inc.
+ Copyright (C) 2015 - 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
@@ -27,6 +27,7 @@ const random = require("../lib-common/random-node");
 const ecma_nacl_1 = require("ecma-nacl");
 const sign_in_1 = require("./sign-in");
 const rxjs_1 = require("rxjs");
+const error_1 = require("../lib-common/exceptions/error");
 /**
  * With these parameters scrypt shall use memory around:
  * (2^7)*r*N === (2^7)*(2^3)*(2^17) === 2^27 === (2^7)*(2^20) === 128MB
@@ -41,13 +42,13 @@ const SALT_LEN = 32;
 const KEY_ID_LEN = 10;
 async function makeLabeledMidLoginKey(cryptor) {
     const sk = await random.bytes(ecma_nacl_1.box.KEY_LENGTH);
-    const skey = jwkeys_1.keyToJson({
+    const skey = (0, jwkeys_1.keyToJson)({
         k: sk,
         alg: ecma_nacl_1.box.JWK_ALG_NAME,
         use: jwkeys_1.use.MID_PKLOGIN,
         kid: await random.stringOfB64Chars(KEY_ID_LEN)
     });
-    const pkey = jwkeys_1.keyToJson({
+    const pkey = (0, jwkeys_1.keyToJson)({
         k: await cryptor.box.generate_pubkey(sk),
         alg: skey.alg,
         use: skey.use,
@@ -65,7 +66,7 @@ class SignUp {
         this.store = undefined;
         this.netLazyInit = undefined;
         this.getAvailableAddresses = async (name, signupToken) => {
-            const addresses = await _3nweb_signup_1.checkAvailableAddressesForName(this.net, this.serviceURL, name, signupToken);
+            const addresses = await (0, _3nweb_signup_1.checkAvailableAddressesForName)(this.net, this.serviceURL, name, signupToken);
             return addresses;
         };
         this.createUserParams = async (pass, progressCB) => {
@@ -74,18 +75,17 @@ class SignUp {
         };
         this.addUser = async (address, signupToken) => {
             for (const user of await this.getUsersOnDisk()) {
-                if (canonical_address_1.areAddressesEqual(address, user)) {
+                if ((0, canonical_address_1.areAddressesEqual)(address, user)) {
                     throw new Error(`Account ${user} already exists on a disk.`);
                 }
             }
-            const accountCreated = await _3nweb_signup_1.addUser(this.net, this.serviceURL, {
+            const accountCreated = await (0, _3nweb_signup_1.addUser)(this.net, this.serviceURL, {
                 userId: address,
                 mailerId: this.mid.params,
                 storage: this.store.params,
                 signupToken
             }).catch(async (err) => {
-                await this.logError(err, `Failed to create user account ${address}.`);
-                throw err;
+                throw await this.logAndWrap(err, `Failed to create user account ${address}.`);
             });
             if (!accountCreated) {
                 return false;
@@ -113,7 +113,7 @@ class SignUp {
         return this.netLazyInit;
     }
     setServiceURL(serviceURL) {
-        const url = url_1.parse(serviceURL);
+        const url = (0, url_1.parse)(serviceURL);
         if (url.protocol !== 'https:') {
             throw new Error("Url protocol must be https.");
         }
@@ -138,7 +138,7 @@ class SignUp {
             p: defaultDerivParams.p,
             salt: buffer_utils_1.base64.pack(await random.bytes(SALT_LEN))
         };
-        const progressCB = sign_in_1.makeKeyGenProgressCB(progressStart, progressEnd, originalProgressCB);
+        const progressCB = (0, sign_in_1.makeKeyGenProgressCB)(progressStart, progressEnd, originalProgressCB);
         const skey = await keyDeriv.deriveStorageSKey(this.cryptor, pass, derivParams, progressCB);
         this.store = {
             skey: skey,
@@ -154,7 +154,7 @@ class SignUp {
             p: defaultDerivParams.p,
             salt: buffer_utils_1.base64.pack(await random.bytes(SALT_LEN))
         };
-        const progressCB = sign_in_1.makeKeyGenProgressCB(progressStart, progressEnd, originalProgressCB);
+        const progressCB = (0, sign_in_1.makeKeyGenProgressCB)(progressStart, progressEnd, originalProgressCB);
         const defaultPair = await keyDeriv.deriveMidKeyPair(this.cryptor, pass, derivParams, progressCB, jwkeys_1.use.MID_PKLOGIN, '_');
         const labeledKey = await makeLabeledMidLoginKey(this.cryptor);
         this.mid = {
@@ -169,6 +169,10 @@ class SignUp {
             }
         };
     }
+    async logAndWrap(err, msg) {
+        await this.logError(err, msg);
+        return (0, error_1.errWithCause)(err, msg);
+    }
     forgetKeys() {
         this.store = undefined;
         this.mid = undefined;

package/build/core/storage/common/json-saving.d.ts

@@ -0,0 +1,21 @@
+export declare class JSONSavingProc<T> {
+    private readonly path;
+    private readonly getForSerialization;
+    private proc;
+    private jsonNeedsSaving;
+    /**
+     * @param path where json file is saved
+     * @param getForSerialization function that either returns something to
+     * jsonify and save, or undefined to remove the file.
+     * @param logError is an optional log function saving errors.
+     */
+    constructor(path: string, getForSerialization: () => T | undefined);
+    /**
+     * This triggers saving. One may await returned promise, but doesn't have to.
+     * Several triggers can be done, but overlapping ones will save only the
+     * latest value.
+     */
+    trigger(): Promise<void>;
+    isSaved(): boolean;
+    private save;
+}

package/build/core/storage/common/json-saving.js

@@ -0,0 +1,82 @@
+"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.JSONSavingProc = void 0;
+const async_fs_node_1 = require("../../../lib-common/async-fs-node");
+class JSONSavingProc {
+    /**
+     * @param path where json file is saved
+     * @param getForSerialization function that either returns something to
+     * jsonify and save, or undefined to remove the file.
+     * @param logError is an optional log function saving errors.
+     */
+    constructor(path, getForSerialization) {
+        this.path = path;
+        this.getForSerialization = getForSerialization;
+        this.proc = undefined;
+        this.jsonNeedsSaving = false;
+        Object.seal(this);
+    }
+    /**
+     * This triggers saving. One may await returned promise, but doesn't have to.
+     * Several triggers can be done, but overlapping ones will save only the
+     * latest value.
+     */
+    trigger() {
+        if (!this.jsonNeedsSaving) {
+            this.jsonNeedsSaving = true;
+            if (!this.proc) {
+                this.proc = this.save();
+            }
+        }
+        return this.proc;
+    }
+    isSaved() {
+        return !this.jsonNeedsSaving;
+    }
+    async save() {
+        try {
+            this.jsonNeedsSaving = false;
+            const serialForm = this.getForSerialization();
+            if (serialForm === undefined) {
+                await (0, async_fs_node_1.unlink)(this.path)
+                    .catch((e) => {
+                    if (!e.notFound) {
+                        throw e;
+                    }
+                });
+            }
+            else {
+                const json = JSON.stringify(serialForm);
+                await (0, async_fs_node_1.writeFile)(this.path, json, { encoding: 'utf8' });
+            }
+        }
+        finally {
+            if (this.jsonNeedsSaving) {
+                return this.save();
+            }
+            {
+                this.proc = undefined;
+            }
+        }
+    }
+}
+exports.JSONSavingProc = JSONSavingProc;
+Object.freeze(JSONSavingProc.prototype);
+Object.freeze(JSONSavingProc);
+Object.freeze(exports);

package/build/core/storage/common/obj-info-file.d.ts

@@ -1 +1,52 @@
 export declare function readJSONInfoFileIn<T>(objFolder: string, fileName: string): Promise<T | undefined>;
+export interface VersionsInfo {
+    /**
+     * This field indicates current object version in cache.
+     */
+    current?: number;
+    /**
+     * This is a list of archived versions in the cache.
+     */
+    archived?: number[];
+    /**
+     * This is a map from base version to diff-ed version, that uses base.
+     */
+    baseToDiff: {
+        [baseVersion: number]: number;
+    };
+    /**
+     * This is a map from diff version to base version.
+     */
+    diffToBase: {
+        [diffVersion: number]: number;
+    };
+}
+/**
+ * This function adds base->diff link to given versions info.
+ * @param versions
+ * @param diffVer
+ * @param baseVer
+ */
+export declare function addBaseToDiffLinkInVersInfo(versions: VersionsInfo, diffVer: number, baseVer: number): void;
+export declare function isVersionIn(version: number, vers: VersionsInfo): boolean;
+/**
+ * This function removes given version from versions info, if it is neither
+ * archived, nor is a base for another version. If given version is itself
+ * based on another, this function is recursively applied to base version, as
+ * well.
+ * @param versions
+ * @param ver
+ */
+export declare function rmNonArchVersionsIn(versions: VersionsInfo, ver: number): void;
+export declare function rmArchVersionFrom(versions: VersionsInfo, ver: number): boolean;
+export declare function setCurrentVersionIn(versions: VersionsInfo, version: number, baseVer: number | undefined): void;
+export declare function rmCurrentVersionIn(versions: VersionsInfo): number | undefined;
+export declare function rmVersionIn(version: number, vers: VersionsInfo): void;
+export declare function nonGarbageVersionsIn(versions: VersionsInfo): Set<number>;
+export interface NonGarbageVersions {
+    gcMaxVer?: number;
+    nonGarbage: Set<number>;
+}
+export declare function addWithBasesTo(nonGarbage: Set<number>, ver: number | undefined, versions: VersionsInfo): void;
+export declare function addArchived(versions: VersionsInfo, version: number): boolean;
+export declare function isEmptyVersions(versions: VersionsInfo): boolean;

package/build/core/storage/common/obj-info-file.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
@@ -13,15 +13,16 @@
  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/>. */
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readJSONInfoFileIn = void 0;
+exports.isEmptyVersions = exports.addArchived = exports.addWithBasesTo = exports.nonGarbageVersionsIn = exports.rmVersionIn = exports.rmCurrentVersionIn = exports.setCurrentVersionIn = exports.rmArchVersionFrom = exports.rmNonArchVersionsIn = exports.isVersionIn = exports.addBaseToDiffLinkInVersInfo = exports.readJSONInfoFileIn = void 0;
 const fs = require("../../../lib-common/async-fs-node");
 const path_1 = require("path");
 const exceptions_1 = require("../../../lib-client/3nstorage/exceptions");
 async function readJSONInfoFileIn(objFolder, fileName) {
     try {
-        const infoJSONStr = await fs.readFile(path_1.join(objFolder, fileName), { encoding: 'utf8' }).catch((exc) => {
+        const infoJSONStr = await fs.readFile((0, path_1.join)(objFolder, fileName), { encoding: 'utf8' }).catch((exc) => {
             if (!exc.notFound) {
                 throw exc;
             }
@@ -34,11 +35,158 @@ async function readJSONInfoFileIn(objFolder, fileName) {
         return status;
     }
     catch (err) {
-        throw exceptions_1.makeStorageException({
+        throw (0, exceptions_1.makeStorageException)({
             message: `Can't read and parse content of obj info file ${fileName} in obj folder ${objFolder}`,
             cause: err
         });
     }
 }
 exports.readJSONInfoFileIn = readJSONInfoFileIn;
+/**
+ * This function adds base->diff link to given versions info.
+ * @param versions
+ * @param diffVer
+ * @param baseVer
+ */
+function addBaseToDiffLinkInVersInfo(versions, diffVer, baseVer) {
+    if (diffVer <= baseVer) {
+        throw new Error(`Given diff version ${diffVer} is not greater than base version ${baseVer}`);
+    }
+    versions.diffToBase[diffVer] = baseVer;
+    versions.baseToDiff[baseVer] = diffVer;
+}
+exports.addBaseToDiffLinkInVersInfo = addBaseToDiffLinkInVersInfo;
+function isVersionIn(version, vers) {
+    if (vers.current === version) {
+        return true;
+    }
+    if (vers.archived && vers.archived.includes(version)) {
+        return true;
+    }
+    return false;
+}
+exports.isVersionIn = isVersionIn;
+/**
+ * This function removes given version from versions info, if it is neither
+ * archived, nor is a base for another version. If given version is itself
+ * based on another, this function is recursively applied to base version, as
+ * well.
+ * @param versions
+ * @param ver
+ */
+function rmNonArchVersionsIn(versions, ver) {
+    if (versions.archived
+        && versions.archived.includes(ver)) {
+        return;
+    }
+    if (versions.baseToDiff[ver]) {
+        return;
+    }
+    const base = versions.diffToBase[ver];
+    if (base) {
+        delete versions.diffToBase[ver];
+        delete versions.baseToDiff[base];
+        rmNonArchVersionsIn(versions, base);
+    }
+}
+exports.rmNonArchVersionsIn = rmNonArchVersionsIn;
+function rmArchVersionFrom(versions, ver) {
+    if (!versions.archived) {
+        return false;
+    }
+    const vInd = versions.archived.indexOf(ver);
+    if (vInd < 0) {
+        return false;
+    }
+    versions.archived.splice(vInd, 1);
+    if (versions.archived.length === 0) {
+        versions.archived = undefined;
+    }
+    rmNonArchVersionsIn(versions, ver);
+    return true;
+}
+exports.rmArchVersionFrom = rmArchVersionFrom;
+function setCurrentVersionIn(versions, version, baseVer) {
+    if (baseVer !== undefined) {
+        // base->diff links should be added before removals
+        addBaseToDiffLinkInVersInfo(versions, version, baseVer);
+    }
+    const initCurrent = versions.current;
+    if (typeof initCurrent === 'number') {
+        rmNonArchVersionsIn(versions, initCurrent);
+    }
+    versions.current = version;
+}
+exports.setCurrentVersionIn = setCurrentVersionIn;
+function rmCurrentVersionIn(versions) {
+    const current = versions.current;
+    if (typeof current === 'number') {
+        rmNonArchVersionsIn(versions, current);
+        versions.current = undefined;
+    }
+    return current;
+}
+exports.rmCurrentVersionIn = rmCurrentVersionIn;
+function rmVersionIn(version, vers) {
+    if (vers.current === version) {
+        vers.current = undefined;
+        rmNonArchVersionsIn(vers, version);
+    }
+    if (isVersionIn(version, vers)) {
+        rmArchVersionFrom(vers, version);
+    }
+}
+exports.rmVersionIn = rmVersionIn;
+function nonGarbageVersionsIn(versions) {
+    const nonGarbage = new Set();
+    addWithBasesTo(nonGarbage, versions.current, versions);
+    if (versions.archived) {
+        for (const archVer of versions.archived) {
+            addWithBasesTo(nonGarbage, archVer, versions);
+        }
+    }
+    return nonGarbage;
+}
+exports.nonGarbageVersionsIn = nonGarbageVersionsIn;
+function addWithBasesTo(nonGarbage, ver, versions) {
+    while (typeof ver === 'number') {
+        if (nonGarbage.has(ver)) {
+            break;
+        }
+        nonGarbage.add(ver);
+        if (!versions.diffToBase) {
+            break;
+        }
+        ver = versions.diffToBase[ver];
+    }
+}
+exports.addWithBasesTo = addWithBasesTo;
+function addArchived(versions, version) {
+    if (!versions.archived) {
+        versions.archived = [];
+    }
+    else if (versions.archived.includes(version)) {
+        return false;
+    }
+    versions.archived.push(version);
+    versions.archived.sort();
+    return true;
+}
+exports.addArchived = addArchived;
+function isEmptyVersions(versions) {
+    if (versions.current) {
+        return false;
+    }
+    if (!versions.archived) {
+        return true;
+    }
+    else if (versions.archived.length > 0) {
+        return false;
+    }
+    else {
+        versions.archived = undefined;
+        return true;
+    }
+}
+exports.isEmptyVersions = isEmptyVersions;
 Object.freeze(exports);

package/build/core/storage/common/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function getAndRemoveOneFrom<T>(set: Set<T>): T | undefined;
+export declare function noop(): void;

package/build/core/storage/common/utils.js

@@ -0,0 +1,32 @@
+"use strict";
+/*
+ Copyright (C) 2016 - 2020 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.noop = exports.getAndRemoveOneFrom = void 0;
+function getAndRemoveOneFrom(set) {
+    const iter = set.values();
+    const { value, done } = iter.next();
+    if (done) {
+        return;
+    }
+    set.delete(value);
+    return value;
+}
+exports.getAndRemoveOneFrom = getAndRemoveOneFrom;
+function noop() { }
+exports.noop = noop;
+Object.freeze(exports);

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

@@ -3,24 +3,12 @@ import { GenerateKey } from '../sign-in';
 import { StorageGetter } from '../../lib-client/3nstorage/xsp-fs/common';
 import { ServiceLocator } from '../../lib-client/service-locator';
 import { AsyncSBoxCryptor } from 'xsp-files';
-import { NetClient } from '../../lib-client/request-utils';
 import { StoragePathForUser } from '../app-files';
 import { LogError } from '../../lib-client/logging/log-to-file';
+import { MakeNet } from '..';
 declare type WritableFS = web3n.files.WritableFS;
 declare type StorageType = web3n.storage.StorageType;
 declare type FSItem = web3n.files.FSItem;
-export declare const sysFolders: {
-    appData: string;
-    apps: string;
-    packages: string;
-    sharedLibs: string;
-    userFiles: string;
-};
-/**
- * This function creates initial folder structure in a given root.
- * @param root
- */
-export declare function initSysFolders(root: WritableFS): Promise<void>;
 export declare class Storages implements FactoryOfFSs {
     private cryptor;
     private storageDirForUser;
@@ -42,8 +30,8 @@ export declare class Storages implements FactoryOfFSs {
      * This is a storage getter for links and linking in synced storage.
      */
     private storageGetterForSyncedStorage;
-    startInitFromCache(user: string, keyGen: GenerateKey, makeNet: () => NetClient, resolver: ServiceLocator, logError: LogError): Promise<((getSigner: GetSigner) => Promise<boolean>) | undefined>;
-    initFromRemote(user: string, getSigner: GetSigner, keyOrGen: GenerateKey | Uint8Array, makeNet: () => NetClient, resolver: ServiceLocator, logError: LogError): Promise<boolean>;
+    startInitFromCache(user: string, keyGen: GenerateKey, makeNet: MakeNet, resolver: ServiceLocator, logError: LogError): Promise<((getSigner: GetSigner) => Promise<boolean>) | undefined>;
+    initFromRemote(user: string, getSigner: GetSigner, keyOrGen: GenerateKey | Uint8Array, makeNet: MakeNet, resolver: ServiceLocator, logError: LogError): Promise<boolean>;
     makeSyncedFSForApp(appFolder: string): Promise<WritableFS>;
     makeLocalFSForApp(appFolder: string): Promise<WritableFS>;
     getUserFS(type: StorageType): Promise<FSItem>;
@@ -51,8 +39,6 @@ export declare class Storages implements FactoryOfFSs {
     close(): Promise<void>;
     wrap(): FactoryOfFSs;
 }
-export declare function userFilesOnDevice(): Promise<WritableFS>;
-export declare function sysFilesOnDevice(): Promise<FSItem>;
 export interface FactoryOfFSs {
     makeSyncedFSForApp(appFolder: string): Promise<WritableFS>;
     makeLocalFSForApp(appFolder: string): Promise<WritableFS>;