@filen/sync 0.2.1 → 0.3.2

package/dist/lib/filesystems/remote.js

@@ -3,17 +3,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RemoteFileSystem = exports.DEVICE_ID_VERSION = void 0;
+exports.RemoteFileSystem = exports.REMOTE_BUILD_CONCURRENCY = exports.DEVICE_ID_VERSION = void 0;
 const sdk_1 = require("@filen/sdk");
 const path_1 = __importDefault(require("path"));
 const semaphore_1 = require("../../semaphore");
-const fs_extra_1 = __importDefault(require("fs-extra"));
 const ipc_1 = require("../ipc");
 const utils_1 = require("../../utils");
 const uuid_1 = require("uuid");
 const constants_1 = require("../../constants");
-const write_file_atomic_1 = __importDefault(require("write-file-atomic"));
 exports.DEVICE_ID_VERSION = 1;
+/**
+ * How many remote items (folders, then files) are decrypted concurrently while building the tree. The
+ * build decrypts entries in fixed-size batches instead of mapping ALL entries to promises up front — on a
+ * tree with millions of entries that eager map allocated millions of pending promises + closures at once
+ * (an O(n) peak-memory spike). A batch caps peak concurrency — and therefore peak memory — without
+ * reducing throughput (the SDK's decrypt/IO services only a handful in parallel regardless), and the batch
+ * size IS the parallel-decrypt width (it replaces the old 1024-wide listSemaphore).
+ */
+exports.REMOTE_BUILD_CONCURRENCY = 1024;
 class RemoteFileSystem {
     constructor(sync) {
         this.getDirectoryTreeCache = {
@@ -26,7 +33,6 @@ class RemoteFileSystem {
         this.mutex = new semaphore_1.Semaphore(1);
         this.mkdirMutex = new semaphore_1.Semaphore(1);
         this.itemsMutex = new semaphore_1.Semaphore(1);
-        this.listSemaphore = new semaphore_1.Semaphore(1024);
         this.deviceIdCache = "";
         this.ignoredCache = new Map();
         this.sync = sync;
@@ -36,16 +42,16 @@ class RemoteFileSystem {
             return this.deviceIdCache;
         }
         const deviceIdFile = path_1.default.join(this.sync.dbPath, "deviceId", `v${exports.DEVICE_ID_VERSION}`, this.sync.syncPair.uuid);
-        await fs_extra_1.default.ensureDir(path_1.default.dirname(deviceIdFile));
-        let deviceId = "";
-        if (!(await fs_extra_1.default.exists(deviceIdFile))) {
+        await this.sync.environment.fs.ensureDir(path_1.default.dirname(deviceIdFile));
+        let deviceId;
+        if (!(await this.sync.environment.fs.exists(deviceIdFile))) {
             deviceId = (0, uuid_1.v4)();
-            await (0, write_file_atomic_1.default)(deviceIdFile, deviceId, {
+            await this.sync.environment.writeFileAtomic(deviceIdFile, deviceId, {
                 encoding: "utf-8"
             });
         }
         else {
-            deviceId = await fs_extra_1.default.readFile(deviceIdFile, {
+            deviceId = await this.sync.environment.fs.readFile(deviceIdFile, {
                 encoding: "utf-8"
             });
         }
@@ -54,8 +60,8 @@ class RemoteFileSystem {
     }
     async clearDeviceId() {
         const deviceIdFile = path_1.default.join(this.sync.dbPath, "deviceId", `v${exports.DEVICE_ID_VERSION}`, this.sync.syncPair.uuid);
-        await fs_extra_1.default.ensureDir(path_1.default.dirname(deviceIdFile));
-        await fs_extra_1.default.rm(deviceIdFile, {
+        await this.sync.environment.fs.ensureDir(path_1.default.dirname(deviceIdFile));
+        await this.sync.environment.fs.rm(deviceIdFile, {
             force: true,
             maxRetries: 60 * 10,
             recursive: true,
@@ -64,8 +70,10 @@ class RemoteFileSystem {
     }
     isPathIgnored({ absolutePath, relativePath, name, type }) {
         const key = absolutePath + ":" + type;
-        if (this.ignoredCache.get(key)) {
-            return this.ignoredCache.get(key);
+        // One cache lookup, not two (the second redundant get() ran per item on every tree build).
+        const cached = this.ignoredCache.get(key);
+        if (cached) {
+            return cached;
         }
         if ((0, utils_1.isPathOverMaxLength)(absolutePath)) {
             this.ignoredCache.set(key, {
@@ -137,11 +145,10 @@ class RemoteFileSystem {
     }
     async getDirectoryTree(skipCache = false) {
         const deviceId = await this.getDeviceId();
-        const dir = await this.sync.sdk.api(3).dir().tree({
+        const dir = await this.sync.environment.fetchDirTree(this.sync.sdk, {
             uuid: this.sync.syncPair.remoteParentUUID,
             deviceId,
-            skipCache,
-            includeRaw: false
+            skipCache
         });
         const now = Date.now();
         // Data did not change, use cache
@@ -156,152 +163,171 @@ class RemoteFileSystem {
                 changed: false
             };
         }
-        const baseFolder = dir.folders[0];
-        if (!baseFolder) {
-            throw new Error("Could not get base folder.");
-        }
-        const baseFolderParent = baseFolder[2];
-        if (baseFolderParent !== "base") {
+        // The /v3/dir/tree response can arrive UNORDERED — there is no guarantee a parent folder precedes its
+        // children, nor that folders[0] is the sync root. So we decrypt every folder's metadata first (in
+        // bounded-concurrency batches, capping peak pending promises/memory), then resolve each folder's full
+        // path by walking its parent chain to the sync root (memoized). The previous implementation built
+        // paths incrementally in array order and required folders[0].parent === "base", so an out-of-order
+        // response corrupted child paths or threw. We still REQUIRE a sync-root folder (parent "base") to
+        // exist: a response with none is malformed and must NOT be read as an empty tree (that would look like
+        // every remote node was deleted). (perf + unordered correctness)
+        if (!dir.folders.some(folder => folder[2] === "base")) {
             throw new Error("Invalid base folder parent.");
         }
-        const folderNames = { base: "/" };
         const pathsAdded = {};
         let size = 0;
         this.getDirectoryTreeCache.ignored = [];
         this.getDirectoryTreeCache.tree = {};
         this.getDirectoryTreeCache.uuids = {};
         this.getDirectoryTreeCache.size = 0;
-        for (const folder of dir.folders) {
-            try {
-                const decrypted = await this.sync.sdk.crypto().decrypt().folderMetadata({ metadata: folder[1] });
-                const parentPath = folder[2] === "base" ? "" : `${folderNames[folder[2]]}/`;
-                const folderPath = folder[2] === "base" ? "" : `${parentPath}${decrypted.name}`;
-                const localPath = path_1.default.join(this.sync.syncPair.localPath, folderPath);
-                folderNames[folder[0]] = folderPath;
-                if (folderPath.startsWith(constants_1.LOCAL_TRASH_NAME) ||
-                    decrypted.name.startsWith(constants_1.LOCAL_TRASH_NAME) ||
-                    (folder[2] !== "base" && decrypted.name.length === 0)) {
-                    continue;
+        const folderMeta = new Map();
+        for (let offset = 0; offset < dir.folders.length; offset += exports.REMOTE_BUILD_CONCURRENCY) {
+            await Promise.all(dir.folders.slice(offset, offset + exports.REMOTE_BUILD_CONCURRENCY).map(async (folder) => {
+                try {
+                    const decrypted = await this.sync.sdk.crypto().decrypt().folderMetadata({ metadata: folder[1] });
+                    folderMeta.set(folder[0], { name: decrypted.name, parent: folder[2] });
                 }
-                const lowercasePath = folderPath.toLowerCase();
-                if (pathsAdded[lowercasePath]) {
-                    this.getDirectoryTreeCache.ignored.push({
-                        localPath,
-                        relativePath: folderPath,
-                        reason: "duplicate"
-                    });
-                    continue;
-                }
-                pathsAdded[lowercasePath] = true;
-                if (folderPath.length === 0) {
-                    continue;
+                catch (e) {
+                    this.sync.worker.logger.log("error", e, "filesystems.remote.getDirectoryTree");
+                    this.sync.worker.logger.log("error", e);
                 }
-                const ignored = this.isPathIgnored({
-                    absolutePath: localPath,
+            }));
+        }
+        // Resolve a folder uuid to its relative path ("" = the sync root), memoized. Depth-bounded so a
+        // malformed cyclic chain can never infinite-loop; returns undefined for an orphan (parent absent).
+        // Format matches the old code exactly: root -> "", a child of `parent` -> `${parentPath}/${name}`
+        // (so a top-level dir is "/name", a nested one "/a/b").
+        const folderPathByUUID = new Map();
+        const resolveFolderPath = (uuid, depth) => {
+            const cached = folderPathByUUID.get(uuid);
+            if (cached !== undefined) {
+                return cached;
+            }
+            if (depth > dir.folders.length) {
+                return undefined;
+            }
+            const meta = folderMeta.get(uuid);
+            if (!meta) {
+                return undefined;
+            }
+            if (meta.parent === "base") {
+                folderPathByUUID.set(uuid, "");
+                return "";
+            }
+            const parentPath = resolveFolderPath(meta.parent, depth + 1);
+            if (parentPath === undefined) {
+                return undefined;
+            }
+            const path = `${parentPath}/${meta.name}`;
+            folderPathByUUID.set(uuid, path);
+            return path;
+        };
+        // Build the folder tree. Iterate the response array (preserving first-occurrence-wins dedup order);
+        // only the PATH resolution above is order-independent.
+        for (const folder of dir.folders) {
+            const meta = folderMeta.get(folder[0]);
+            if (!meta) {
+                continue;
+            }
+            const folderPath = resolveFolderPath(folder[0], 0);
+            // undefined => orphan (broken parent chain); "" => the sync root. Neither is a tree entry.
+            if (folderPath === undefined || folderPath.length === 0) {
+                continue;
+            }
+            const localPath = path_1.default.join(this.sync.syncPair.localPath, folderPath);
+            if (folderPath.startsWith(constants_1.LOCAL_TRASH_NAME) || meta.name.startsWith(constants_1.LOCAL_TRASH_NAME) || meta.name.length === 0) {
+                continue;
+            }
+            const lowercasePath = folderPath.toLowerCase();
+            if (pathsAdded[lowercasePath]) {
+                this.getDirectoryTreeCache.ignored.push({
+                    localPath,
                     relativePath: folderPath,
-                    name: decrypted.name,
-                    type: "directory"
+                    reason: "duplicate"
                 });
-                if (ignored.ignored) {
-                    this.getDirectoryTreeCache.ignored.push({
-                        localPath,
-                        relativePath: folderPath,
-                        reason: ignored.reason
-                    });
-                    continue;
-                }
-                const item = {
-                    type: "directory",
-                    uuid: folder[0],
-                    name: decrypted.name,
-                    size: 0,
-                    path: folderPath
-                };
-                this.getDirectoryTreeCache.tree[folderPath] = item;
-                this.getDirectoryTreeCache.uuids[folder[0]] = item;
-                size += 1;
+                continue;
             }
-            catch (e) {
-                this.sync.worker.logger.log("error", e, "filesystems.remote.getDirectoryTree");
-                this.sync.worker.logger.log("error", e);
+            pathsAdded[lowercasePath] = true;
+            const ignored = this.isPathIgnored({
+                absolutePath: localPath,
+                relativePath: folderPath,
+                name: meta.name,
+                type: "directory"
+            });
+            if (ignored.ignored) {
+                this.getDirectoryTreeCache.ignored.push({
+                    localPath,
+                    relativePath: folderPath,
+                    reason: ignored.reason
+                });
+                continue;
             }
-        }
-        if (Object.keys(folderNames).length === 0) {
-            throw new Error("Could not build directory tree.");
-        }
-        await (0, utils_1.promiseAllChunked)(dir.files.map(async (file) => {
-            await this.listSemaphore.acquire();
-            try {
-                const decrypted = await this.sync.sdk.crypto().decrypt().fileMetadata({ metadata: file[5] });
-                if (decrypted.name.length === 0) {
-                    return;
-                }
-                const parentPath = folderNames[file[4]];
-                const filePath = `${parentPath}/${decrypted.name}`;
-                const localPath = path_1.default.join(this.sync.syncPair.localPath, filePath);
-                if (filePath.startsWith(constants_1.LOCAL_TRASH_NAME) || decrypted.name.startsWith(constants_1.LOCAL_TRASH_NAME) || filePath.length === 0) {
-                    return;
-                }
-                const lowercasePath = filePath.toLowerCase();
-                if (pathsAdded[lowercasePath]) {
-                    this.getDirectoryTreeCache.ignored.push({
-                        localPath,
-                        relativePath: filePath,
-                        reason: "duplicate"
-                    });
-                    return;
-                }
-                pathsAdded[lowercasePath] = true;
-                if (decrypted.size <= 0) {
-                    this.getDirectoryTreeCache.ignored.push({
-                        localPath,
+            const item = {
+                type: "directory",
+                uuid: folder[0],
+                name: meta.name,
+                size: 0,
+                path: folderPath
+            };
+            this.getDirectoryTreeCache.tree[folderPath] = item;
+            this.getDirectoryTreeCache.uuids[folder[0]] = item;
+            size += 1;
+        }
+        // Files: decrypt + place in bounded-concurrency batches (caps peak pending promises/memory; the batch
+        // size IS the parallel-decrypt width, replacing the eager `map` + 1024 semaphore that created N
+        // promises up front). Folders were fully resolved above, so every file's parent path is available.
+        for (let offset = 0; offset < dir.files.length; offset += exports.REMOTE_BUILD_CONCURRENCY) {
+            await Promise.all(dir.files.slice(offset, offset + exports.REMOTE_BUILD_CONCURRENCY).map(async (file) => {
+                try {
+                    const decrypted = await this.sync.sdk.crypto().decrypt().fileMetadata({ metadata: file[5] });
+                    if (decrypted.name.length === 0) {
+                        return;
+                    }
+                    const parentPath = folderPathByUUID.get(file[4]);
+                    // Orphan file (its parent folder was absent from the response) — skip it.
+                    if (parentPath === undefined) {
+                        return;
+                    }
+                    const filePath = `${parentPath}/${decrypted.name}`;
+                    const localPath = path_1.default.join(this.sync.syncPair.localPath, filePath);
+                    if (filePath.startsWith(constants_1.LOCAL_TRASH_NAME) || decrypted.name.startsWith(constants_1.LOCAL_TRASH_NAME) || filePath.length === 0) {
+                        return;
+                    }
+                    const lowercasePath = filePath.toLowerCase();
+                    if (pathsAdded[lowercasePath]) {
+                        this.getDirectoryTreeCache.ignored.push({
+                            localPath,
+                            relativePath: filePath,
+                            reason: "duplicate"
+                        });
+                        return;
+                    }
+                    pathsAdded[lowercasePath] = true;
+                    const ignored = this.isPathIgnored({
+                        absolutePath: localPath,
                         relativePath: filePath,
-                        reason: "empty"
+                        name: decrypted.name,
+                        type: "file"
                     });
-                    return;
+                    if (ignored.ignored) {
+                        this.getDirectoryTreeCache.ignored.push({
+                            localPath,
+                            relativePath: filePath,
+                            reason: ignored.reason
+                        });
+                        return;
+                    }
+                    const item = Object.assign(Object.assign(Object.assign({ type: "file", uuid: file[0], name: decrypted.name, size: decrypted.size, mime: decrypted.mime, lastModified: (0, utils_1.convertTimestampToMs)(decrypted.lastModified), version: file[6], chunks: file[3], key: decrypted.key, bucket: file[1], region: file[2] }, (decrypted.creation !== undefined ? { creation: decrypted.creation } : {})), (decrypted.hash !== undefined ? { hash: decrypted.hash } : {})), { path: filePath });
+                    this.getDirectoryTreeCache.tree[filePath] = item;
+                    this.getDirectoryTreeCache.uuids[item.uuid] = item;
+                    size += 1;
                 }
-                const ignored = this.isPathIgnored({
-                    absolutePath: localPath,
-                    relativePath: filePath,
-                    name: decrypted.name,
-                    type: "directory"
-                });
-                if (ignored.ignored) {
-                    this.getDirectoryTreeCache.ignored.push({
-                        localPath,
-                        relativePath: filePath,
-                        reason: ignored.reason
-                    });
-                    return;
+                catch (e) {
+                    this.sync.worker.logger.log("error", e, "filesystems.remote.getDirectoryTree");
+                    this.sync.worker.logger.log("error", e);
                 }
-                const item = {
-                    type: "file",
-                    uuid: file[0],
-                    name: decrypted.name,
-                    size: decrypted.size,
-                    mime: decrypted.mime,
-                    lastModified: (0, utils_1.convertTimestampToMs)(decrypted.lastModified),
-                    version: file[6],
-                    chunks: file[3],
-                    key: decrypted.key,
-                    bucket: file[1],
-                    region: file[2],
-                    creation: decrypted.creation,
-                    hash: decrypted.hash,
-                    path: filePath
-                };
-                this.getDirectoryTreeCache.tree[filePath] = item;
-                this.getDirectoryTreeCache.uuids[item.uuid] = item;
-                size += 1;
-            }
-            catch (e) {
-                this.sync.worker.logger.log("error", e, "filesystems.remote.getDirectoryTree");
-                this.sync.worker.logger.log("error", e);
-            }
-            finally {
-                this.listSemaphore.release();
-            }
-        }), 10000, false);
+            }));
+        }
         this.getDirectoryTreeCache.size = size;
         this.getDirectoryTreeCache.timestamp = now;
         return {
@@ -333,8 +359,9 @@ class RemoteFileSystem {
         if (relativePath === "/" || relativePath === "." || relativePath.length <= 0) {
             return this.sync.syncPair.remoteParentUUID;
         }
-        if (this.getDirectoryTreeCache.tree[relativePath] && acceptedTypes.includes(this.getDirectoryTreeCache.tree[relativePath].type)) {
-            return this.getDirectoryTreeCache.tree[relativePath].uuid;
+        const item = this.getDirectoryTreeCache.tree[relativePath];
+        if (item && acceptedTypes.includes(item.type)) {
+            return item.uuid;
         }
         return null;
     }
@@ -387,18 +414,23 @@ class RemoteFileSystem {
             const pathEx = relativePath.split("/");
             let builtPath = "/";
             for (const part of pathEx) {
-                if (pathEx.length <= 0) {
+                // Skip the empty segments produced by leading/duplicate slashes (e.g. "" from "/x/y").
+                if (part.length <= 0) {
                     continue;
                 }
                 builtPath = path_1.default.posix.join(builtPath, part);
                 if (!this.getDirectoryTreeCache.tree[builtPath]) {
                     const partBasename = path_1.default.posix.basename(builtPath);
                     const partParentPath = path_1.default.posix.dirname(builtPath);
+                    const parentIsBase = partParentPath === "/" || partParentPath === "." || partParentPath === "";
                     const parentItem = this.getDirectoryTreeCache.tree[partParentPath];
-                    if (!parentItem) {
+                    // The sync root is never a cache key, so when this level's parent IS the root we must fall
+                    // back to remoteParentUUID. Only bail when the parent is a non-root directory we cannot find
+                    // (a level we failed to build earlier) — checking parentIsBase BEFORE this guard is what lets
+                    // a directory whose parent is the root get created at all.
+                    if (!parentIsBase && !parentItem) {
                         continue;
                     }
-                    const parentIsBase = partParentPath === "/" || partParentPath === "." || partParentPath === "";
                     const parentUUID = parentIsBase ? this.sync.syncPair.remoteParentUUID : parentItem.uuid;
                     const uuid = await this.sync.sdk.cloud().createDirectory({
                         name: partBasename,
@@ -406,19 +438,21 @@ class RemoteFileSystem {
                         renameIfExists: true
                     });
                     await this.itemsMutex.acquire();
-                    this.getDirectoryTreeCache.tree[relativePath] = {
+                    // Store each intermediate directory under its OWN built path (not the final relativePath), so
+                    // the next iteration's parent lookup (tree[partParentPath]) resolves and the chain keeps building.
+                    this.getDirectoryTreeCache.tree[builtPath] = {
                         type: "directory",
                         uuid,
                         name: partBasename,
                         size: 0,
-                        path: relativePath
+                        path: builtPath
                     };
                     this.getDirectoryTreeCache.uuids[uuid] = {
                         type: "directory",
                         uuid,
                         name: partBasename,
                         size: 0,
-                        path: relativePath
+                        path: builtPath
                     };
                     this.itemsMutex.release();
                 }
@@ -532,18 +566,10 @@ class RemoteFileSystem {
             const newBasename = path_1.default.posix.basename(toRelativePath);
             const oldBasename = path_1.default.posix.basename(fromRelativePath);
             const itemMetadata = item.type === "file"
-                ? ({
-                    name: newBasename,
-                    size: item.size,
-                    mime: item.mime,
-                    lastModified: item.lastModified,
-                    creation: item.creation,
-                    hash: item.hash,
-                    key: item.key
-                })
-                : ({
+                ? Object.assign(Object.assign(Object.assign({ name: newBasename, size: item.size, mime: item.mime, lastModified: item.lastModified }, (item.creation !== undefined ? { creation: item.creation } : {})), (item.hash !== undefined ? { hash: item.hash } : {})), { key: item.key })
+                : {
                     name: newBasename
-                });
+                };
             if (newParentPath === currentParentPath) {
                 if (toRelativePath === "/" || newBasename.length <= 0) {
                     throw new Error("Invalid paths.");
@@ -659,10 +685,9 @@ class RemoteFileSystem {
      * @async
      * @param {{ relativePath: string }} param0
      * @param {string} param0.relativePath
-     * @returns {Promise<fs.Stats>}
+     * @returns {Promise<Stats>}
      */
     async download({ relativePath }) {
-        var _a;
         const localPath = path_1.default.posix.join(this.sync.syncPair.localPath, relativePath);
         const tmpLocalPath = path_1.default.join(this.sync.syncPair.localPath, constants_1.LOCAL_TRASH_NAME, (0, uuid_1.v4)());
         const signalKey = `download:${relativePath}`;
@@ -702,7 +727,7 @@ class RemoteFileSystem {
                 key: item.key,
                 size: item.size,
                 pauseSignal: this.sync.pauseSignals[signalKey],
-                abortSignal: (_a = this.sync.abortControllers[signalKey]) === null || _a === void 0 ? void 0 : _a.signal,
+                abortSignal: this.sync.abortControllers[signalKey].signal,
                 onError: err => {
                     this.sync.worker.logger.log("error", err, "filesystems.remote.download");
                     this.sync.worker.logger.log("error", err);
@@ -748,11 +773,25 @@ class RemoteFileSystem {
                     });
                 }
             });
-            await fs_extra_1.default.move(tmpLocalPath, localPath, {
+            // Integrity guard: only commit a download whose staged size matches the expected size. The SDK
+            // can RESOLVE (rather than reject) with an incomplete staged file when the transfer is aborted
+            // mid-stream — the read stream ends cleanly, so the pipeline reports no error even though fewer
+            // bytes were written. Without this check the partial/0-byte file would be moved into place and
+            // cached as "synced", leaving local and remote permanently diverged (it never re-downloads,
+            // because the cached size now matches the persisted base). Discarding it and throwing turns an
+            // aborted download into a normal failed task that the next cycle retries.
+            const stagedSize = (await this.sync.environment.fs.stat(tmpLocalPath)).size;
+            if (stagedSize !== item.size) {
+                await this.sync.environment.fs
+                    .rm(tmpLocalPath, { force: true, maxRetries: 60 * 10, recursive: true, retryDelay: 100 })
+                    .catch(() => { });
+                throw new Error(`Download of ${relativePath} is incomplete: expected ${item.size} bytes but staged ${stagedSize}.`);
+            }
+            await this.sync.environment.fs.move(tmpLocalPath, localPath, {
                 overwrite: true
             });
-            await fs_extra_1.default.utimes(localPath, new Date(), new Date((0, utils_1.convertTimestampToMs)(item.lastModified)));
-            const stats = await fs_extra_1.default.stat(localPath);
+            await this.sync.environment.fs.utimes(localPath, new Date(), new Date((0, utils_1.convertTimestampToMs)(item.lastModified)));
+            const stats = await this.sync.environment.fs.stat(localPath);
             const localItem = {
                 type: "file",
                 inode: stats.ino,
@@ -779,6 +818,13 @@ class RemoteFileSystem {
             return stats;
         }
         catch (e) {
+            // Best-effort: discard the staged temp file so a download that failed AFTER staging — a partial
+            // write, or a failure committing it into place — does not orphan it in the local trash directory.
+            // (force ignores an already-moved/never-created temp; the periodic trash sweep is only a delayed
+            // backstop, so reclaim the space immediately.)
+            await this.sync.environment.fs
+                .rm(tmpLocalPath, { force: true, maxRetries: 3, recursive: true, retryDelay: 100 })
+                .catch(() => { });
             this.sync.worker.logger.log("error", e, "filesystems.remote.download");
             this.sync.worker.logger.log("error", e);
             if (e instanceof Error) {
@@ -834,13 +880,21 @@ class RemoteFileSystem {
     async fileExists(relativePath) {
         try {
             const item = this.getDirectoryTreeCache.tree[relativePath];
-            const parent = this.getDirectoryTreeCache.tree[path_1.default.posix.dirname(relativePath)];
-            if (!item || !parent) {
+            if (!item) {
+                return false;
+            }
+            const parentPath = path_1.default.posix.dirname(relativePath);
+            // The sync root is never a cache key, so a top-level file's parent must resolve to remoteParentUUID.
+            // Looking up tree["/"] used to yield undefined and make this return false for EVERY top-level file —
+            // which silently swallowed a failed top-level rename/delete task (caller reads false as "vanished").
+            const parentIsBase = parentPath === "/" || parentPath === "." || parentPath === "";
+            const parent = parentIsBase ? undefined : this.getDirectoryTreeCache.tree[parentPath];
+            if (!parentIsBase && !parent) {
                 return false;
             }
             const { exists, uuid: existsUUID } = await this.sync.sdk.cloud().fileExists({
                 name: item.name,
-                parent: parent.uuid
+                parent: parentIsBase ? this.sync.syncPair.remoteParentUUID : parent.uuid
             });
             if (!exists || existsUUID !== item.uuid) {
                 return false;