core-3nweb-client-lib 0.49.7 → 0.50.0

package/build/lib-client/asmail/recipient.js

@@ -18,6 +18,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MailRecipient = void 0;
 exports.makeMsgNotFoundException = makeMsgNotFoundException;
+exports.makeFailToDecryptMsgException = makeFailToDecryptMsgException;
 exports.makeObjNotFoundException = makeObjNotFoundException;
 exports.makeMsgIsBrokenException = makeMsgIsBrokenException;
 const request_utils_1 = require("../request-utils");
@@ -37,6 +38,16 @@ function makeMsgNotFoundException(msgId) {
     };
     return exc;
 }
+function makeFailToDecryptMsgException(msgId) {
+    const exc = {
+        runtimeException: true,
+        type: 'inbox',
+        msgId,
+        failToDecrypt: true,
+        stack: (0, runtime_1.getStackHere)(1)
+    };
+    return exc;
+}
 function makeObjNotFoundException(msgId, objId) {
     const exc = {
         runtimeException: true,

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/folder-node.js

@@ -36,7 +36,6 @@ const folder_node_serialization_1 = require("./folder-node-serialization");
 const attrs_1 = require("./attrs");
 const node_persistence_1 = require("./node-persistence");
 const assert_1 = require("../../lib-common/assert");
-const for_arrays_1 = require("./util/for-arrays");
 function jsonToInfoAndAttrs(json) {
     const folderInfo = {
         nodes: (0, json_utils_1.copy)(json.nodes)
@@ -870,7 +869,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
     async uploadRemovalOf(removedNodes) {
         const rmObjs = [];
         for (const node of removedNodes) {
-            (0, for_arrays_1.appendArray)(rmObjs, await this.listRemovedInTreeToUploadRm(node));
+            appendArray(rmObjs, await this.listRemovedInTreeToUploadRm(node));
         }
         await this.uploadRemovalOfObjs(rmObjs);
     }
@@ -896,7 +895,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             const src = await storage.getObjSrc(node.objId, versionBeforeRm, true);
             const folderContent = await FolderPersistance.readFolderContent(node.objId, node.key, src, storage.cryptor, storage.random);
             for (const child of Object.values(folderContent.nodes)) {
-                (0, for_arrays_1.appendArray)(objs, await this.listRemovedInTreeToUploadRm(child));
+                appendArray(objs, await this.listRemovedInTreeToUploadRm(child));
             }
             return objs;
         }
@@ -1136,6 +1135,17 @@ class FolderNode extends node_in_fs_1.NodeInFS {
 exports.FolderNode = FolderNode;
 Object.freeze(FolderNode.prototype);
 Object.freeze(FolderNode);
+function appendArray(arr, elems) {
+    if (elems !== undefined) {
+        if (Array.isArray(elems)) {
+            arr.push(...elems);
+        }
+        else {
+            arr.push(elems);
+        }
+    }
+    return arr;
+}
 const EMPTY_ARR = new Uint8Array(0);
 function noop() { }
 function checkFolderInfo(folderJson) {

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 {
@@ -403,15 +417,16 @@ function startDatasetSync(periodicCheckAndUploadOfData, millisBeforeNextRun, log
     // We pass this single process point out to wrap fn's with it, in an attempt to explicitly keeping it at the
     // boundary of incoming operations, either from fn calls, or from handling changes passed via fs events.
     const changeProc = new synced_1.SingleProc();
-    function dbSyncCheckAndAction() {
+    function datasetCheckAndSyncAction() {
         changeProc.startOrChain(periodicCheckAndUploadOfData);
     }
     let interval = undefined;
     function resetSyncInterval() {
+        var _a, _b;
         if (interval !== undefined) {
             clearInterval(interval);
         }
-        interval = setInterval(dbSyncCheckAndAction, 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

@@ -0,0 +1,12 @@
+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<{
+    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;
+};
+export {};

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

@@ -0,0 +1,73 @@
+"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.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 (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, changeProc, onChangeFromOtherDevices, onConflictingChangeFromOtherDevices) {
+    function whenConnected() {
+        return file.v.sync.whenConnected();
+    }
+    const stopFileWatching = file.watch({
+        next: ev => {
+            if (ev.type === 'remote-change') {
+                (0, utils_1.runRetryingButNotBlockingOnDisconnect)(() => checkStatusAndSyncFile(true), whenConnected, changeProc);
+            }
+            else if ((ev.type === 'file-change') && (ev.src === 'sync')) {
+                onChangeFromOtherDevices(ev.newVersion, changeProc, file);
+            }
+        }
+    });
+    function triggerUpload() {
+        (0, utils_1.runRetryingButNotBlockingOnDisconnect)(() => file.v.sync.upload(), whenConnected, changeProc);
+    }
+    async function checkStatusAndSyncFile(skipServerCheck) {
+        const { state } = await file.v.sync.status(skipServerCheck);
+        if (state === 'behind') {
+            await file.v.sync.adoptRemote();
+        }
+        else if (state === 'conflicting') {
+            onConflictingChangeFromOtherDevices(changeProc, file);
+        }
+        else if (state === 'unsynced') {
+            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-client/xsp-fs/util/for-arrays.js → lib-common-on-node/device-fs-places.js}

@@ -1,31 +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.appendArray = appendArray;
-function appendArray(arr, elems) {
-    if (elems !== undefined) {
-        if (Array.isArray(elems)) {
-            arr.push(...elems);
-        }
-        else {
-            arr.push(elems);
-        }
+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)
+        });
     }
-    return arr;
+    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.7",
+  "version": "0.50.0",
   "description": "3NWeb client core library, embeddable into different environments",
   "main": "build/lib-index.js",
   "types": "build/lib-index.d.ts",

package/build/lib-client/xsp-fs/util/for-arrays.d.ts

@@ -1 +0,0 @@
-export declare function appendArray<T>(arr: T[], elems: T[] | T | undefined): T[];