core-3nweb-client-lib 0.49.8 → 0.50.0

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/fs-utils/fs-sync-utils.d.ts

@@ -5,7 +5,7 @@ type RemoteEvent = web3n.files.RemoteEvent;
 type FileEvent = web3n.files.FileEvent;
 type FolderEvent = web3n.files.FolderEvent;
 export declare function getRemoteFolderChanges(fs: WritableFS): Promise<void>;
-export declare function getOrMakeSyncedDirOnInit(syncedFS: WritableFS, dir: string): Promise<WritableFS>;
+export declare function getOrMakeDirOnInit(syncedFS: WritableFS, dir: string): Promise<WritableFS>;
 export declare function uploadFolderChangesIfAny(fs: WritableFS): Promise<void>;
 export declare function observableFromTreeEvents(fs: ReadonlyFS, rootPath: string): Observable<RemoteEvent | FileEvent | FolderEvent>;
 export {};

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

@@ -17,12 +17,11 @@
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRemoteFolderChanges = getRemoteFolderChanges;
-exports.getOrMakeSyncedDirOnInit = getOrMakeSyncedDirOnInit;
+exports.getOrMakeDirOnInit = getOrMakeDirOnInit;
 exports.uploadFolderChangesIfAny = uploadFolderChangesIfAny;
 exports.observableFromTreeEvents = observableFromTreeEvents;
 const rxjs_1 = require("rxjs");
 const exceptions_1 = require("../xsp-fs/exceptions");
-const assert_1 = require("../../lib-common/assert");
 async function getRemoteFolderChanges(fs) {
     let { state } = await fs.v.sync.status('');
     if (state === 'behind') {
@@ -36,13 +35,16 @@ async function getRemoteFolderChanges(fs) {
         });
     }
 }
-async function getOrMakeSyncedDirOnInit(syncedFS, dir) {
+async function getOrMakeDirOnInit(syncedFS, dir) {
     // Except for initial time, all folders exist and synced into parent, so, we shortcut sync check, if dir exists.
     // This allows to start while offline, when initialization has been done.
     if (await syncedFS.checkFolderPresence(dir)) {
         return await syncedFS.writableSubRoot(dir, { create: false });
     }
-    await ensureIsInSyncedState(syncedFS);
+    await attemptToBringToSyncedState(syncedFS)
+        .catch(exc => {
+        console.error(`\n ------`, dir, exc);
+    });
     if (await syncedFS.checkFolderPresence(dir)) {
         return await syncedFS.writableSubRoot(dir, { create: false });
     }
@@ -58,15 +60,10 @@ async function getOrMakeSyncedDirOnInit(syncedFS, dir) {
     }
 }
 function noop() { }
-async function ensureIsInSyncedState(syncedFS) {
+async function attemptToBringToSyncedState(syncedFS) {
     const { existsInSyncedParent, state, remote } = await syncedFS.v.sync.status('');
-    // assert(!!existsInSyncedParent, `${syncedFS.name} is not present in synced parent, preventing further construction of synced fs tree`);
-    if (state === 'synced') {
-        return;
-    }
-    else if (state === 'behind') {
+    if (state === 'behind') {
         await syncedFS.v.sync.adoptRemote('.');
-        return;
     }
     else if (state === 'unsynced') {
         await syncedFS.v.sync.upload('.').catch(async (exc) => {
@@ -77,11 +74,20 @@ async function ensureIsInSyncedState(syncedFS) {
                 await recursivelyUploadNewTreeItems(syncedFS, '.');
             }
         });
-        return;
     }
-    (0, assert_1.assert)(state !== 'conflicting');
+    else if (state === 'conflicting') {
+        await syncedFS.v.sync.absorbRemoteFolderChanges('.');
+        await syncedFS.v.sync.upload('.', { uploadVersion: remote.latest }).catch(async (exc) => {
+            if (exc.type !== 'fs-sync') {
+                throw exc;
+            }
+            else if (exc.childNeverUploaded) {
+                await recursivelyUploadNewTreeItems(syncedFS, '.', remote.latest);
+            }
+        });
+    }
 }
-async function recursivelyUploadNewTreeItems(fs, path) {
+async function recursivelyUploadNewTreeItems(fs, path, uploadVersion) {
     for (const item of await fs.listFolder(path)) {
         const { remote, synced } = await fs.v.sync.status(`${path}/${item.name}`);
         if (remote || synced) {
@@ -92,7 +98,7 @@ async function recursivelyUploadNewTreeItems(fs, path) {
         }
         await fs.v.sync.upload(`${path}/${item.name}`);
     }
-    await fs.v.sync.upload(path);
+    await fs.v.sync.upload(path, { uploadVersion });
 }
 // export async function getOrMakeAndUploadFolderIn(fs: WritableFS, folder: string): Promise<WritableFS> {
 // 	try {

package/build/lib-client/xsp-fs/util/file-based-json.js

@@ -20,7 +20,7 @@ exports.JsonFileProc = void 0;
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const synced_1 = require("../../../lib-common/processes/synced");
-// XXX File proc can have general flow for sync
+// XXX File proc can have general flow for sync, missing now!
 class JsonFileProc {
     constructor(onFileEvent, order = new synced_1.SingleProc()) {
         this.onFileEvent = onFileEvent;

package/build/lib-common/dataset-sync/per-device-json-array-logs.js

@@ -21,7 +21,6 @@ exports.startDatasetSync = startDatasetSync;
 const synced_1 = require("../processes/synced");
 const buffer_utils_1 = require("../buffer-utils");
 const rng_def_1 = require("../rng-def");
-const sink_utils_1 = require("../obj-streaming/sink-utils");
 const DEVICE_ID_FILE = 'device-id';
 const DEV_LOGS_PROCESSING_FILE = 'dev-logs-processing';
 const DEV_ID_LEN = 24;
@@ -122,11 +121,11 @@ async function makeRecentChangesLogs(logsFS, localLogsFS, areOpsEqual, logError)
             return;
         }
         try {
-            const content = (await logsFS.readBytes(logFile));
+            const content = (await logsFS.readTxtFile(logFile));
             if (!content) {
                 return;
             }
-            const appendedEvents = deserializeLogs(buffer_utils_1.utf8.open(content));
+            const appendedEvents = deserializeLogs(content);
             processFromLogFile(devId, appendedEvents, sink);
         }
         catch (err) {
@@ -211,28 +210,37 @@ async function makeRecentChangesLogs(logsFS, localLogsFS, areOpsEqual, logError)
     async function saveAndUploadIfNeeded() {
         if (needToSave && (logs.length > numOfEntriesOnLastSave)) {
             needToSave = false;
-            if (numOfEntriesOnLastSave > 0) {
-                const logsToAppend = logs.slice(numOfEntriesOnLastSave);
-                const logsTxt = serializeLogs(logsToAppend);
-                const sink = await thisDevLogsFile.getByteSink(false);
-                try {
-                    await (0, sink_utils_1.appendFiniteSink)(sink, buffer_utils_1.utf8.pack(','), false);
-                    await (0, sink_utils_1.appendFiniteSink)(sink, buffer_utils_1.utf8.pack(logsTxt), true);
-                }
-                catch (err) {
-                    await sink.done(err);
-                }
-                numOfEntriesOnLastSave += logsToAppend.length;
-            }
-            else {
-                const logsTxt = serializeLogs(logs);
-                const numOfLogs = logs.length;
-                await thisDevLogsFile.writeTxt(logsTxt)
-                    .catch(_exc => {
-                    needToSave = true;
-                });
-                numOfEntriesOnLastSave += numOfLogs;
-            }
+            // XXX do more efficient appending
+            //   sink.slice is not doing efficient appending job, and when versions go into 1000's it blows things up.
+            //   When appending can be done properly, we can switch to a more efficient
+            // 
+            // if (numOfEntriesOnLastSave > 0) {
+            // 	const logsToAppend = logs.slice(numOfEntriesOnLastSave);
+            // 	const logsTxt = serializeLogs(logsToAppend);
+            // 	const sink = await thisDevLogsFile.getByteSink(false);
+            // 	try {
+            // 		await appendFiniteSink(sink, utf8.pack(','), false);
+            // 		await appendFiniteSink(sink, utf8.pack(logsTxt), true);
+            // 	} catch (err) {
+            // 		await sink.done(err);
+            // 	}
+            // 	numOfEntriesOnLastSave += logsToAppend.length;
+            // } else {
+            // 	const logsTxt = serializeLogs(logs);
+            // 	const numOfLogs = logs.length
+            // 	await thisDevLogsFile.writeTxt(logsTxt)
+            // 	.catch(_exc => {
+            // 		needToSave = true;
+            // 	});
+            // 	numOfEntriesOnLastSave = numOfLogs;
+            // }
+            const logsTxt = serializeLogs(logs);
+            const numOfLogs = logs.length;
+            await thisDevLogsFile.writeTxt(logsTxt)
+                .catch(_exc => {
+                needToSave = true;
+            });
+            numOfEntriesOnLastSave = numOfLogs;
             needToUpload = true;
         }
         if (needToUpload) {
@@ -298,7 +306,13 @@ async function makeRecentChangesLogs(logsFS, localLogsFS, areOpsEqual, logError)
             await logsFS.v.sync.upload('');
         }
         else if (state === 'unsynced') {
-            await logsFS.v.sync.upload('');
+            await logsFS.v.sync.upload('')
+                .catch(async (exc) => {
+                if (exc.childNeverUploaded) {
+                    await localLogsFS.deleteFile(exc.childName);
+                    return syncLogsFS();
+                }
+            });
         }
     }
     return {
@@ -408,10 +422,11 @@ function startDatasetSync(periodicCheckAndUploadOfData, millisBeforeNextRun, log
     }
     let interval = undefined;
     function resetSyncInterval() {
+        var _a, _b;
         if (interval !== undefined) {
             clearInterval(interval);
         }
-        interval = setInterval(datasetCheckAndSyncAction, millisBeforeNextRun()).unref();
+        interval = (_b = (_a = setInterval(datasetCheckAndSyncAction, millisBeforeNextRun())).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
     }
     resetSyncInterval();
     // XXX we should watch for reconnect events and run similar to start checks of possibly missed ops

package/build/lib-common/dataset-sync/single-file.d.ts

@@ -1,9 +1,11 @@
 import { SingleProc } from "../processes/synced";
 type WritableFS = web3n.files.WritableFS;
 type WritableFile = web3n.files.WritableFile;
-export declare function initSyncedFile(syncedFS: WritableFS, fName: string, initNewFile: (newFile: WritableFile) => Promise<void>): Promise<WritableFile>;
-export declare function watchAndApplyChangesFromOtherDevices(file: WritableFile, onChangeFromOtherDevices: (changeProc: SingleProc, file: WritableFile) => Promise<void>, onConflictingChangeFromOtherDevices: (changeProc: SingleProc, file: WritableFile) => Promise<void>): {
+export declare function initSyncedFile(syncedFS: WritableFS, fName: string, initNewFile: (newFile: WritableFile) => Promise<void>): Promise<{
+    file: WritableFile;
     changeProc: SingleProc;
+}>;
+export declare function watchAndApplyChangesFromOtherDevices(file: WritableFile, changeProc: SingleProc, onChangeFromOtherDevices: (fileVersion: number, changeProc: SingleProc, file: WritableFile) => Promise<void>, onConflictingChangeFromOtherDevices: (changeProc: SingleProc, file: WritableFile) => Promise<void>): {
     stopFileWatching: () => void;
     triggerUpload: () => void;
 };

package/build/lib-common/dataset-sync/single-file.js

@@ -19,59 +19,55 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.initSyncedFile = initSyncedFile;
 exports.watchAndApplyChangesFromOtherDevices = watchAndApplyChangesFromOtherDevices;
 const synced_1 = require("../processes/synced");
+const utils_1 = require("./utils");
 async function initSyncedFile(syncedFS, fName, initNewFile) {
+    const changeProc = new synced_1.SingleProc();
     const file = await syncedFS.writableFile(fName);
     if (file.isNew) {
         await initNewFile(file);
-        await file.v.sync.upload();
-        await syncedFS.v.sync.upload('.');
     }
-    // XXX add initial sync no-connection handling
-    return file;
+    await (0, utils_1.runRetryingButNotBlockingOnDisconnect)(async function ensureFileIsInFSTree() {
+        const { existsInSyncedParent, synced } = await file.v.sync.status(false);
+        if (!synced) {
+            await file.v.sync.upload();
+        }
+        if (!existsInSyncedParent) {
+            await syncedFS.v.sync.upload('.');
+        }
+    }, () => file.v.sync.whenConnected(), changeProc);
+    return { file, changeProc };
 }
-function watchAndApplyChangesFromOtherDevices(file, onChangeFromOtherDevices, onConflictingChangeFromOtherDevices) {
-    const changeProc = new synced_1.SingleProc();
+function watchAndApplyChangesFromOtherDevices(file, changeProc, onChangeFromOtherDevices, onConflictingChangeFromOtherDevices) {
+    function whenConnected() {
+        return file.v.sync.whenConnected();
+    }
     const stopFileWatching = file.watch({
         next: ev => {
             if (ev.type === 'remote-change') {
-                changeProc.startOrChain(async () => {
-                    await file.v.sync.adoptRemote({ remoteVersion: ev.newRemoteVersion })
-                        .catch((exc) => {
-                        if (exc.type === 'connect') {
-                            // XXX need to have watcher for connection to continue processing
-                        }
-                    });
-                });
+                (0, utils_1.runRetryingButNotBlockingOnDisconnect)(() => checkStatusAndSyncFile(true), whenConnected, changeProc);
             }
             else if ((ev.type === 'file-change') && (ev.src === 'sync')) {
-                onChangeFromOtherDevices(changeProc, file);
+                onChangeFromOtherDevices(ev.newVersion, changeProc, file);
             }
         }
     });
     function triggerUpload() {
-        changeProc.startOrChain(async () => file.v.sync.upload())
-            .catch((exc) => {
-            if (exc.type === 'connect') {
-                // XXX need to have watcher for connection to complete upload
-                //     Should this whole try-to-connect method be generic to reuse it?
-            }
-        });
+        (0, utils_1.runRetryingButNotBlockingOnDisconnect)(() => file.v.sync.upload(), whenConnected, changeProc);
     }
-    file.v.sync.status()
-        .then(async ({ state }) => {
+    async function checkStatusAndSyncFile(skipServerCheck) {
+        const { state } = await file.v.sync.status(skipServerCheck);
         if (state === 'behind') {
-            await changeProc.startOrChain(() => file.v.sync.adoptRemote());
+            await file.v.sync.adoptRemote();
         }
         else if (state === 'conflicting') {
-            await onConflictingChangeFromOtherDevices(changeProc, file);
+            onConflictingChangeFromOtherDevices(changeProc, file);
         }
         else if (state === 'unsynced') {
             triggerUpload();
         }
-    })
-        .catch(exc => {
-        // XXX need to have watcher for connection to continue processing
-    });
-    return { changeProc, stopFileWatching, triggerUpload };
+    }
+    // starting initial check with changeProc, without waiting here
+    (0, utils_1.runRetryingButNotBlockingOnDisconnect)(checkStatusAndSyncFile, whenConnected);
+    return { stopFileWatching, triggerUpload };
 }
 Object.freeze(exports);

package/build/lib-common/dataset-sync/utils.d.ts

@@ -0,0 +1,16 @@
+import { SingleProc } from "../processes/synced";
+/**
+ * Returned promise resolves when action runs first time, successfully or not.
+ * On disconnect action will be triggered again but outside of return promise.
+ * @param action
+ * @param whenConnected
+ * @param changeProc when given, is used to chain action invocation
+ */
+export declare function runRetryingButNotBlockingOnDisconnect(action: () => Promise<any>, whenConnected: () => Promise<void>, changeProc?: SingleProc): Promise<void>;
+/**
+ * Returned promise resolves when action ultimately runs or fails, after all possible disconnects.
+ * @param action
+ * @param whenConnected
+ * @param changeProc when given, is used to chain action invocation
+ */
+export declare function runRetryingOnDisconnectTillDone<T>(action: () => Promise<T>, whenConnected: () => Promise<void>, changeProc?: SingleProc): Promise<T>;

package/build/lib-common/dataset-sync/utils.js

@@ -0,0 +1,72 @@
+"use strict";
+/*
+ Copyright (C) 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
+ 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.runRetryingButNotBlockingOnDisconnect = runRetryingButNotBlockingOnDisconnect;
+exports.runRetryingOnDisconnectTillDone = runRetryingOnDisconnectTillDone;
+/**
+ * Returned promise resolves when action runs first time, successfully or not.
+ * On disconnect action will be triggered again but outside of return promise.
+ * @param action
+ * @param whenConnected
+ * @param changeProc when given, is used to chain action invocation
+ */
+async function runRetryingButNotBlockingOnDisconnect(action, whenConnected, changeProc) {
+    if (changeProc) {
+        await changeProc.startOrChain(action).catch((exc) => {
+            if (exc.type === 'connect') {
+                whenConnected().then(() => runRetryingButNotBlockingOnDisconnect(() => changeProc.startOrChain(action), whenConnected, changeProc));
+            }
+        });
+    }
+    else {
+        await action().catch((exc) => {
+            if (exc.type === 'connect') {
+                whenConnected().then(() => runRetryingButNotBlockingOnDisconnect(action, whenConnected));
+            }
+        });
+    }
+}
+/**
+ * Returned promise resolves when action ultimately runs or fails, after all possible disconnects.
+ * @param action
+ * @param whenConnected
+ * @param changeProc when given, is used to chain action invocation
+ */
+async function runRetryingOnDisconnectTillDone(action, whenConnected, changeProc) {
+    if (changeProc) {
+        return await changeProc.startOrChain(action).catch((exc) => {
+            if (exc.type === 'connect') {
+                return whenConnected().then(() => runRetryingOnDisconnectTillDone(() => changeProc.startOrChain(action), whenConnected, changeProc));
+            }
+            else {
+                throw exc;
+            }
+        });
+    }
+    else {
+        return await action().catch((exc) => {
+            if (exc.type === 'connect') {
+                return whenConnected().then(() => runRetryingOnDisconnectTillDone(action, whenConnected));
+            }
+            else {
+                throw exc;
+            }
+        });
+    }
+}
+Object.freeze(exports);

package/build/lib-common-on-node/device-fs-places.d.ts

@@ -0,0 +1,3 @@
+type FSItem = web3n.files.FSItem;
+export declare function sysFilesOnDevice(): Promise<FSItem>;
+export {};

package/build/lib-common-on-node/device-fs-places.js

@@ -0,0 +1,39 @@
+"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.sysFilesOnDevice = sysFilesOnDevice;
+const fs_collection_1 = require("../lib-client/fs-utils/fs-collection");
+const lib_index_1 = require("../lib-index");
+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)
+        });
+    }
+    else {
+        await c.set('', {
+            isFolder: true,
+            item: await lib_index_1.DeviceFS.makeWritable('/')
+        });
+    }
+    return { isCollection: true, item: c };
+}
+Object.freeze(exports);

package/build/tests/computer.3nweb.core/keyrings.js

@@ -58,9 +58,9 @@ describe('ASMail keyring', () => {
         // run different peers' keyrings from different folders
         const peer1 = `keyring tester 1 @rock.cafe`;
         const peer2 = `keyring tester 2 @rock.cafe`;
-        const p1FS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(dev1FS, peer1);
+        const p1FS = await (0, fs_sync_utils_1.getOrMakeDirOnInit)(dev1FS, peer1);
         const p1LocalFS = await dev1LocalFS.writableSubRoot(`local fs for ${peer1}`);
-        const p2FS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(dev1FS, peer2);
+        const p2FS = await (0, fs_sync_utils_1.getOrMakeDirOnInit)(dev1FS, peer2);
         const p2LocalFS = await dev1LocalFS.writableSubRoot(`local fs for ${peer2}`);
         const peerKeys1 = await (0, peer_keys_1.makePeersKeyring)(p1FS, p1LocalFS, random_node_1.bytes, logger);
         const peerKeys2 = await (0, peer_keys_1.makePeersKeyring)(p2FS, p2LocalFS, random_node_1.bytes, logger);

package/build/tests/libs-for-tests/core-runner.js

@@ -31,6 +31,7 @@ const dns_1 = require("dns");
 const napi_nacl_1 = require("napi-nacl");
 const request_from_node_1 = require("../../lib-common-on-node/request-from-node");
 const websocket_from_node_1 = require("../../lib-common-on-node/websocket-from-node");
+const device_fs_places_1 = require("../../lib-common-on-node/device-fs-places");
 exports.testApp = {
     appDomain: 'test.3nweb.app',
     capsRequested: {
@@ -91,7 +92,7 @@ class CoreRunner {
                     resolve(texts);
                 }
             }))
-        }), napi_nacl_1.makeNativeCryptor, random_node_1.bytes);
+        }), device_fs_places_1.sysFilesOnDevice, napi_nacl_1.makeNativeCryptor, random_node_1.bytes);
     }
     async close() {
         if (this.appCaps) {

package/package.json

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