core-3nweb-client-lib 0.38.1 → 0.40.0

package/build/api-defs/asmail.d.ts

@@ -301,22 +301,6 @@ declare namespace web3n.asmail {
 		msgIsBroken?: true;
 	}
 
-	interface ServLocException extends RuntimeException {
-		type: 'service-locating';
-		address: string;
-
-		/**
-		 * domainNotFound flag indicates that domain in the address doesn't exist.
-		 */
-		domainNotFound?: true;
-
-		/**
-		 * noServiceRecord flag indicates that 3NWeb services are not set at
-		 * domain in the address.
-		 */
-		noServiceRecord?: true;
-	}
-
 	interface ASMailSendException extends RuntimeException {
 		type: 'asmail-delivery';
 		address?: string;

package/build/api-defs/startup.d.ts

@@ -1,5 +1,5 @@
 /*
- Copyright (C) 2016 - 2017, 2020, 2023 3NSoft Inc.
+ Copyright (C) 2016 - 2017, 2020, 2023, 2025 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
@@ -70,9 +70,10 @@ declare namespace web3n.startup {
 		 * @param progressCB is a callback for progress notification
 		 */
 		createUserParams(
-			pass: string,
-			progressCB: (progress: number) => void
+			pass: string, progressCB: ProgressCB
 		): Promise<void>;
+
+		watchBoot(observer: BootProcessObserver): () => void;
 		
 	}
 	
@@ -106,8 +107,7 @@ declare namespace web3n.startup {
 		 * @param progressCB is a callback for progress notification
 		 */
 		completeLoginAndLocalSetup(
-			pass: string,
-			progressCB: (progress: number) => void
+			pass: string, progressCB: ProgressCB
 		): Promise<boolean>;
 		
 		/**
@@ -119,12 +119,22 @@ declare namespace web3n.startup {
 		 * @param progressCB is a callback for progress notification
 		 */
 		useExistingStorage(
-			address: string, pass: string,
-			progressCB: (progress: number) => void
+			address: string, pass: string, progressCB: ProgressCB
 		): Promise<boolean>;
+
+		watchBoot(observer: BootProcessObserver): () => void;
 		
 	}
 
+	type ProgressCB = (progress: number) => void;
+	type BootProcessObserver = Observer<BootEvent>;
+	interface BootEvent {
+		coreApp?: string;
+		message: string;
+		isError?: true;
+		isWarning?: true;
+	}
+
 	interface W3N {
 		signIn: startup.SignInService;
 		signUp: startup.SignUpService;

package/build/api-defs/web3n.d.ts

@@ -25,7 +25,7 @@
 
 
 declare namespace web3n {
-	
+
 	interface RuntimeException {
 		runtimeException: true;
 		type?: string;
@@ -33,21 +33,47 @@ declare namespace web3n {
 		message?: string;
 	}
 
+	interface ConnectException extends RuntimeException {
+		type: 'connect';
+		connectType: string;
+	}
+
 	interface HTTPErrorDetails extends web3n.RuntimeException {
 		url: string;
 		method: string;
-		message?: string;
 	}
-	
-	interface ConnectException extends HTTPErrorDetails {
-		type: 'http-connect';
+
+	interface HTTPConnectException extends ConnectException {
+		connectType: 'http';
+		url?: string;
+		method?: string;
+	}
+
+	interface DNSConnectException extends ConnectException {
+		connectType: 'dns';
 	}
-	
+
 	interface HTTPException extends HTTPErrorDetails {
 		type: 'http-request';
 		status: number;
 	}
-	
+
+	interface ServLocException extends RuntimeException {
+		type: 'service-locating';
+		address: string;
+
+		/**
+		 * domainNotFound flag indicates that domain in the address doesn't exist.
+		 */
+		domainNotFound?: true;
+
+		/**
+		 * noServiceRecord flag indicates that 3NWeb services are not set at
+		 * domain in the address.
+		 */
+		noServiceRecord?: true;
+	}
+
 	interface EncryptionException {
 		failedCipherVerification?: true;
 		failedSignatureVerification?: true;

package/build/core/asmail/inbox/index.js

@@ -214,7 +214,7 @@ class InboxOnServer {
                 msgIds = await this.msgReceiver.listMsgs(fromTS);
             }
             catch (exc) {
-                if (exc.type !== 'http-connect') {
+                if (exc.type !== 'connect') {
                     throw exc;
                 }
                 return this.index.listMsgs(fromTS);

package/build/core/asmail/sending-params/invitations-anon.js

@@ -87,24 +87,33 @@ class AnonymousInvites {
         });
         return serverJSON;
     }
-    async syncServiceSetting() {
+    async syncServiceSetting(rethrowConnectExc = false) {
         // XXX we may have the following bug here:
         // Device with older version of param gets to this point, and sets older
         // value.
         // To protect aginst this case, absorbing from file must ensure highest
         // synced version is read.
-        const infoOnServer = await this.anonInvitesOnServer.getFromServer()
-            .catch((exc) => {
-            if (exc.type === 'http-connect') {
-                return;
+        try {
+            const infoOnServer = await this.anonInvitesOnServer.getFromServer()
+                .catch((exc) => {
+                if (exc.type === 'connect') {
+                    return;
+                }
+                else {
+                    throw exc;
+                }
+            });
+            const currentVal = this.toServiceJSON();
+            if (!(0, json_utils_1.deepEqual)(infoOnServer, currentVal)) {
+                await this.anonInvitesOnServer.setOnServer(currentVal);
             }
-            else {
-                throw exc;
+        }
+        catch (exc) {
+            if (!rethrowConnectExc
+                && (exc.type === 'connect')) {
+                return;
             }
-        });
-        const currentVal = this.toServiceJSON();
-        if (!(0, json_utils_1.deepEqual)(infoOnServer, currentVal)) {
-            await this.anonInvitesOnServer.setOnServer(currentVal);
+            throw exc;
         }
     }
     getAll() {

package/build/core/id-manager/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2018, 2020 - 2022 3NSoft Inc.
+ Copyright (C) 2015 - 2018, 2020 - 2022, 2025 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
@@ -72,15 +72,7 @@ class IdManager {
     }
     static async initFromCachedStore(address, fs, resolver, makeNet, logError, logWarning) {
         const store = key_storage_1.IdKeysStorage.makeWithStorage(fs, logError, logWarning);
-        const idManager = new IdManager(store, makeNet, resolver, address);
-        try {
-            await idManager.provisionUsingSavedKey();
-            return idManager;
-        }
-        catch (err) {
-            await logError(err, `Can't initialize id manager from local store`);
-            return;
-        }
+        return new IdManager(store, makeNet, resolver, address);
     }
     async startProvisionWithoutSavedKey(address) {
         const midUrl = await this.midServiceFor(address);

package/build/core/index.d.ts

@@ -20,13 +20,14 @@ export declare class Core {
     private asmail;
     private keyrings;
     private idManager;
-    private isInitialized;
     private closingProc;
+    private isInitialized;
     private constructor();
     static make(conf: CoreConf, makeNet: MakeNet, makeResolver: ServiceLocatorMaker, makeCryptor: makeCryptor): Core;
     start(): {
         capsForStartup: web3n.startup.W3N;
         coreInit: Promise<string>;
+        coreAppsInit: Promise<void>;
     };
     private initForNewUser;
     private initForExistingUserWithoutCache;
@@ -40,11 +41,9 @@ export declare class Core {
     private makeKeyringsCAP;
     private makeLogCAP;
     private makeMailerIdCAP;
-    private closeBroadcast;
-    close$: import("rxjs").Observable<void>;
     close(): Promise<void>;
     private performDataMigrationsAtInit;
-    private initCore;
+    private initCoreApps;
     getStorages(): FactoryOfFSs;
 }
 export {};

package/build/core/index.js

@@ -24,13 +24,12 @@ const sign_in_1 = require("./startup/sign-in");
 const asmail_1 = require("./asmail");
 const error_1 = require("../lib-common/exceptions/error");
 const json_utils_1 = require("../lib-common/json-utils");
-const rxjs_1 = require("rxjs");
 const log_to_file_1 = require("../lib-client/logging/log-to-file");
-const operators_1 = require("rxjs/operators");
 const app_files_1 = require("./app-files");
 const keyring_1 = require("./keyring");
 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, appDirs, logger, signUpUrl) {
         this.makeNet = makeNet;
@@ -39,94 +38,184 @@ class Core {
         this.logger = logger;
         this.signUpUrl = signUpUrl;
         this.idManager = undefined;
-        this.isInitialized = false;
         this.closingProc = undefined;
-        this.initForNewUser = async (u) => {
+        this.isInitialized = false;
+        this.cryptor = makeCryptor(this.logger.logError, this.logger.logWarning);
+        this.storages = new storage_1.Storages(this.cryptor.cryptor.sbox, this.appDirs.storagePathFor);
+        this.keyrings = new keyring_1.Keyrings(this.cryptor.cryptor.sbox);
+        this.asmail = new asmail_1.ASMail(this.cryptor.cryptor.sbox, this.makeNet, this.appDirs.inboxPathFor, this.logger);
+        Object.seal(this);
+    }
+    static make(conf, makeNet, makeResolver, makeCryptor) {
+        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, dirs, logger, conf.signUpUrl);
+        return core;
+    }
+    start() {
+        const { promise: midPromise, resolve: midDone } = (0, deferred_1.defer)();
+        const { watchBoot, emitBootEvent } = makeForBootEvents();
+        const signUp = new sign_up_1.SignUp(this.signUpUrl, this.cryptor.cryptor, this.makeNet, this.appDirs.getUsersOnDisk, user => this.initForNewUser(user, midDone, emitBootEvent), watchBoot, this.logger.logError);
+        const signIn = new sign_in_1.SignIn(this.cryptor.cryptor, addr => this.initForExistingUserWithoutCache(addr, midDone, emitBootEvent), (addr, storageKey) => this.initForExistingUserWithCache(addr, storageKey, midDone, emitBootEvent), this.appDirs.getUsersOnDisk, watchBoot, this.logger.logError);
+        const capsForStartup = {
+            signUp: signUp.exposedService(),
+            signIn: signIn.exposedService()
+        };
+        Object.freeze(capsForStartup);
+        const coreInit = midPromise.then(idManager => {
+            this.idManager = idManager;
+            return this.idManager.getId();
+        });
+        const coreAppsInit = coreInit.then(async () => {
+            // XXX This should be removed, at some point, as there will be no more
+            //     users with very old data folders.
+            await this.performDataMigrationsAtInit();
+            await this.initCoreApps(emitBootEvent);
+            this.isInitialized = true;
+        });
+        return { coreInit, coreAppsInit, capsForStartup };
+    }
+    ;
+    async initForNewUser(u, done, emitBootEvent) {
+        var _a;
+        emitBootEvent({
+            message: `Initializing system for new user ${u.address}`
+        });
+        try {
             // 1) init of id manager without setting fs
-            const stepTwo = await id_manager_1.IdManager.initWithoutStore(u.address, this.makeResolver('mailerid'), () => this.makeNet(), this.logger.logError, this.logger.logWarning);
+            const stepTwo = await id_manager_1.IdManager.initWithoutStore(u.address, this.makeResolver('mailerid'), this.makeNet, this.logger.logError, this.logger.logWarning);
             if (!stepTwo) {
-                throw new Error(`MailerId server doesn't recognize identity ${u.address}`);
+                const message = `MailerId server doesn't recognize identity ${u.address}`;
+                emitBootEvent({ message, isError: true });
+                throw new Error(message);
             }
+            emitBootEvent({ message: `✔️  started login to provision MailerId` });
             // 2) complete id manager login, without use of fs
             const idManagerInit = await stepTwo(u.midSKey.default);
             if (!idManagerInit) {
-                throw new Error(`Failed to provision MailerId identity`);
+                const message = `Failed to provision MailerId identity`;
+                emitBootEvent({ message, isError: true });
+                throw new Error(message);
             }
+            emitBootEvent({ message: `✔️  MailerId certificate provisioned` });
             const { idManager, setupManagerStorage } = idManagerInit;
             // 3) initialize all storages
+            emitBootEvent({ message: `Setting up main storage for new user` });
             const storesUp = await this.storages.initFreshForNewUser(u.address, idManager.getSigner, u.storeParams, u.storeSKey, this.makeNet, this.makeResolver('3nstorage'), this.logger.logError);
             if (!storesUp) {
-                throw new Error(`Stores failed to initialize`);
+                const message = `Main store failed to initialize for new user`;
+                emitBootEvent({ message, isError: true });
+                throw new Error(message);
             }
+            emitBootEvent({ message: `✔️  main storage initialized` });
             // 3) give id manager fs, in which it will record labeled key(s)
+            emitBootEvent({ coreApp: constants_1.MAILERID_APP_NAME, message: `setting up storage` });
             await setupManagerStorage(await this.storages.makeSyncedFSForApp(constants_1.MAILERID_APP_NAME), [u.midSKey.labeled]);
-            return idManager;
-        };
-        this.initForExistingUserWithoutCache = async (address) => {
+            emitBootEvent({ coreApp: constants_1.MAILERID_APP_NAME, message: `✔️  storage setup completed` });
+            done(idManager);
+        }
+        catch (exc) {
+            if (exc.type === 'connect') {
+                emitBootEvent({ message: `🔌  fail due to loss of connectivity`, isError: true });
+            }
+            else {
+                emitBootEvent({ message: (_a = exc.message) !== null && _a !== void 0 ? _a : (0, error_1.stringifyErr)(exc), isError: true });
+            }
+            throw exc;
+        }
+    }
+    async initForExistingUserWithoutCache(address, done, emitBootEvent) {
+        var _a;
+        emitBootEvent({
+            message: `Initializing system for user ${address}, without local cache on this device`
+        });
+        try {
             // 1) init of id manager without setting fs
-            const stepTwo = await id_manager_1.IdManager.initWithoutStore(address, this.makeResolver('mailerid'), () => this.makeNet(), this.logger.logError, this.logger.logWarning);
+            const stepTwo = await id_manager_1.IdManager.initWithoutStore(address, this.makeResolver('mailerid'), this.makeNet, this.logger.logError, this.logger.logWarning);
             if (!stepTwo) {
+                emitBootEvent({
+                    isError: true, message: `MailerId server doesn't recognize identity ${address}`
+                });
                 return;
             }
             return async (midLoginKey, storageKey) => {
-                // 2) complete id manager login, without use of fs
-                const idManagerInit = await stepTwo(midLoginKey);
-                if (!idManagerInit) {
-                    return;
+                var _a;
+                try {
+                    // 2) complete id manager login, without use of fs
+                    const idManagerInit = await stepTwo(midLoginKey);
+                    if (!idManagerInit) {
+                        emitBootEvent({
+                            isError: true, message: `password/key is incorrect to provision MailerId certificate`
+                        });
+                        return false;
+                    }
+                    emitBootEvent({ message: `✔️  MailerId certificate provisioned` });
+                    const { idManager, setupManagerStorage } = idManagerInit;
+                    // 3) initialize all storages
+                    emitBootEvent({ message: `Setting up main storage without local cache` });
+                    const storeDone = await this.storages.initFromRemote(address, idManager.getSigner, storageKey, this.makeNet, this.makeResolver('3nstorage'), this.logger.logError);
+                    if (!storeDone) {
+                        emitBootEvent({ message: `Main store failed to initialize`, isError: true });
+                        return false;
+                    }
+                    emitBootEvent({ message: `✔️  main storage initialized` });
+                    // 4) complete initialization of id manager
+                    emitBootEvent({ coreApp: constants_1.MAILERID_APP_NAME, message: `setting up storage` });
+                    await setupManagerStorage(await this.storages.makeSyncedFSForApp(constants_1.MAILERID_APP_NAME));
+                    emitBootEvent({ coreApp: constants_1.MAILERID_APP_NAME, message: `✔️  storage setup completed` });
+                    done(idManager);
+                    return true;
                 }
-                const { idManager, setupManagerStorage } = idManagerInit;
-                // 3) initialize all storages
-                const storeDone = await this.storages.initFromRemote(address, idManager.getSigner, storageKey, this.makeNet, this.makeResolver('3nstorage'), this.logger.logError);
-                if (!storeDone) {
-                    return;
+                catch (exc) {
+                    if (exc.type === 'connect') {
+                        emitBootEvent({ message: `🔌  fail due to loss of connectivity`, isError: true });
+                    }
+                    else {
+                        emitBootEvent({ message: (_a = exc.message) !== null && _a !== void 0 ? _a : (0, error_1.stringifyErr)(exc), isError: true });
+                    }
+                    throw exc;
                 }
-                // 4) complete initialization of id manager
-                await setupManagerStorage(await this.storages.makeSyncedFSForApp(constants_1.MAILERID_APP_NAME));
-                return idManager;
             };
-        };
-        this.initForExistingUserWithCache = async (address, storageKey) => {
+        }
+        catch (exc) {
+            if (exc.type === 'connect') {
+                emitBootEvent({ message: `🔌  fail due to loss of connectivity`, isError: true });
+            }
+            else {
+                emitBootEvent({ message: (_a = exc.message) !== null && _a !== void 0 ? _a : (0, error_1.stringifyErr)(exc), isError: true });
+            }
+            throw exc;
+        }
+    }
+    async initForExistingUserWithCache(address, storageKey, done, emitBootEvent) {
+        var _a;
+        emitBootEvent({
+            message: `Initializing system for user ${address}, with local cache on this device`
+        });
+        try {
+            emitBootEvent({ message: `Unlocking data from local cache with provided password/key` });
             const completeStorageInit = await this.storages.startInitFromCache(address, storageKey, this.makeNet, this.makeResolver('3nstorage'), this.logger.logError);
             if (!completeStorageInit) {
-                return;
+                emitBootEvent({
+                    isError: true, message: `password/key is incorrect to decrypt local caches, or caches are damaged`
+                });
+                return false;
             }
-            const idManager = await id_manager_1.IdManager.initFromCachedStore(address, await this.storages.makeSyncedFSForApp(constants_1.MAILERID_APP_NAME), this.makeResolver('mailerid'), () => this.makeNet(), this.logger.logError, this.logger.logWarning);
+            emitBootEvent({ message: `✔️  main storage is opened` });
+            const idManager = await id_manager_1.IdManager.initFromCachedStore(address, await this.storages.makeSyncedFSForApp(constants_1.MAILERID_APP_NAME), this.makeResolver('mailerid'), this.makeNet, this.logger.logError, this.logger.logWarning);
             if (!idManager) {
-                return;
+                return false;
             }
+            emitBootEvent({ message: `✔️  MailerId manager is initialized` });
             completeStorageInit(idManager.getSigner);
-            return idManager;
-        };
-        this.closeBroadcast = new rxjs_1.Subject();
-        this.close$ = this.closeBroadcast.asObservable();
-        this.cryptor = makeCryptor(this.logger.logError, this.logger.logWarning);
-        this.storages = new storage_1.Storages(this.cryptor.cryptor.sbox, this.appDirs.storagePathFor);
-        this.keyrings = new keyring_1.Keyrings(this.cryptor.cryptor.sbox);
-        this.asmail = new asmail_1.ASMail(this.cryptor.cryptor.sbox, this.makeNet, this.appDirs.inboxPathFor, this.logger);
-        Object.seal(this);
-    }
-    static make(conf, makeNet, makeResolver, makeCryptor) {
-        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, dirs, logger, conf.signUpUrl);
-        return core;
-    }
-    start() {
-        const signUp = new sign_up_1.SignUp(this.signUpUrl, this.cryptor.cryptor, this.makeNet.bind(this), this.appDirs.getUsersOnDisk, this.logger.logError);
-        const signIn = new sign_in_1.SignIn(this.cryptor.cryptor, this.initForExistingUserWithoutCache, this.initForExistingUserWithCache, this.appDirs.getUsersOnDisk, this.logger.logError);
-        const capsForStartup = {
-            signUp: signUp.exposedService(),
-            signIn: signIn.exposedService()
-        };
-        Object.freeze(capsForStartup);
-        const initFromSignUp$ = signUp.newUser$
-            .pipe((0, operators_1.mergeMap)(this.initForNewUser, 1));
-        const initFromSignIn$ = signIn.existingUser$;
-        const coreInit = (0, rxjs_1.lastValueFrom)((0, rxjs_1.merge)(initFromSignIn$, initFromSignUp$)
-            .pipe((0, operators_1.take)(1), (0, operators_1.mergeMap)(idManager => this.initCore(idManager), 1)));
-        return { coreInit, capsForStartup };
+            done(idManager);
+            return true;
+        }
+        catch (exc) {
+            emitBootEvent({ message: (_a = exc.message) !== null && _a !== void 0 ? _a : (0, error_1.stringifyErr)(exc), isError: true });
+            throw exc;
+        }
     }
-    ;
     makeCAPsForApp(appDomain, requestedCAPs) {
         if (!this.isInitialized || this.closingProc) {
             throw new Error(`Core is either not yet initialized, or is already closed.`);
@@ -203,7 +292,6 @@ class Core {
                 }
                 await this.cryptor.close();
                 this.cryptor = undefined;
-                this.closeBroadcast.next();
             })();
         }
         await this.closingProc;
@@ -213,25 +301,26 @@ class Core {
         await this.storages.migrateCoreAppDataOnFirstRun('synced', `${constants_1.ASMAIL_APP_NAME}/config/introductory-key.json`, `${constants_1.KEYRINGS_APP_NAME}/introductory-keys/published-on-server.json`);
         await this.storages.migrateCoreAppDataOnFirstRun('synced', `${constants_1.ASMAIL_APP_NAME}/config/anonymous/invites.json`, `${constants_1.ASMAIL_APP_NAME}/sending-params/anonymous-invites.json`);
     }
-    async initCore(idManager) {
+    async initCoreApps(emitBootEvent) {
+        // XXX push events to this.bootProcObserver
+        var _a;
         try {
-            this.idManager = idManager;
             const address = this.idManager.getId();
             const getSigner = this.idManager.getSigner;
             const asmailServerConfig = new config_1.ConfigOfASMailServer(address, getSigner, this.makeResolver('asmail'), this.makeNet());
-            // XXX This should be removed, at some point, as there will be no more
-            //     users with very old data folders.
-            await this.performDataMigrationsAtInit();
+            emitBootEvent({ coreApp: constants_1.KEYRINGS_APP_NAME, message: `starting initialization` });
             const keyringsSyncedFS = await this.storages.makeSyncedFSForApp(constants_1.KEYRINGS_APP_NAME);
             await this.keyrings.init(keyringsSyncedFS, this.idManager.getSigner, asmailServerConfig.makeParamSetterAndGetter('init-pub-key'));
+            emitBootEvent({ coreApp: constants_1.KEYRINGS_APP_NAME, message: `✔️  initialized` });
+            emitBootEvent({ coreApp: constants_1.ASMAIL_APP_NAME, message: `starting initialization` });
             const inboxSyncedFS = await this.storages.makeSyncedFSForApp(constants_1.ASMAIL_APP_NAME);
             const inboxLocalFS = await this.storages.makeLocalFSForApp(constants_1.ASMAIL_APP_NAME);
             await this.asmail.init(this.idManager.getId(), this.idManager.getSigner, inboxSyncedFS, inboxLocalFS, this.storages.storageGetterForASMail(), this.makeResolver, asmailServerConfig, this.keyrings.forASMail());
-            this.isInitialized = true;
-            return this.idManager.getId();
+            emitBootEvent({ coreApp: constants_1.ASMAIL_APP_NAME, message: `✔️  initialized` });
         }
         catch (err) {
-            throw (0, error_1.errWithCause)(err, 'Failed to initialize core');
+            emitBootEvent({ isError: true, message: (_a = err.message) !== null && _a !== void 0 ? _a : (0, error_1.stringifyErr)(err) });
+            throw (0, error_1.errWithCause)(err, 'Failed to initialize core apps');
         }
     }
     getStorages() {
@@ -241,6 +330,25 @@ class Core {
 exports.Core = Core;
 Object.freeze(Core.prototype);
 Object.freeze(Core);
+function makeForBootEvents() {
+    let bootProcObserver = undefined;
+    return {
+        watchBoot(obs) {
+            var _a;
+            if (bootProcObserver) {
+                (_a = bootProcObserver.error) === null || _a === void 0 ? void 0 : _a.call(bootProcObserver, `New observer is added, and it stops the previous one.`);
+            }
+            bootProcObserver = obs;
+            return () => {
+                bootProcObserver = undefined;
+            };
+        },
+        emitBootEvent(ev) {
+            var _a;
+            (_a = bootProcObserver === null || bootProcObserver === void 0 ? void 0 : bootProcObserver.next) === null || _a === void 0 ? void 0 : _a.call(bootProcObserver, ev);
+        }
+    };
+}
 function makeStoragePolicy(appDomain, requestedCAPs) {
     if (!requestedCAPs.storage) {
         throw new Error(`Missing storage setting in app's manifest`);

package/build/core/startup/sign-in.d.ts

@@ -1,29 +1,27 @@
-import type { IdManager } from '../id-manager';
 import { ScryptGenParams } from '../../lib-client/key-derivation';
 import type { GetUsersOnDisk } from '../app-files';
 import { Cryptor } from '../../lib-client/cryptor/cryptor';
 import { LogError } from '../../lib-client/logging/log-to-file';
 export type GenerateKey = (derivParams: ScryptGenParams) => Promise<Uint8Array>;
 export type StartInitWithoutCache = (address: string) => Promise<CompleteInitWithoutCache | undefined>;
-export type CompleteInitWithoutCache = (midLoginKey: GenerateKey, storageKey: GenerateKey) => Promise<IdManager | undefined>;
-export type InitWithCache = (address: string, storageKey: GenerateKey) => Promise<IdManager | undefined>;
+export type CompleteInitWithoutCache = (midLoginKey: GenerateKey, storageKey: GenerateKey) => Promise<boolean>;
+export type InitWithCache = (address: string, storageKey: GenerateKey) => Promise<boolean>;
 type SignInService = web3n.startup.SignInService;
+type ProgressCB = web3n.startup.ProgressCB;
 export declare class SignIn {
     private cryptor;
     private startInitWithoutCache;
     private initWithCache;
     private getUsersOnDisk;
+    private readonly watchBoot;
     private readonly logError;
     private completeInitWithoutCache;
-    constructor(cryptor: Cryptor, startInitWithoutCache: StartInitWithoutCache, initWithCache: InitWithCache, getUsersOnDisk: GetUsersOnDisk, logError: LogError);
+    constructor(cryptor: Cryptor, startInitWithoutCache: StartInitWithoutCache, initWithCache: InitWithCache, getUsersOnDisk: GetUsersOnDisk, watchBoot: SignInService['watchBoot'], logError: LogError);
     exposedService(): SignInService;
     private startLoginToRemoteStorage;
     private completeLoginAndLocalSetup;
-    private readonly doneBroadcast;
-    readonly existingUser$: import("rxjs").Observable<IdManager>;
     private useExistingStorage;
     private logAndWrap;
 }
-export type ProgressCB = (p: number) => void;
 export declare function makeKeyGenProgressCB(progressStart: number, progressEnd: number, progressCB: ProgressCB): ProgressCB;
 export {};

package/build/core/startup/sign-in.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2018, 2020, 2022 3NSoft Inc.
+ Copyright (C) 2015 - 2018, 2020, 2022, 2025 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
@@ -19,75 +19,62 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SignIn = void 0;
 exports.makeKeyGenProgressCB = makeKeyGenProgressCB;
 const key_derivation_1 = require("../../lib-client/key-derivation");
-const rxjs_1 = require("rxjs");
 const error_1 = require("../../lib-common/exceptions/error");
 class SignIn {
-    constructor(cryptor, startInitWithoutCache, initWithCache, getUsersOnDisk, logError) {
+    constructor(cryptor, startInitWithoutCache, initWithCache, getUsersOnDisk, watchBoot, logError) {
         this.cryptor = cryptor;
         this.startInitWithoutCache = startInitWithoutCache;
         this.initWithCache = initWithCache;
         this.getUsersOnDisk = getUsersOnDisk;
+        this.watchBoot = watchBoot;
         this.logError = logError;
         this.completeInitWithoutCache = undefined;
-        this.startLoginToRemoteStorage = async (address) => {
-            try {
-                this.completeInitWithoutCache = await this.startInitWithoutCache(address);
-                return !!this.completeInitWithoutCache;
-            }
-            catch (err) {
-                throw await this.logAndWrap(err, 'Fail to start login to remote storage');
-            }
-        };
-        this.completeLoginAndLocalSetup = async (pass, progressCB) => {
-            if (!this.completeInitWithoutCache) {
-                throw new Error(`Call method startLoginToRemoteStorage() before calling this.`);
-            }
-            try {
-                const midKeyProgressCB = makeKeyGenProgressCB(0, 50, progressCB);
-                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 => (0, key_derivation_1.deriveStorageSKey)(this.cryptor, pass, params, storeKeyProgressCB);
-                const idManager = await this.completeInitWithoutCache(midKeyGen, storeKeyGen);
-                if (!idManager) {
-                    return false;
-                }
-                this.doneBroadcast.next(idManager);
-                return true;
-            }
-            catch (err) {
-                throw await this.logAndWrap(err, 'Fail to initialize from a state without cache');
-            }
-        };
-        this.doneBroadcast = new rxjs_1.Subject();
-        this.existingUser$ = this.doneBroadcast.asObservable();
-        this.useExistingStorage = async (user, pass, progressCB) => {
-            try {
-                const storeKeyProgressCB = makeKeyGenProgressCB(0, 99, progressCB);
-                const storeKeyGen = params => (0, key_derivation_1.deriveStorageSKey)(this.cryptor, pass, params, storeKeyProgressCB);
-                const idManager = await this.initWithCache(user, storeKeyGen);
-                if (idManager) {
-                    this.doneBroadcast.next(idManager);
-                    return true;
-                }
-                else {
-                    return false;
-                }
-            }
-            catch (err) {
-                throw await this.logAndWrap(err, 'Failing to start in a state with cache');
-            }
-        };
         Object.seal(this);
     }
     exposedService() {
         const service = {
-            completeLoginAndLocalSetup: this.completeLoginAndLocalSetup,
+            completeLoginAndLocalSetup: this.completeLoginAndLocalSetup.bind(this),
             getUsersOnDisk: this.getUsersOnDisk,
-            startLoginToRemoteStorage: this.startLoginToRemoteStorage,
-            useExistingStorage: this.useExistingStorage
+            startLoginToRemoteStorage: this.startLoginToRemoteStorage.bind(this),
+            useExistingStorage: this.useExistingStorage.bind(this),
+            watchBoot: this.watchBoot
         };
         return Object.freeze(service);
     }
+    async startLoginToRemoteStorage(address) {
+        try {
+            this.completeInitWithoutCache = await this.startInitWithoutCache(address);
+            return !!this.completeInitWithoutCache;
+        }
+        catch (err) {
+            throw await this.logAndWrap(err, 'Fail to start login to remote storage');
+        }
+    }
+    async completeLoginAndLocalSetup(pass, progressCB) {
+        if (!this.completeInitWithoutCache) {
+            throw new Error(`Call method startLoginToRemoteStorage() before calling this.`);
+        }
+        try {
+            const midKeyProgressCB = makeKeyGenProgressCB(0, 50, progressCB);
+            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 => (0, key_derivation_1.deriveStorageSKey)(this.cryptor, pass, params, storeKeyProgressCB);
+            return await this.completeInitWithoutCache(midKeyGen, storeKeyGen);
+        }
+        catch (err) {
+            throw await this.logAndWrap(err, 'Fail to initialize from a state without cache');
+        }
+    }
+    async useExistingStorage(user, pass, progressCB) {
+        try {
+            const storeKeyProgressCB = makeKeyGenProgressCB(0, 99, progressCB);
+            const storeKeyGen = params => (0, key_derivation_1.deriveStorageSKey)(this.cryptor, pass, params, storeKeyProgressCB);
+            return await this.initWithCache(user, storeKeyGen);
+        }
+        catch (err) {
+            throw await this.logAndWrap(err, 'Failing to start in a state with cache');
+        }
+    }
     async logAndWrap(err, msg) {
         await this.logError(err, msg);
         return (0, error_1.errWithCause)(err, msg);

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

@@ -15,14 +15,18 @@ export declare class SignUp {
     private cryptor;
     private makeNet;
     private getUsersOnDisk;
+    private initForNewUser;
+    private readonly watchBoot;
     private readonly logError;
     private mid;
     private store;
     private serviceURL;
     private netLazyInit;
     private get net();
-    constructor(serviceURL: string, cryptor: Cryptor, makeNet: () => NetClient, getUsersOnDisk: GetUsersOnDisk, logError: LogError);
+    constructor(serviceURL: string, cryptor: Cryptor, makeNet: () => NetClient, getUsersOnDisk: GetUsersOnDisk, initForNewUser: (u: CreatedUser) => Promise<void>, watchBoot: SignUpService['watchBoot'], logError: LogError);
     private setServiceURL;
+    private getAvailableDomains;
+    private getAvailableAddresses;
     exposedService(): SignUpService;
     private createUserParams;
     private genStorageParams;
@@ -30,8 +34,6 @@ export declare class SignUp {
     private addUser;
     private logAndWrap;
     private forgetKeys;
-    private doneBroadcast;
-    newUser$: import("rxjs").Observable<CreatedUser>;
 }
 export interface CreatedUser {
     address: string;

package/build/core/startup/sign-up.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2020, 2022 - 2023 3NSoft Inc.
+ Copyright (C) 2015 - 2020, 2022 - 2023, 2025 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
@@ -26,7 +26,6 @@ const keyDeriv = require("../../lib-client/key-derivation");
 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:
@@ -63,54 +62,21 @@ class SignUp {
         }
         return this.netLazyInit;
     }
-    constructor(serviceURL, cryptor, makeNet, getUsersOnDisk, logError) {
+    constructor(serviceURL, cryptor, makeNet, getUsersOnDisk, initForNewUser, watchBoot, logError) {
         this.cryptor = cryptor;
         this.makeNet = makeNet;
         this.getUsersOnDisk = getUsersOnDisk;
+        this.initForNewUser = initForNewUser;
+        this.watchBoot = watchBoot;
         this.logError = logError;
         this.mid = undefined;
         this.store = undefined;
         this.serviceURL = undefined;
         this.netLazyInit = undefined;
-        this.createUserParams = async (pass, progressCB) => {
-            await this.genMidParams(pass, 0, 50, progressCB);
-            await this.genStorageParams(pass, 51, 100, progressCB);
-        };
-        this.addUser = async (address, signupToken) => {
-            for (const user of await this.getUsersOnDisk()) {
-                if ((0, canonical_address_1.areAddressesEqual)(address, user)) {
-                    throw new Error(`Account ${user} already exists on a disk.`);
-                }
-            }
-            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) => {
-                throw await this.logAndWrap(err, `Failed to create user account ${address}.`);
-            });
-            if (!accountCreated) {
-                return false;
-            }
-            this.doneBroadcast.next({
-                address,
-                midSKey: {
-                    default: this.mid.defaultSKey,
-                    labeled: this.mid.labeledSKey
-                },
-                storeSKey: this.store.skey,
-                storeParams: this.store.params.kdParams
-            });
-            this.forgetKeys();
-            return true;
-        };
-        this.doneBroadcast = new rxjs_1.Subject();
-        this.newUser$ = this.doneBroadcast.asObservable();
         this.setServiceURL(serviceURL);
         Object.seal(this);
     }
-    setServiceURL(serviceURL) {
+    async setServiceURL(serviceURL) {
         const url = (0, url_1.parse)(serviceURL);
         if (url.protocol !== 'https:') {
             throw new Error("Url protocol must be https.");
@@ -120,17 +86,28 @@ class SignUp {
             this.serviceURL += '/';
         }
     }
+    async getAvailableDomains(signupToken) {
+        return await (0, _3nweb_signup_1.checkAvailableDomains)(this.net, this.serviceURL, signupToken);
+    }
+    async getAvailableAddresses(name, signupToken) {
+        return await (0, _3nweb_signup_1.checkAvailableAddressesForName)(this.net, this.serviceURL, name, signupToken);
+    }
     exposedService() {
         const service = {
-            setSignUpServer: async (srvUrl) => this.setServiceURL(srvUrl),
-            getAvailableDomains: signupToken => (0, _3nweb_signup_1.checkAvailableDomains)(this.net, this.serviceURL, signupToken),
-            addUser: this.addUser,
-            createUserParams: this.createUserParams,
-            getAvailableAddresses: (name, signupToken) => (0, _3nweb_signup_1.checkAvailableAddressesForName)(this.net, this.serviceURL, name, signupToken),
-            isActivated: async () => { throw new Error(`Not implemented, yet`); }
+            setSignUpServer: this.setServiceURL.bind(this),
+            getAvailableDomains: this.getAvailableDomains.bind(this),
+            addUser: this.addUser.bind(this),
+            createUserParams: this.createUserParams.bind(this),
+            getAvailableAddresses: this.getAvailableAddresses.bind(this),
+            isActivated: () => { throw new Error(`Not implemented, yet`); },
+            watchBoot: this.watchBoot
         };
         return Object.freeze(service);
     }
+    async createUserParams(pass, progressCB) {
+        await this.genMidParams(pass, 0, 50, progressCB);
+        await this.genStorageParams(pass, 51, 100, progressCB);
+    }
     async genStorageParams(pass, progressStart, progressEnd, originalProgressCB) {
         const derivParams = {
             logN: defaultDerivParams.logN,
@@ -169,6 +146,35 @@ class SignUp {
             }
         };
     }
+    async addUser(address, signupToken) {
+        for (const user of await this.getUsersOnDisk()) {
+            if ((0, canonical_address_1.areAddressesEqual)(address, user)) {
+                throw new Error(`Account ${user} already exists on a disk.`);
+            }
+        }
+        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) => {
+            throw await this.logAndWrap(err, `Failed to create user account ${address}.`);
+        });
+        if (!accountCreated) {
+            return false;
+        }
+        this.initForNewUser({
+            address,
+            midSKey: {
+                default: this.mid.defaultSKey,
+                labeled: this.mid.labeledSKey
+            },
+            storeSKey: this.store.skey,
+            storeParams: this.store.params.kdParams
+        });
+        this.forgetKeys();
+        return true;
+    }
     async logAndWrap(err, msg) {
         await this.logError(err, msg);
         return (0, error_1.errWithCause)(err, msg);

package/build/core/startup/startup-cap.js

@@ -44,7 +44,8 @@ function wrapSignInCAP(cap) {
                 (_b = obs.complete) === null || _b === void 0 ? void 0 : _b.call(obs);
             }, err => { var _a; return (_a = obs.error) === null || _a === void 0 ? void 0 : _a.call(obs, err); });
             return noop;
-        })
+        }),
+        watchBoot: (0, service_side_wrap_1.wrapObservingFunc)(cap.watchBoot)
     };
 }
 function makeSignInCaller(caller, objPath) {
@@ -66,7 +67,8 @@ function makeSignInCaller(caller, objPath) {
                 obsFn(obs, addr, pass);
                 return promise;
             };
-        })()
+        })(),
+        watchBoot: (0, caller_side_wrap_1.makeObservableFuncCaller)(caller, objPath.concat('watchBoot'))
     };
 }
 function callSignIn(caller, objPath, method) {
@@ -104,7 +106,8 @@ function wrapSignUpCAP(cap) {
                 .then(() => { var _a; return (_a = obs.complete) === null || _a === void 0 ? void 0 : _a.call(obs); }, err => { var _a; return (_a = obs.error) === null || _a === void 0 ? void 0 : _a.call(obs, err); });
             return noop;
         }),
-        isActivated: (0, service_side_wrap_1.wrapReqReplySrvMethod)(cap, 'isActivated')
+        isActivated: (0, service_side_wrap_1.wrapReqReplySrvMethod)(cap, 'isActivated'),
+        watchBoot: (0, service_side_wrap_1.wrapObservingFunc)(cap.watchBoot)
     };
 }
 function noop() { }
@@ -129,7 +132,8 @@ function makeSignUpCaller(caller, objPath) {
                 return completion.promise;
             };
         })(),
-        isActivated: callSignUp(caller, objPath, 'isActivated')
+        isActivated: callSignUp(caller, objPath, 'isActivated'),
+        watchBoot: (0, caller_side_wrap_1.makeObservableFuncCaller)(caller, objPath.concat('watchBoot'))
     };
 }
 Object.freeze(exports);

package/build/lib-client/server-events.js

@@ -95,7 +95,7 @@ class ServerEvents {
         if (!exc.runtimeException) {
             return false;
         }
-        if (exc.type === 'http-connect') {
+        if (exc.type === 'connect') {
             return true;
         }
         else if (exc.type === 'http-request') {

package/build/lib-client/service-locator.js

@@ -24,6 +24,7 @@ exports.getMailerIdInfoFor = getMailerIdInfoFor;
 const jwkeys_1 = require("../lib-common/jwkeys");
 const url_1 = require("url");
 const request_utils_1 = require("./request-utils");
+const runtime_1 = require("../lib-common/exceptions/runtime");
 async function readJSONLocatedAt(client, url) {
     if ((0, url_1.parse)(url).protocol !== 'https:') {
         throw new Error("Url protocol must be https.");
@@ -143,23 +144,17 @@ function checkAndPrepareURL(value) {
     return 'https://' + value;
 }
 function domainNotFoundExc(address, cause) {
-    const exc = {
-        runtimeException: true,
-        type: 'service-locating',
-        address,
-        domainNotFound: true,
-        cause
-    };
-    return exc;
+    return (0, runtime_1.makeRuntimeException)('service-locating', { address, cause }, { domainNotFound: true });
 }
 function noServiceRecordExc(address) {
-    const exc = {
-        runtimeException: true,
-        type: 'service-locating',
-        address,
-        noServiceRecord: true
-    };
-    return exc;
+    return (0, runtime_1.makeRuntimeException)('service-locating', { address }, { noServiceRecord: true });
+}
+function noConnectionExc(cause) {
+    return (0, runtime_1.makeRuntimeException)('connect', {
+        connectType: 'dns',
+        message: `The most likely cause of this error is device not connected. Next likely cause is DNS not setup, or not connecting properly. Like the saying goes: "It's not DNS. There is no way it's DNS. It was DNS."`,
+        cause
+    }, {});
 }
 /**
  * This implementation extracts exactly one string value for a given service.
@@ -227,7 +222,8 @@ function getRecordAtStartOf(txt) {
 }
 const DNS_ERR_CODE = {
     NODATA: 'ENODATA',
-    NOTFOUND: 'ENOTFOUND'
+    NOTFOUND: 'ENOTFOUND',
+    ESERVFAIL: 'ESERVFAIL'
 };
 Object.freeze(DNS_ERR_CODE);
 function makeServiceLocator(resolver) {
@@ -247,6 +243,9 @@ function makeServiceLocator(resolver) {
             if (code === DNS_ERR_CODE.NODATA) {
                 throw noServiceRecordExc(address);
             }
+            else if (code === DNS_ERR_CODE.ESERVFAIL) {
+                throw noConnectionExc({ code, hostname, message });
+            }
             else if (hostname) {
                 throw domainNotFoundExc(address, { code, hostname, message });
             }

package/build/lib-common/exceptions/http.d.ts

@@ -1,4 +1,4 @@
-export type ConnectException = web3n.ConnectException;
+export type ConnectException = web3n.HTTPConnectException;
 export type HTTPException = web3n.HTTPException;
-export declare function makeConnectionException(url: string | undefined, method: string | undefined, msg?: string, cause?: any): ConnectException;
-export declare function makeHTTPException(url: string, method: string, status: number, msg?: string, cause?: any): HTTPException;
+export declare function makeConnectionException(url: string | undefined, method: string | undefined, message?: string, cause?: any): ConnectException;
+export declare function makeHTTPException(url: string, method: string, status: number, message?: string, cause?: any): HTTPException;

package/build/lib-common/exceptions/http.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 3NSoft Inc.
+ Copyright (C) 2015, 2025 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
@@ -17,31 +17,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeConnectionException = makeConnectionException;
 exports.makeHTTPException = makeHTTPException;
-function makeConnectionException(url, method, msg, cause) {
-    const exc = {
-        runtimeException: true,
-        type: 'http-connect',
-        url: url,
-        method: method,
-        cause
-    };
-    if (msg) {
-        exc.message = msg;
-    }
-    return exc;
+const runtime_1 = require("./runtime");
+function makeConnectionException(url, method, message, cause) {
+    return (0, runtime_1.makeRuntimeException)('connect', { connectType: 'http', url, method, cause, message }, {});
 }
-function makeHTTPException(url, method, status, msg, cause) {
-    const exc = {
-        runtimeException: true,
-        type: 'http-request',
-        url: url,
-        method: method,
-        status: status,
-        cause
-    };
-    if (msg) {
-        exc.message = msg;
-    }
-    return exc;
+function makeHTTPException(url, method, status, message, cause) {
+    return (0, runtime_1.makeRuntimeException)('http-request', { url, method, status, cause, message }, {});
 }
 Object.freeze(exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-3nweb-client-lib",
-  "version": "0.38.1",
+  "version": "0.40.0",
   "description": "3NWeb client core library, embeddable into different environments",
   "main": "build/lib-index.js",
   "types": "build/lib-index.d.ts",