core-3nweb-client-lib 0.43.17 → 0.43.18

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

@@ -1,5 +1,5 @@
 /*
- Copyright (C) 2016 - 2018, 2020, 2022, 2025 3NSoft Inc.
+ Copyright (C) 2016 - 2018, 2020, 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
@@ -1331,8 +1331,17 @@ declare namespace web3n.files {
 		 */
 		getRemoteFileItem(path: string, remoteItemName: string, remoteVersion?: number): Promise<ReadonlyFile>;
 
+		/**
+		 * Returns child folder from remote version of a folder.
+		 * @param path of folder
+		 * @param remoteItemName 
+		 * @param remoteVersion of folder. Default is current remote.
+		 */
 		getRemoteFolderItem(path: string, remoteItemName: string, remoteVersion?: number): Promise<ReadonlyFS>;
 
+		// XXX method to work around demaged files
+		// reloadFromServer(path: string): Promise<SyncStatus>;
+
 	}
 
 	/**
@@ -1346,8 +1355,12 @@ declare namespace web3n.files {
 		inCurrent?: ListingEntry[];
 		inRemote?: ListingEntry[];
 
-		// XXX 
-		// differentNames?: ;
+		// XXX add indication for items that have different name
+		differentNames?: {
+			localName: string;
+			remoteName: string;
+		}[];
+		differentKeys?: string[];
 
 		nameOverlaps?: string[];
 		ctime: {
@@ -1391,7 +1404,8 @@ declare namespace web3n.files {
 
 		/**
 		 * This method is for resolving conflicts on folders.
-		 * It adopts some folder items, and not the whole folder state.
+		 * It adopts given folder item, that is present in remote version and is missing in local version.
+		 * Returns new local version.
 		 * @param path 
 		 * @param remoteItemName 
 		 * @param opts 
@@ -1400,6 +1414,15 @@ declare namespace web3n.files {
 			path: string, remoteItemName: string, opts?: OptionsToAdoptRemoteItem
 		): Promise<number>;
 
+		/**
+		 * This method is for resolving conflicts on folders.
+		 * It adopts all folder items, that are present in remote version and are missing in local version.
+		 * Returns new local version, if there were remote items to adopt and their were added to local state.
+		 * @param path 
+		 * @param opts
+		 */
+		adoptAllRemoteItems(path: string, opts?: OptionsToAdoptAllRemoteItems): Promise<number|undefined>;
+
 	}
 
 	interface OptionsToAdoptRemoteItem {
@@ -1422,6 +1445,22 @@ declare namespace web3n.files {
 		newItemName?: string;
 	}
 
+	interface OptionsToAdoptAllRemoteItems {
+		/**
+		 * Folder's local version. If not given, current local version is used.
+		 */
+		localVersion?: number;
+		/**
+		 * Folder's remote version. If not given, current remote version is used.
+		 */
+		remoteVersion?: number;
+		/**
+		 * Postfix to add to remote item names that have overlapping names with existing local items.
+		 * If there are name overlaps and postfix isn't given, then exception is thrown.
+		 */
+		postfixForNameOverlaps?: string;
+	}
+
 	interface FSEvent {
 		path: string;
 	}

package/build/core-ipc/fs.d.ts

@@ -4,7 +4,6 @@ import { Caller, CoreSideServices } from "../ipc-via-protobuf/connector";
 import { FileMsg } from "./file";
 type FS = web3n.files.FS;
 type FSItem = web3n.files.FSItem;
-type OptionsToAdoptRemoteItem = web3n.files.OptionsToAdoptRemoteItem;
 export declare function makeFSCaller(caller: Caller, fsMsg: FSMsg): FS;
 export declare function exposeFSService(fs: FS, expServices: CoreSideServices): FSMsg;
 export interface FSMsg {
@@ -38,12 +37,4 @@ export declare namespace fsItem {
     function exposeFSItem(expServices: CoreSideServices, item: FSItem): FSItemMsg;
     function fsItemFromMsg(caller: Caller, msg: FSItemMsg): FSItem;
 }
-interface OptionsToAdoptRemoteItemMsg {
-    localVersion?: Value<number>;
-    remoteVersion?: Value<number>;
-    replaceLocalItem?: Value<boolean>;
-    newItemName?: Value<string>;
-}
-export declare function optionsToAdoptRemoteItemToMsg(opts: OptionsToAdoptRemoteItem | undefined): OptionsToAdoptRemoteItemMsg | undefined;
-export declare function optionsToAdoptRemoteItemFromMsg(msg: OptionsToAdoptRemoteItemMsg | undefined): OptionsToAdoptRemoteItem | undefined;
 export {};

package/build/core-ipc/fs.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2020, 2022, 2025 3NSoft Inc.
+ Copyright (C) 2020, 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
@@ -19,8 +19,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fsItem = exports.fsMsgType = void 0;
 exports.makeFSCaller = makeFSCaller;
 exports.exposeFSService = exposeFSService;
-exports.optionsToAdoptRemoteItemToMsg = optionsToAdoptRemoteItemToMsg;
-exports.optionsToAdoptRemoteItemFromMsg = optionsToAdoptRemoteItemFromMsg;
 const protobuf_msg_1 = require("../ipc-via-protobuf/protobuf-msg");
 const protobuf_type_1 = require("../lib-client/protobuf-type");
 const fs_proto_1 = require("../protos/fs.proto");
@@ -117,6 +115,7 @@ function makeFSCaller(caller, fsMsg) {
                 fs.v.sync.startUpload = vsStartUpload.makeCaller(caller, vsPath);
                 fs.v.sync.upload = vsUpload.makeCaller(caller, vsPath);
                 fs.v.sync.adoptRemoteFolderItem = vsAdoptRemoteFolderItem.makeCaller(caller, vsPath);
+                fs.v.sync.adoptAllRemoteItems = vsAdoptAllRemoteItems.makeCaller(caller, vsPath);
             }
         }
     }
@@ -200,6 +199,7 @@ function exposeFSService(fs, expServices) {
                 implExp.v.sync.startUpload = vsStartUpload.wrapService(fs.v.sync.startUpload);
                 implExp.v.sync.upload = vsUpload.wrapService(fs.v.sync.upload);
                 implExp.v.sync.adoptRemoteFolderItem = vsAdoptRemoteFolderItem.wrapService(fs.v.sync.adoptRemoteFolderItem);
+                implExp.v.sync.adoptAllRemoteFolderItems = vsAdoptAllRemoteItems.wrapService(fs.v.sync.adoptAllRemoteItems);
             }
         }
     }
@@ -1930,35 +1930,35 @@ var vsUpload;
     vsUpload.makeCaller = makeCaller;
 })(vsUpload || (vsUpload = {}));
 Object.freeze(vsUpload);
-function optionsToAdoptRemoteItemToMsg(opts) {
-    if (!opts) {
-        return;
-    }
-    return {
-        localVersion: (0, protobuf_msg_1.toOptVal)(opts.localVersion),
-        remoteVersion: (0, protobuf_msg_1.toOptVal)(opts.remoteVersion),
-        replaceLocalItem: (0, protobuf_msg_1.toOptVal)(opts.replaceLocalItem),
-        newItemName: (0, protobuf_msg_1.toOptVal)(opts.newItemName)
-    };
-}
-function optionsToAdoptRemoteItemFromMsg(msg) {
-    if (!msg) {
-        return;
-    }
-    return {
-        localVersion: (0, protobuf_msg_1.valOfOptInt)(msg.localVersion),
-        remoteVersion: (0, protobuf_msg_1.valOfOptInt)(msg.remoteVersion),
-        replaceLocalItem: (0, protobuf_msg_1.valOfOpt)(msg.replaceLocalItem),
-        newItemName: (0, protobuf_msg_1.valOfOpt)(msg.newItemName)
-    };
-}
 var vsAdoptRemoteFolderItem;
 (function (vsAdoptRemoteFolderItem) {
     const requestType = protobuf_type_1.ProtoType.for(fs_proto_1.fs.AdoptRemoteFolderItemRequestBody);
+    function optionsFromMsg(msg) {
+        if (!msg) {
+            return;
+        }
+        return {
+            localVersion: (0, protobuf_msg_1.valOfOptInt)(msg.localVersion),
+            remoteVersion: (0, protobuf_msg_1.valOfOptInt)(msg.remoteVersion),
+            replaceLocalItem: (0, protobuf_msg_1.valOfOpt)(msg.replaceLocalItem),
+            newItemName: (0, protobuf_msg_1.valOfOpt)(msg.newItemName)
+        };
+    }
+    function optionsToMsg(opts) {
+        if (!opts) {
+            return;
+        }
+        return {
+            localVersion: (0, protobuf_msg_1.toOptVal)(opts.localVersion),
+            remoteVersion: (0, protobuf_msg_1.toOptVal)(opts.remoteVersion),
+            replaceLocalItem: (0, protobuf_msg_1.toOptVal)(opts.replaceLocalItem),
+            newItemName: (0, protobuf_msg_1.toOptVal)(opts.newItemName)
+        };
+    }
     function wrapService(fn) {
         return buf => {
             const { path, itemName, opts } = requestType.unpack(buf);
-            const promise = fn(path, itemName, optionsToAdoptRemoteItemFromMsg(opts))
+            const promise = fn(path, itemName, optionsFromMsg(opts))
                 .then(protobuf_msg_1.packInt);
             return { promise };
         };
@@ -1968,13 +1968,55 @@ var vsAdoptRemoteFolderItem;
         const ipcPath = (0, protobuf_msg_1.methodPathFor)(objPath, 'adoptRemoteFolderItem');
         return (path, itemName, opts) => caller
             .startPromiseCall(ipcPath, requestType.pack({
-            path, itemName, opts: optionsToAdoptRemoteItemToMsg(opts)
+            path, itemName, opts: optionsToMsg(opts)
         }))
             .then(protobuf_msg_1.unpackInt);
     }
     vsAdoptRemoteFolderItem.makeCaller = makeCaller;
 })(vsAdoptRemoteFolderItem || (vsAdoptRemoteFolderItem = {}));
 Object.freeze(vsAdoptRemoteFolderItem);
+var vsAdoptAllRemoteItems;
+(function (vsAdoptAllRemoteItems) {
+    const requestType = protobuf_type_1.ProtoType.for(fs_proto_1.fs.AdoptAllRemoteFolderItemsRequestBody);
+    function optionsFromMsg(msg) {
+        if (!msg) {
+            return;
+        }
+        return {
+            localVersion: (0, protobuf_msg_1.valOfOptInt)(msg.localVersion),
+            remoteVersion: (0, protobuf_msg_1.valOfOptInt)(msg.remoteVersion),
+            postfixForNameOverlaps: (0, protobuf_msg_1.valOfOpt)(msg.postfixForNameOverlaps),
+        };
+    }
+    function optionsToMsg(opts) {
+        if (!opts) {
+            return;
+        }
+        return {
+            localVersion: (0, protobuf_msg_1.toOptVal)(opts.localVersion),
+            remoteVersion: (0, protobuf_msg_1.toOptVal)(opts.remoteVersion),
+            postfixForNameOverlaps: (0, protobuf_msg_1.toOptVal)(opts.postfixForNameOverlaps),
+        };
+    }
+    const replyType = protobuf_type_1.ProtoType.for(fs_proto_1.fs.AdoptAllRemoteFolderItemsReplyBody);
+    function wrapService(fn) {
+        return buf => {
+            const { path, opts } = requestType.unpack(buf);
+            const promise = fn(path, optionsFromMsg(opts))
+                .then(newVersion => replyType.pack({ newVersion: (0, protobuf_msg_1.toOptVal)(newVersion) }));
+            return { promise };
+        };
+    }
+    vsAdoptAllRemoteItems.wrapService = wrapService;
+    function makeCaller(caller, objPath) {
+        const ipcPath = (0, protobuf_msg_1.methodPathFor)(objPath, 'adoptAllRemoteItems');
+        return (path, opts) => caller
+            .startPromiseCall(ipcPath, requestType.pack({ path, opts: optionsToMsg(opts) }))
+            .then(buf => (0, protobuf_msg_1.valOfOpt)(replyType.unpack(buf).newVersion));
+    }
+    vsAdoptAllRemoteItems.makeCaller = makeCaller;
+})(vsAdoptAllRemoteItems || (vsAdoptAllRemoteItems = {}));
+Object.freeze(vsAdoptAllRemoteItems);
 var vsAdoptRemote;
 (function (vsAdoptRemote) {
     const requestType = protobuf_type_1.ProtoType.for(fs_proto_1.fs.AdoptRemoteRequestBody);

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

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2016 - 2022, 2025 3NSoft Inc.
+ Copyright (C) 2016 - 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
@@ -241,6 +241,7 @@ function wrapWritableFSSyncAPI(sImpl) {
         startUpload: sImpl.startUpload.bind(sImpl),
         upload: sImpl.upload.bind(sImpl),
         adoptRemoteFolderItem: sImpl.adoptRemoteFolderItem.bind(sImpl),
+        adoptAllRemoteItems: sImpl.adoptAllRemoteItems.bind(sImpl),
         statRemoteItem: sImpl.statRemoteItem.bind(sImpl),
         listRemoteFolderItem: sImpl.listRemoteFolderItem.bind(sImpl),
         getRemoteFileItem: sImpl.getRemoteFileItem.bind(sImpl),

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

@@ -11,6 +11,7 @@ type XAttrsChanges = web3n.files.XAttrsChanges;
 type FolderDiff = web3n.files.FolderDiff;
 type OptionsToAdopteRemote = web3n.files.OptionsToAdopteRemote;
 type OptionsToAdoptRemoteItem = web3n.files.OptionsToAdoptRemoteItem;
+type OptionsToAdoptAllRemoteItems = web3n.files.OptionsToAdoptAllRemoteItems;
 type OptionsToUploadLocal = web3n.files.OptionsToUploadLocal;
 type VersionedReadFlags = web3n.files.VersionedReadFlags;
 type Stats = web3n.files.Stats;
@@ -96,6 +97,16 @@ export declare class FolderNode extends NodeInFS<FolderPersistance> {
     getFile(name: string, undefOnMissing?: boolean): Promise<FileNode | undefined>;
     getLink(name: string, undefOnMissing?: boolean): Promise<LinkNode | undefined>;
     private fixMissingChildAndThrow;
+    adoptItemsFromRemoteVersion(opts: OptionsToAdoptAllRemoteItems | undefined): Promise<number | undefined>;
+    /**
+     * If no initial local version given, then this performs like doTransition(change) method.
+     * When initial local version is given and check, exceptions are thrown if versions mismatch,
+     * or when there is another concurrent process that is already transitioning folder state to new state.
+     * This returns value of new local version.
+     * @param initLocalVersion
+     * @param change
+     */
+    private doChangeWhileTrackingVersion;
     /**
      * This method prepares a transition state, runs given action, and completes
      * transition to a new version.
@@ -161,6 +172,7 @@ export declare class FolderNode extends NodeInFS<FolderPersistance> {
     private getRemoteChildNodeInfo;
     private addRemoteChild;
     private replaceLocalChildWithRemote;
+    private readRemoteVersion;
     diffCurrentAndRemote(remoteVersion: number | undefined): Promise<FolderDiff | undefined>;
     private diffWithArchivedRemote;
     private diffWithRemote;

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

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2020, 2022, 2025 3NSoft Inc.
+ Copyright (C) 2015 - 2020, 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
@@ -337,6 +337,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             else if (exc.failedCipherVerification) {
                 exc = (0, file_1.makeFileException)('ioError', `${this.name}/${info.name}`, exc);
             }
+            // XXX why and what ?
             deferred.reject((0, error_1.errWithCause)(exc, `Failed to instantiate fs node '${this.name}/${info.name}'`));
             return nodeSet;
         }
@@ -370,6 +371,75 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         fileExc.inconsistentStateOfFS = true;
         throw fileExc;
     }
+    async adoptItemsFromRemoteVersion(opts) {
+        const { state, remote } = await this.syncStatus();
+        if ((state !== 'conflicting') && (state !== 'behind')) {
+            return;
+        }
+        const remoteVersion = versionFromRemoteBranch(remote, opts === null || opts === void 0 ? void 0 : opts.remoteVersion);
+        if (!remoteVersion) {
+            throw 'something';
+        }
+        const { folderInfo: remoteState } = await this.readRemoteVersion(remoteVersion);
+        return await this.doChangeWhileTrackingVersion(opts === null || opts === void 0 ? void 0 : opts.localVersion, async (state) => {
+            const { inRemote, nameOverlaps, differentKeys } = diffNodes(state, remoteState);
+            if (differentKeys) {
+                throw 'something';
+            }
+            if (!inRemote) {
+                return [];
+            }
+            const addedNodes = new Set();
+            if (nameOverlaps) {
+                const postfix = opts === null || opts === void 0 ? void 0 : opts.postfixForNameOverlaps;
+                if ((postfix === undefined) || (postfix.length < 0)) {
+                    throw 'something';
+                }
+                for (const itemName of nameOverlaps) {
+                    const node = remoteState.nodes[itemName];
+                    let newName = `${itemName}${postfix}`;
+                    while (state.nodes[newName]) {
+                        newName = `${newName}${postfix}`;
+                    }
+                    node.name = newName;
+                    state[newName] = node;
+                    addedNodes.add(itemName);
+                }
+            }
+            for (const { name: itemName } of inRemote) {
+                if (addedNodes.has(itemName)) {
+                    continue;
+                }
+                const node = remoteState.nodes[itemName];
+                state[itemName] = node;
+            }
+            return [];
+        });
+    }
+    /**
+     * If no initial local version given, then this performs like doTransition(change) method.
+     * When initial local version is given and check, exceptions are thrown if versions mismatch,
+     * or when there is another concurrent process that is already transitioning folder state to new state.
+     * This returns value of new local version.
+     * @param initLocalVersion
+     * @param change
+     */
+    async doChangeWhileTrackingVersion(initLocalVersion, change) {
+        if (initLocalVersion) {
+            if (this.version === initLocalVersion) {
+                return await this.doChange(false, () => this.performTransition(change));
+            }
+            else {
+                throw (0, exceptions_1.makeFSSyncException)(this.name, {
+                    versionMismatch: true,
+                    message: `Given local version ${initLocalVersion} is not equal to current ${this.version}`
+                });
+            }
+        }
+        else {
+            return await this.doChange(true, () => this.performTransition(change));
+        }
+    }
     /**
      * This method prepares a transition state, runs given action, and completes
      * transition to a new version.
@@ -406,6 +476,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             const { event, childObjId } = changeEvents;
             this.broadcastEvent(event, false, childObjId);
         }
+        return version;
     }
     /**
      * This function only creates folder node, but it doesn't insert it anywhere.
@@ -894,14 +965,6 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         return removedNodes;
     }
     async adoptRemoteFolderItem(remoteItemName, opts) {
-        if (opts === null || opts === void 0 ? void 0 : opts.localVersion) {
-            if (this.version !== opts.localVersion) {
-                throw (0, exceptions_1.makeFSSyncException)(this.name, {
-                    versionMismatch: true,
-                    message: `Given local version ${opts.localVersion} is not equal to current ${this.version}`
-                });
-            }
-        }
         const remoteChildNode = await this.getRemoteChildNodeInfo(remoteItemName, opts === null || opts === void 0 ? void 0 : opts.remoteVersion);
         let dstItemName = remoteItemName;
         if (typeof (opts === null || opts === void 0 ? void 0 : opts.newItemName) === 'string') {
@@ -912,15 +975,14 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         }
         const localNodeWithSameName = this.getCurrentNodeInfo(dstItemName, true);
         if (!localNodeWithSameName) {
-            return await this.addRemoteChild(remoteChildNode, dstItemName);
+            return await this.addRemoteChild(remoteChildNode, dstItemName, opts === null || opts === void 0 ? void 0 : opts.localVersion);
         }
         else if (localNodeWithSameName.objId === remoteChildNode.objId) {
-            (0, assert_1.assert)(typeOfNode(localNodeWithSameName) === typeOfNode(remoteChildNode));
             // XXX
             throw new Error(`Adaptation of changing keys needs implementation`);
         }
         else if (opts === null || opts === void 0 ? void 0 : opts.replaceLocalItem) {
-            return await this.replaceLocalChildWithRemote(remoteChildNode);
+            return await this.replaceLocalChildWithRemote(remoteChildNode, opts === null || opts === void 0 ? void 0 : opts.localVersion);
         }
         else {
             throw (0, exceptions_1.makeFSSyncException)(this.name, {
@@ -964,10 +1026,8 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             });
         }
     }
-    async addRemoteChild(remoteChildNode, childName) {
-        let newVersion;
-        await this.doTransition(async (state, version) => {
-            newVersion = version;
+    addRemoteChild(remoteChildNode, childName, initLocalVersion) {
+        return this.doChangeWhileTrackingVersion(initLocalVersion, async (state, newVersion) => {
             remoteChildNode.name = childName;
             state.nodes[remoteChildNode.name] = remoteChildNode;
             const event = {
@@ -979,13 +1039,10 @@ class FolderNode extends node_in_fs_1.NodeInFS {
             };
             return { event, childObjId: remoteChildNode.objId };
         });
-        return newVersion;
     }
-    async replaceLocalChildWithRemote(remoteChildNode) {
+    async replaceLocalChildWithRemote(remoteChildNode, initLocalVersion) {
         let origChildNode;
-        let newVersion;
-        await this.doTransition(async (state, version) => {
-            newVersion = version;
+        const newVersion = await this.doChangeWhileTrackingVersion(initLocalVersion, async (state, newVersion) => {
             origChildNode = state.nodes[remoteChildNode.name];
             state.nodes[remoteChildNode.name] = remoteChildNode;
             const additionEvent = {
@@ -1011,8 +1068,12 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         this.uploadRemovalOfObjs(removalsToUpload);
         return newVersion;
     }
+    async readRemoteVersion(remoteVersion) {
+        const storage = this.syncedStorage();
+        const srcOfRemote = await storage.getObjSrcOfRemoteVersion(this.objId, remoteVersion);
+        return await this.crypto.read(srcOfRemote);
+    }
     async diffCurrentAndRemote(remoteVersion) {
-        var _a;
         const { state, remote } = await this.syncStatus();
         let isCurrentLocal;
         if (state === 'behind') {
@@ -1024,26 +1085,13 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         else {
             return;
         }
-        if (remote.isArchived) {
-            return this.diffWithArchivedRemote(isCurrentLocal);
+        remoteVersion = versionFromRemoteBranch(remote, remoteVersion);
+        if (remoteVersion) {
+            const { folderInfo, attrs, xattrs } = await this.readRemoteVersion(remoteVersion);
+            return this.diffWithRemote(isCurrentLocal, remoteVersion, folderInfo, attrs, xattrs);
         }
         else {
-            if (remoteVersion) {
-                if ((remoteVersion !== remote.latest)
-                    && !((_a = remote.archived) === null || _a === void 0 ? void 0 : _a.includes(remoteVersion))) {
-                    throw (0, exceptions_1.makeFSSyncException)(this.name, {
-                        versionMismatch: true,
-                        message: `Unknown remote version ${remoteVersion}`
-                    });
-                }
-            }
-            else {
-                remoteVersion = remote.latest;
-            }
-            const storage = this.syncedStorage();
-            const srcOfRemote = await storage.getObjSrcOfRemoteVersion(this.objId, remote.latest);
-            const { folderInfo, attrs, xattrs } = await this.crypto.read(srcOfRemote);
-            return this.diffWithRemote(isCurrentLocal, remoteVersion, folderInfo, attrs, xattrs);
+            return this.diffWithArchivedRemote(isCurrentLocal);
         }
     }
     diffWithArchivedRemote(isCurrentLocal) {
@@ -1118,20 +1166,6 @@ function nodeToListingEntry({ name, type }) {
             return { name };
     }
 }
-function typeOfNode(nodeInfo) {
-    if (nodeInfo.isFolder) {
-        return 'folder';
-    }
-    else if (nodeInfo.isFile) {
-        return 'file';
-    }
-    else if (nodeInfo.isLink) {
-        return 'link';
-    }
-    else {
-        throw new Error(`Unknown type of node info`);
-    }
-}
 function addToTransitionState(state, f, key) {
     const nodeInfo = {
         name: f.name,
@@ -1165,42 +1199,46 @@ function diffAttrs(current, remote) {
     };
 }
 function diffNodes(current, remote) {
-    const inCurrent = getOnlyNotEqualNodes(current.nodes, remote.nodes);
-    const inRemote = getOnlyNotEqualNodes(remote.nodes, current.nodes);
-    const combined = combineCheckingNameOverlaps(inCurrent, inRemote);
-    return (combined ? combined : {});
-}
-function getOnlyNotEqualNodes(src, exclude) {
-    const collected = [];
-    for (const [name, nodeInSrc] of Object.entries(src)) {
-        const nodeInExclude = exclude[name];
-        if (!nodeInExclude
-            || !areNodesEqual(nodeInSrc, nodeInExclude)) {
-            collected.push(nodeInfoToListingEntry(nodeInSrc));
+    const inRemote = [];
+    const nodesInCurrentById = new Map();
+    for (const node of Object.values(current.nodes)) {
+        nodesInCurrentById.set(node.objId, node);
+    }
+    const nameOverlaps = [];
+    const differentNames = [];
+    const differentKeys = [];
+    for (const remoteNode of Object.values(remote.nodes)) {
+        const localNode = nodesInCurrentById.get(remoteNode.objId);
+        if (localNode) {
+            if (localNode.name !== remoteNode.name) {
+                differentNames.push({
+                    localName: localNode.name,
+                    remoteName: remoteNode.name
+                });
+            }
+            if (!areBytesEqual(localNode.key, remoteNode.key)) {
+                differentKeys.push(localNode.name);
+            }
+            nodesInCurrentById.delete(remoteNode.objId);
+        }
+        else {
+            inRemote.push(nodeInfoToListingEntry(remoteNode));
+            if (current.nodes[remoteNode.name]) {
+                nameOverlaps.push(remoteNode.name);
+            }
         }
     }
-    return ((collected.length > 0) ? collected : undefined);
-}
-function areNodesEqual(n1, n2) {
-    if (n1.name !== n2.name) {
-        return false;
-    }
-    if (n1.isFile && !n2.isFile) {
-        return false;
-    }
-    if (n1.isFolder && !n2.isFolder) {
-        return false;
-    }
-    if (n1.isLink && !n2.isLink) {
-        return false;
-    }
-    if (n1.objId !== n2.objId) {
-        return false;
-    }
-    if (!areBytesEqual(n1.key, n2.key)) {
-        return false;
+    const inCurrent = [];
+    for (const localNode of nodesInCurrentById.values()) {
+        inCurrent.push(nodeInfoToListingEntry(localNode));
     }
-    return true;
+    return {
+        inCurrent: ((inCurrent.length > 0) ? inCurrent : undefined),
+        inRemote: ((inRemote.length > 0) ? inRemote : undefined),
+        differentNames: ((differentNames.length > 0) ? differentNames : undefined),
+        nameOverlaps: ((nameOverlaps.length > 0) ? nameOverlaps : undefined),
+        differentKeys: ((differentKeys.length > 0) ? differentKeys : undefined)
+    };
 }
 function combineCheckingNameOverlaps(inCurrent, inRemote) {
     if (inCurrent) {
@@ -1343,4 +1381,22 @@ function identifyChanges(originalNodes, newNodes) {
     }
     return { addedNodes, removedNodes, renamedNodes };
 }
+function versionFromRemoteBranch(remote, remoteVersion) {
+    var _a;
+    if (remote.isArchived) {
+        return;
+    }
+    if (remoteVersion) {
+        if ((remoteVersion !== remote.latest)
+            && !((_a = remote.archived) === null || _a === void 0 ? void 0 : _a.includes(remoteVersion))) {
+            throw (0, exceptions_1.makeFSSyncException)(this.name, {
+                versionMismatch: true,
+                message: `Unknown remote version ${remoteVersion}`
+            });
+        }
+    }
+    else {
+        return remote.latest;
+    }
+}
 Object.freeze(exports);

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

@@ -28,6 +28,7 @@ type SyncStatus = web3n.files.SyncStatus;
 type WritableFSVersionedAPI = web3n.files.WritableFSVersionedAPI;
 type OptionsToAdopteRemote = web3n.files.OptionsToAdopteRemote;
 type OptionsToAdoptRemoteItem = web3n.files.OptionsToAdoptRemoteItem;
+type OptionsToAdoptAllRemoteItems = web3n.files.OptionsToAdoptAllRemoteItems;
 type OptionsToUploadLocal = web3n.files.OptionsToUploadLocal;
 type FolderDiff = web3n.files.FolderDiff;
 export declare class XspFS implements WritableFS {
@@ -182,5 +183,6 @@ declare class S implements WritableFSSyncAPI {
     listRemoteFolderItem(path: string, remoteItemName: string, remoteVersion?: number): Promise<ListingEntry[]>;
     getRemoteFileItem(path: string, remoteItemName: string, remoteVersion?: number): Promise<ReadonlyFile>;
     getRemoteFolderItem(path: string, remoteItemName: string, remoteVersion?: number): Promise<ReadonlyFS>;
+    adoptAllRemoteItems(path: string, opts?: OptionsToAdoptAllRemoteItems): Promise<number | undefined>;
 }
 export {};