core-3nweb-client-lib 0.49.5 → 0.49.7

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

@@ -0,0 +1,208 @@
+"use strict";
+/*
+ Copyright (C) 2015 - 2018, 2022, 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.makePeersKeyring = makePeersKeyring;
+const common_1 = require("../common");
+const ecma_nacl_1 = require("ecma-nacl");
+const buffer_utils_1 = require("../../../lib-common/buffer-utils");
+const fs_sync_utils_1 = require("../../../lib-client/fs-utils/fs-sync-utils");
+const per_device_json_array_logs_1 = require("../../../lib-common/dataset-sync/per-device-json-array-logs");
+const synced_1 = require("../../../lib-common/processes/synced");
+const logs_1 = require("./dataset/v2/logs");
+const peer_keys_db_1 = require("./dataset/v2/peer-keys-db");
+const canonical_address_1 = require("../../../lib-common/canonical-address");
+const LOGS_DIR = 'peer-keys-logs';
+const PEER_KEYS_FOLDER = 'peer-keys-db';
+const NUM_OF_LOGS_TO_START_CUT = 200;
+async function makePeersKeyring(keyringFS, localFS, random, logger) {
+    const logsFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(keyringFS, LOGS_DIR);
+    const logsLocalFS = await localFS.writableSubRoot(LOGS_DIR);
+    const peerKeysFS = await (0, fs_sync_utils_1.getOrMakeSyncedDirOnInit)(keyringFS, PEER_KEYS_FOLDER);
+    // XXX log and saving reduction(!):
+    //  - we don't need to log message counts
+    //  - we don't have to immediately save changes in message counts
+    //  - we want to save and log crypto material, more so, we generate and log new crypto first, then send message
+    //  - logging and saving of marking pair as in use also doesn't have to be immediate (should it be logged?)
+    const logs = await (0, logs_1.makePeerKeysChangeLogs)(logsFS, logsLocalFS, logger.logError);
+    const keysDB = await (0, peer_keys_db_1.makePeerKeysDB)(peerKeysFS, random);
+    async function suggestPairForPeerIntroKey(peerAddr, peerIntroPKey) {
+        const peerCAddr = (0, canonical_address_1.toCanonicalAddress)(peerAddr);
+        const alreadySuggested = keysDB.getPairSuggestedToPeer(peerCAddr);
+        if (alreadySuggested && (alreadySuggested.senderKid === peerIntroPKey.kid)) {
+            return alreadySuggested;
+        }
+        else {
+            if (!keysDB.getPeerAddressForCanonical(peerCAddr)) {
+                keysDB.addPeer(peerAddr);
+            }
+            const { nextCrypto, entryToLog } = await keysDB.generateSuggestedPairOnPeerIntroKey(peerCAddr, peerIntroPKey);
+            await keysDB.saveIfNeeded();
+            await logs.recordSuggestingCryptoToPeer(entryToLog, peerAddr);
+            return nextCrypto;
+        }
+    }
+    function needIntroKeyFor(peerAddr) {
+        return !keysDB.getSendingPair((0, canonical_address_1.toCanonicalAddress)(peerAddr));
+    }
+    async function getSendingCryptoWithinEstablishedPair(peerCAddr) {
+        const pair = keysDB.getSendingPair(peerCAddr);
+        if (!pair) {
+            throw new Error(`No sending pair for peer ${peerCAddr}`);
+        }
+        const { pids, peerKId, pairAlg, senderKId, senderPKey, msgMasterKey, sentMsgsCount } = pair;
+        const msgCount = sentMsgsCount + 1;
+        keysDB.updateSentMsgCountInSendingPair(peerCAddr, msgCount);
+        let nextMsgCrypto = keysDB.getPairSuggestedToPeer(peerCAddr);
+        if (!nextMsgCrypto) {
+            const generated = await keysDB.generateRegularSuggestedPairIfNeeded(peerCAddr);
+            if (generated) {
+                nextMsgCrypto = generated.nextCrypto;
+                await keysDB.saveIfNeeded();
+                await logs.recordSuggestingCryptoToPeer(generated.entryToLog, peerCAddr);
+            }
+        }
+        return {
+            currentPair: {
+                pid: selectPid(pids),
+                recipientKid: peerKId,
+                senderPKey: {
+                    alg: pairAlg,
+                    kid: senderKId,
+                    k: senderPKey,
+                    use: common_1.KEY_USE.PUBLIC
+                }
+            },
+            msgMasterKey,
+            msgCount,
+            nextMsgCrypto
+        };
+    }
+    async function markPairAsInUse(peerCAddr, peerKId, recipientKId) {
+        const pairFoundAndMarked = keysDB.markPairAsInUse(peerCAddr, peerKId, recipientKId);
+        if (pairFoundAndMarked) {
+            await keysDB.saveIfNeeded();
+            await logs.recordPeerStartedUsingPair(peerCAddr, peerKId, recipientKId);
+        }
+    }
+    async function absorbNextPairSuggestedByPeer(peerAddr, pair, introKey) {
+        const peerCAddr = (0, canonical_address_1.toCanonicalAddress)(peerAddr);
+        const msgMasterKeyAlg = ecma_nacl_1.box.JWK_ALG_NAME;
+        const peerPKey = buffer_utils_1.base64.open(pair.recipientPKey.k);
+        if (keysDB.getPeerAddressForCanonical(peerCAddr)) {
+            const prevPair = keysDB.getSendingPair(peerCAddr);
+            if (introKey) {
+                if (prevPair
+                    && ((introKey.pkey.kid === pair.senderKid) && (prevPair.peerKId === pair.recipientPKey.kid))) {
+                    // ignoring duplicate
+                    return;
+                }
+                const senderSKey = buffer_utils_1.base64.open(introKey.skey.k);
+                const msgMasterKey = ecma_nacl_1.box.calc_dhshared_key(peerPKey, senderSKey);
+                keysDB.updateSendingPairFromSuggested(peerCAddr, pair, {
+                    msgMasterKey, msgMasterKeyAlg, peerPKey, senderSKey,
+                    senderKId: introKey.pkey.kid,
+                    senderPKey: introKey.pkey.k
+                });
+            }
+            else {
+                if (prevPair
+                    && ((prevPair.senderKId === pair.senderKid) && (prevPair.peerKId === pair.recipientPKey.kid))) {
+                    // ignoring duplicate
+                    return;
+                }
+                const foundPair = keysDB.findKeyToMatchSuggestedForSendingPair(peerCAddr, pair.senderKid);
+                if (!foundPair) {
+                    // ignore bad
+                    return;
+                }
+                const { pkey: senderPKey, skey: senderSKey, pairAlg } = foundPair;
+                const msgMasterKey = ecma_nacl_1.box.calc_dhshared_key(peerPKey, senderSKey);
+                if (prevPair) {
+                    keysDB.updateSendingPairFromSuggested(peerCAddr, pair, {
+                        msgMasterKey, msgMasterKeyAlg, peerPKey, senderSKey, senderPKey,
+                        senderKId: pair.senderKid
+                    });
+                }
+                else {
+                    keysDB.addSendingPairFromSuggested(peerCAddr, pair, {
+                        msgMasterKey, msgMasterKeyAlg, senderSKey, peerPKey, pairAlg, senderPKey,
+                        senderKId: pair.senderKid
+                    });
+                }
+            }
+        }
+        else {
+            if (!introKey) {
+                throw new Error(`Peer ${peerAddr} is not known, while used introductory key is not given`);
+            }
+            keysDB.addPeer(peerAddr);
+            const senderSKey = buffer_utils_1.base64.open(introKey.skey.k);
+            const msgMasterKey = ecma_nacl_1.box.calc_dhshared_key(peerPKey, senderSKey);
+            keysDB.addSendingPairFromSuggested(peerCAddr, pair, {
+                msgMasterKey, msgMasterKeyAlg, senderSKey, peerPKey,
+                pairAlg: introKey.pkey.alg,
+                senderKId: introKey.pkey.kid,
+                senderPKey: introKey.pkey.k
+            });
+        }
+        const entryToLog = keysDB.getSendingPair(peerCAddr);
+        await keysDB.saveIfNeeded();
+        await logs.recordGettingCryptoFromPeer(entryToLog, peerAddr);
+    }
+    async function periodicCheckAndUploadOfData() {
+        // XXX disable uploading for a moment by commenting out
+        // if (logs.numOfLogs() >= NUM_OF_LOGS_TO_START_CUT) {
+        // 	const syncedIndexDbVersion = await keysDB.saveAndSync();
+        // 	await logs.cutLogOnDatasetSyncAndUpload(syncedIndexDbVersion);
+        // }
+    }
+    function millisBeforeNextRun() {
+        return 30 * 60 * 1000 + Math.floor(10 * 60 * 1000 * Math.random());
+    }
+    const { stopSyncing, changeProc } = (0, per_device_json_array_logs_1.startDatasetSync)(periodicCheckAndUploadOfData, millisBeforeNextRun, {
+        watchAndApplyOpsFromOtherDevices: logs.watchAndApplyOpsFromOtherDevices
+    }, {
+        absorbOpsFromOtherDevices: keysDB.absorbOpsFromOtherDevices,
+        watchAndApplyOpsFromOtherDevices: keysDB.watchAndApplyOpsFromOtherDevices
+    });
+    // XXX
+    //  - check if indexed latest is too old, chopping to the latest shard
+    async function close() {
+        stopSyncing();
+    }
+    return {
+        getPeerAddressForCanonical: keysDB.getPeerAddressForCanonical,
+        needIntroKeyFor,
+        suggestPairForPeerIntroKey: (0, synced_1.makeSyncedFunc)(changeProc, undefined, suggestPairForPeerIntroKey),
+        getSendingCryptoWithinEstablishedPair: (0, synced_1.makeSyncedFunc)(changeProc, undefined, getSendingCryptoWithinEstablishedPair),
+        absorbNextPairSuggestedByPeer: (0, synced_1.makeSyncedFunc)(changeProc, undefined, absorbNextPairSuggestedByPeer),
+        findEstablishedReceptionPairs: keysDB.findReceptionPairsForPId,
+        markPairAsInUse: (0, synced_1.makeSyncedFunc)(changeProc, undefined, markPairAsInUse),
+        updateReceivedMsgCountIn: keysDB.updateReceivedMsgCountIn,
+        close,
+        getPeerKeysInfo: keysDB.getPeerKeysInfo
+    };
+}
+function selectPid(pids) {
+    if (pids.length < 1) {
+        throw new Error("There are no pair ids in array.");
+    }
+    const i = Math.round((pids.length - 1) * Math.random());
+    return pids[i];
+}
+Object.freeze(exports);

package/build/core/storage/synced/obj-files.js

@@ -231,7 +231,14 @@ class SyncedObj {
         const status = await obj_status_1.ObjStatus.makeForDownloadedVersion(objFolder, objId, version, version, logError);
         const obj = new SyncedObj(objId, objFolder, status, downloader, scheduleGC);
         const fPath = obj.remoteVerPath(version);
-        const objVer = await obj_on_disk_1.ObjOnDisk.createFileForExistingVersion(obj.objId, version, fPath, obj.downloader, obj.remoteObjSegsGetterFromDisk, parts);
+        const objVer = await obj_on_disk_1.ObjOnDisk.createFileForExistingVersion(obj.objId, version, fPath, obj.downloader, obj.remoteObjSegsGetterFromDisk, parts).catch((exc) => {
+            if (exc.alreadyExists) {
+                return obj_on_disk_1.ObjOnDisk.forExistingFile(obj.objId, version, fPath, obj.downloader, obj.remoteObjSegsGetterFromDisk);
+            }
+            else {
+                throw exc;
+            }
+        });
         obj.remoteVers.set(version, objVer);
         return obj;
     }
@@ -397,7 +404,7 @@ class SyncedObj {
         this.scheduleSelfGC();
     }
     async isRemoteVersionOnDisk(version) {
-        if (!this.status.isAmongRemote(version)) {
+        if (!this.status.isAmongRemoteOrSynced(version)) {
             throw (0, exceptions_1.makeObjVersionNotFoundExc)(this.objId, version);
         }
         const verPath = this.remoteVerPath(version);
@@ -408,7 +415,7 @@ class SyncedObj {
         return (objVer.doesFileNeedDownload() ? 'partial' : 'complete');
     }
     async getNumOfBytesNeedingDownload(version) {
-        if (!this.status.isAmongRemote(version)) {
+        if (!this.status.isAmongRemoteOrSynced(version)) {
             if (this.status.isLocalOnlyVersion(version)) {
                 return 0;
             }

package/build/core/storage/synced/obj-status.d.ts

@@ -147,7 +147,7 @@ export declare class ObjStatus implements SyncedObjStatus, UploadStatusRecorder
     neverUploaded(): boolean;
     versionBeforeUnsyncedRemoval(): number | undefined;
     adoptRemoteVersion(version?: number): Promise<void>;
-    isAmongRemote(version: number): boolean;
+    isAmongRemoteOrSynced(version: number): boolean;
     isLocalOnlyVersion(version: number): boolean;
 }
 export declare function readAndCheckStatus(objFolder: string, objId: ObjId): Promise<ObjStatusInfo>;

package/build/core/storage/synced/obj-status.js

@@ -553,14 +553,20 @@ class ObjStatus {
         this.updateStateIndicator();
         await this.triggerSaveProc();
     }
-    isAmongRemote(version) {
-        var _a;
+    isAmongRemoteOrSynced(version) {
+        var _a, _b;
         if (this.status.remote.current === version) {
             return true;
         }
         if ((_a = this.status.remote.archived) === null || _a === void 0 ? void 0 : _a.includes(version)) {
             return true;
         }
+        if (this.status.remote.baseToDiff[version]) {
+            return true;
+        }
+        if (((_b = this.status.synced) === null || _b === void 0 ? void 0 : _b.version) === version) {
+            return true;
+        }
         return false;
     }
     isLocalOnlyVersion(version) {

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

@@ -1,5 +1,5 @@
 import { IGetMailerIdSigner } from '../../../lib-client/user-with-mid-session';
-import { SyncedStorage as ISyncedStorage, NodesContainer, Storage as IStorage, StorageGetter, ObjId, NodeEvent, SyncedObjStatus, DownloadEventSink } from '../../../lib-client/xsp-fs/common';
+import { SyncedStorage, NodesContainer, Storage as IStorage, StorageGetter, ObjId, NodeEvent, SyncedObjStatus, DownloadEventSink } from '../../../lib-client/xsp-fs/common';
 import { ScryptGenParams } from '../../../lib-client/key-derivation';
 import { LogError } from '../../../lib-client/logging/log-to-file';
 import { AsyncSBoxCryptor, Subscribe, ObjSource } from 'xsp-files';
@@ -12,7 +12,7 @@ type FileEvent = web3n.files.FileEvent;
 type SyncStatus = web3n.files.SyncStatus;
 type OptionsToAdopteRemote = web3n.files.OptionsToAdopteRemote;
 type UploadEvent = web3n.files.UploadEvent;
-export declare class SyncedStore implements ISyncedStorage {
+export declare class SyncedStore implements SyncedStorage {
     private readonly files;
     private readonly remoteStorage;
     private readonly getStorages;
@@ -27,11 +27,11 @@ export declare class SyncedStore implements ISyncedStorage {
     private readonly events;
     private constructor();
     static makeAndStart(path: string, user: string, getSigner: IGetMailerIdSigner, getStorages: StorageGetter, cryptor: AsyncSBoxCryptor, random: AsyncRNG, remoteServiceUrl: () => Promise<string>, net: NetClient, logError: LogError): Promise<{
-        syncedStore: ISyncedStorage;
+        syncedStore: SyncedStorage;
         startObjProcs: () => void;
     }>;
     static makeAndStartWithoutRemote(path: string, user: string, getStorages: StorageGetter, cryptor: AsyncSBoxCryptor, random: AsyncRNG, remoteServiceUrl: () => Promise<string>, net: NetClient, logError: LogError): Promise<{
-        syncedStore: ISyncedStorage;
+        syncedStore: SyncedStorage;
         setupRemoteAndStartObjProcs: (getSigner: IGetMailerIdSigner) => void;
     }>;
     getNodeEvents(): Observable<NodeEvent>;

package/build/core/storage/system-folders/apps-data.d.ts

@@ -9,7 +9,6 @@ export declare class AppDataFolders {
     private syncP;
     private makeSyncedFolder;
     private syncBeforeChange;
-    private uploadAfterCreationOf;
     private startSyncProc;
     stopSync(): void;
 }

package/build/core/storage/system-folders/apps-data.js

@@ -77,7 +77,8 @@ class AppDataFolders {
                 }
             }
             const fs = await this.fs.writableSubRoot(folder, { create: false });
-            await this.uploadAfterCreationOf(folder);
+            await this.fs.v.sync.upload(folder);
+            await this.fs.v.sync.upload('');
             return fs;
         });
     }
@@ -87,11 +88,6 @@ class AppDataFolders {
             await this.fs.v.sync.adoptRemote('');
         }
     }
-    async uploadAfterCreationOf(folder) {
-        // XXX must add work with not-online condition
-        await this.fs.v.sync.upload(folder);
-        await this.fs.v.sync.upload('');
-    }
     startSyncProc() {
         this.syncFolderProc = (new rxjs_1.Observable((obs) => this.fs.watchFolder('', obs)))
             .pipe((0, operators_1.filter)(ev => (ev.type === 'remote-change')), (0, operators_1.mergeMap)(() => this.syncP().startOrChain(() => this.fs.v.sync.adoptRemote('')), 1))

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 getOrMakeAndUploadFolderIn(fs: WritableFS, folder: string): Promise<WritableFS>;
+export declare function getOrMakeSyncedDirOnInit(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

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2022, 2025 3NSoft Inc.
+ Copyright (C) 2022, 2025 - 2026 3NSoft Inc.
 
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -17,11 +17,12 @@
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRemoteFolderChanges = getRemoteFolderChanges;
-exports.getOrMakeAndUploadFolderIn = getOrMakeAndUploadFolderIn;
+exports.getOrMakeSyncedDirOnInit = getOrMakeSyncedDirOnInit;
 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') {
@@ -35,23 +36,79 @@ async function getRemoteFolderChanges(fs) {
         });
     }
 }
-async function getOrMakeAndUploadFolderIn(fs, folder) {
+async function getOrMakeSyncedDirOnInit(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);
+    if (await syncedFS.checkFolderPresence(dir)) {
+        return await syncedFS.writableSubRoot(dir, { create: false });
+    }
     try {
-        const childFolder = await fs.writableSubRoot(folder, { create: false });
-        return childFolder;
+        const fs = await syncedFS.writableSubRoot(dir);
+        await syncedFS.v.sync.upload(dir);
+        await syncedFS.v.sync.upload('.');
+        return fs;
     }
-    catch (exc) {
-        if ((exc.type === 'file')
-            && exc.notFound) {
-            const childFolder = await fs.writableSubRoot(folder);
-            await fs.v.sync.upload(folder);
-            return childFolder;
+    catch (err) {
+        await syncedFS.v.sync.adoptRemote('.').catch(noop);
+        throw err;
+    }
+}
+function noop() { }
+async function ensureIsInSyncedState(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') {
+        await syncedFS.v.sync.adoptRemote('.');
+        return;
+    }
+    else if (state === 'unsynced') {
+        await syncedFS.v.sync.upload('.').catch(async (exc) => {
+            if (exc.type !== 'fs-sync') {
+                throw exc;
+            }
+            else if (exc.childNeverUploaded) {
+                await recursivelyUploadNewTreeItems(syncedFS, '.');
+            }
+        });
+        return;
+    }
+    (0, assert_1.assert)(state !== 'conflicting');
+}
+async function recursivelyUploadNewTreeItems(fs, path) {
+    for (const item of await fs.listFolder(path)) {
+        const { remote, synced } = await fs.v.sync.status(`${path}/${item.name}`);
+        if (remote || synced) {
+            continue;
         }
-        else {
-            throw exc;
+        if (item.isFolder) {
+            await recursivelyUploadNewTreeItems(fs, `${path}/${item.name}`);
         }
+        await fs.v.sync.upload(`${path}/${item.name}`);
     }
+    await fs.v.sync.upload(path);
 }
+// export async function getOrMakeAndUploadFolderIn(fs: WritableFS, folder: string): Promise<WritableFS> {
+// 	try {
+// 		const childFolder = await fs.writableSubRoot(folder, { create: false });
+// 		return childFolder;
+// 	} catch (exc) {
+// 		if (((exc as FileException).type === 'file') && (exc as FileException).notFound) {
+// 			const childFolder = await fs.writableSubRoot(folder);
+// 			await fs.v!.sync!.upload(folder);
+// 			await fs.v!.sync!.upload('.');
+// 			return childFolder;
+// 		} else {
+// 			throw exc;
+// 		}
+// 	}
+// }
 // XXX conflicts are app(let)-specific, hence, we can't have this "general" functionality.
 async function uploadFolderChangesIfAny(fs) {
     try {

package/build/lib-client/xsp-fs/fs.js

@@ -530,7 +530,9 @@ class V {
     async getOrCreateFile(path, flags) {
         const { fileName, folderPath } = split(path);
         const { create, exclusive } = flags;
-        const folder = await this.getRootIfNotClosed(path).getFolderInThisSubTree(folderPath, create).catch(setExcPath(path));
+        const folder = await this.getRootIfNotClosed(path)
+            .getFolderInThisSubTree(folderPath, create)
+            .catch(setExcPath(path));
         const nullOnMissing = create;
         let file = await folder.getFile(fileName, nullOnMissing)
             .catch(setExcPath(path));

package/build/lib-client/xsp-fs/node-in-fs.d.ts

@@ -81,6 +81,7 @@ export declare abstract class NodeInFS<P extends NodePersistance> implements Nod
     get event$(): Observable<FSEvent | RemoteEvent>;
     protected syncedStorage(): SyncedStorage;
     syncStatus(): Promise<SyncStatus>;
+    private isThisPresentInSyncedParent;
     updateStatusInfo(): Promise<SyncStatus>;
     isSyncedVersionOnDisk(version: number): Promise<'partial' | 'complete' | 'none'>;
     startDownload(version: number): Promise<{

package/build/lib-client/xsp-fs/node-in-fs.js

@@ -344,17 +344,22 @@ class NodeInFS {
     async syncStatus() {
         const storage = this.syncedStorage();
         const status = (await storage.status(this.objId)).syncStatus();
+        status.existsInSyncedParent = await this.isThisPresentInSyncedParent();
+        return status;
+    }
+    async isThisPresentInSyncedParent() {
         if (this.parentId) {
+            const storage = this.syncedStorage();
             const parent = storage.nodes.get(this.parentId);
             if (parent) {
-                status.existsInSyncedParent = await parent.childExistsInSyncedVersion(this.objId);
+                return await parent.childExistsInSyncedVersion(this.objId);
             }
         }
-        return status;
     }
     async updateStatusInfo() {
         const storage = this.syncedStorage();
         const status = await storage.updateStatusInfo(this.objId);
+        status.existsInSyncedParent = await this.isThisPresentInSyncedParent();
         return status;
     }
     isSyncedVersionOnDisk(version) {

package/build/lib-client/xsp-fs/node-persistence.js

@@ -137,9 +137,7 @@ class NodePersistance {
         };
     }
     async writableSink(newVersion, attrs, xattrs, base) {
-        const segWriter = await (base ?
-            this.segWriterWithBase(newVersion, base) :
-            this.segWriter(newVersion));
+        const segWriter = await (base ? this.segWriterWithBase(newVersion, base) : this.segWriter(newVersion));
         const { sink, sub } = (0, xsp_files_1.makeEncryptingByteSink)(segWriter);
         const defSink = (0, deferred_1.defer)();
         return {

package/build/lib-client/xsp-fs/xsp-payload-v2.js

@@ -605,8 +605,7 @@ class WritablePayloadV2 {
         if (this.sectionsInSink.length === 0) {
             return;
         }
-        let fstNoCutSectionInd = this.sectionsInSink
-            .findIndex(s => (s.ofsInSrc >= this.cutonlyAreaEnd));
+        let fstNoCutSectionInd = this.sectionsInSink.findIndex(s => (s.ofsInSrc >= this.cutonlyAreaEnd));
         if (fstNoCutSectionInd < 0) {
             fstNoCutSectionInd = this.sectionsInSink.length;
         }

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

@@ -0,0 +1,58 @@
+import { SingleProc } from '../processes/synced';
+type WritableFS = web3n.files.WritableFS;
+/**
+ * Log entry in synced files that act as broadcast of what operation a particular device has done.
+ * There may be race condition, in which devices may perform and record same operation simultaneously in different
+ * log files.
+ * There will also be situations when operation is recorded only on one device, like when triggered by action on
+ * one device.
+ *
+ * Regular log entry has payload in `p` and `n` with entry number that is an increment counter within a given log.
+ * When data set is synced to server, under some version `v`, a log entry with `syncPoint` is added.
+ * `syncPoint` contains `logSyncedPoints` with last operations on known devices that have been incorporated into
+ * the data set synced state of given version.
+ *
+ * Sync point information allows to ignore log entries, cutting log files accordingly.
+ */
+export interface LogEntry<T> {
+    /**
+     * When data set is synced to server, under some version `v`, this log entry is added.
+     * This contains `logSyncedPoints` with last operations on known devices that have been incorporated into data
+     * set synced state.
+     */
+    syncPoint?: {
+        v: number;
+        logSyncedPoints: {
+            [devId: string]: number;
+        };
+        params: any;
+    };
+    /**
+     * Increasing log entry number, unique to a given device log.
+     */
+    n: number;
+    /**
+     * Timestamp of log helps to somewhat order logs from many device.
+     */
+    ts: number;
+    /**
+     * Payload of regular log entry.
+     */
+    p?: T;
+}
+export declare function makeRecentChangesLogs<T>(logsFS: WritableFS, localLogsFS: WritableFS, areOpsEqual: (a: T, b: T) => boolean, logError: (err: any, msg?: string) => Promise<void>): Promise<{
+    appendLogsAndUpload: (...ops: T[]) => Promise<void> | undefined;
+    watchAndApplyOpsFromOtherDevices: (changeProc: SingleProc, sink: (ops: LogEntry<T>[]) => Promise<void>) => () => void;
+    numOfLogs: () => number;
+    cutLogOnDatasetSyncAndUpload: (syncPointV: number, params?: any) => Promise<void> | undefined;
+}>;
+export type RecentChangesLogs<T> = Awaited<ReturnType<typeof makeRecentChangesLogs<T>>>;
+export interface DatasetInstance<T> {
+    watchAndApplyOpsFromOtherDevices: (changeProc: SingleProc, resetSyncInterval: () => void) => (() => void);
+    absorbOpsFromOtherDevices: (changeProc: SingleProc, ops: LogEntry<T>[]) => Promise<void>;
+}
+export declare function startDatasetSync<T>(periodicCheckAndUploadOfData: () => Promise<void>, millisBeforeNextRun: () => number, logs: Pick<RecentChangesLogs<T>, 'watchAndApplyOpsFromOtherDevices'>, dataset: DatasetInstance<T>): {
+    changeProc: SingleProc;
+    stopSyncing: () => void;
+};
+export {};