pushwork 1.0.7 → 1.0.11

package/dist/core/sync-engine.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SyncEngine = void 0;
+const automerge_repo_1 = require("@automerge/automerge-repo");
 const A = __importStar(require("@automerge/automerge"));
 const types_1 = require("../types");
 const utils_1 = require("../utils");
@@ -44,13 +45,9 @@ const change_detection_1 = require("./change-detection");
 const move_detection_1 = require("./move-detection");
 const output_1 = require("../utils/output");
 /**
- * Post-sync delay constants for network propagation
- * These delays allow the WebSocket protocol to propagate peer changes after
- * our changes reach the server. waitForSync only ensures OUR changes reached
- * the server, not that we've RECEIVED changes from other peers.
- * TODO: remove need for this to exist.
+ * Sync configuration constants
  */
-const POST_SYNC_DELAY_MS = 200; // After we pushed changes
+const BIDIRECTIONAL_SYNC_TIMEOUT_MS = 5000; // Timeout for bidirectional sync stability check
 /**
  * Bidirectional sync engine implementing two-phase sync
  */
@@ -58,7 +55,9 @@ class SyncEngine {
     constructor(repo, rootPath, config) {
         this.repo = repo;
         this.rootPath = rootPath;
-        this.handlesToWaitOn = [];
+        // Map from path to handle for leaf-first sync ordering
+        // Path depth determines sync order (deepest first)
+        this.handlesByPath = new Map();
         this.config = config;
         this.snapshotManager = new snapshot_1.SnapshotManager(rootPath);
         this.changeDetector = new change_detection_1.ChangeDetector(repo, rootPath, config.exclude_patterns);
@@ -73,6 +72,15 @@ class SyncEngine {
         // Simply check the actual type of the content
         return typeof content === "string";
     }
+    /**
+     * Get a versioned URL from a handle (includes current heads).
+     * This ensures clients can fetch the exact version of the document.
+     */
+    getVersionedUrl(handle) {
+        const { documentId } = (0, automerge_repo_1.parseAutomergeUrl)(handle.url);
+        const heads = handle.heads();
+        return (0, automerge_repo_1.stringifyAutomergeUrl)({ documentId, heads });
+    }
     /**
      * Set the root directory URL in the snapshot
      */
@@ -111,6 +119,8 @@ class SyncEngine {
             result.directoriesChanged += commitResult.directoriesChanged;
             result.errors.push(...commitResult.errors);
             result.warnings.push(...commitResult.warnings);
+            // Update directory URLs with current heads after all children are populated
+            await this.updateDirectoryUrlsLeafFirst(snapshot);
             // Touch root directory if any changes were made
             const hasChanges = result.filesChanged > 0 || result.directoriesChanged > 0;
             if (hasChanges) {
@@ -144,12 +154,25 @@ class SyncEngine {
             warnings: [],
             timings: {},
         };
-        // Reset handles to wait on
-        this.handlesToWaitOn = [];
+        // Reset tracked handles for sync
+        this.handlesByPath = new Map();
         try {
             // Load current snapshot
             const snapshot = (await this.snapshotManager.load()) ||
                 this.snapshotManager.createEmpty();
+            // Wait for initial sync to receive any pending remote changes
+            if (this.config.sync_enabled && snapshot.rootDirectoryUrl) {
+                try {
+                    await (0, network_sync_1.waitForBidirectionalSync)(this.repo, snapshot.rootDirectoryUrl, this.config.sync_server_storage_id, {
+                        timeoutMs: 3000, // Short timeout for initial sync
+                        pollIntervalMs: 100,
+                        stableChecksRequired: 3,
+                    });
+                }
+                catch (error) {
+                    output_1.out.taskLine(`Initial sync: ${error}`, true);
+                }
+            }
             // Detect all changes
             const changes = await this.changeDetector.detectChanges(snapshot);
             // Detect moves
@@ -160,38 +183,38 @@ class SyncEngine {
             result.directoriesChanged += phase1Result.directoriesChanged;
             result.errors.push(...phase1Result.errors);
             result.warnings.push(...phase1Result.warnings);
-            // Always wait for network sync when enabled (not just when local changes exist)
-            // This is critical for clone scenarios where we need to pull remote changes
+            // Update directory URLs with current heads after all children are populated
+            await this.updateDirectoryUrlsLeafFirst(snapshot);
+            // Wait for network sync (important for clone scenarios)
             if (this.config.sync_enabled) {
                 try {
-                    // If we have a root directory URL, wait for it to sync
+                    // If we have a root directory URL, add it to tracked handles
                     if (snapshot.rootDirectoryUrl) {
                         const rootDirUrl = snapshot.rootDirectoryUrl;
                         const rootHandle = await this.repo.find(rootDirUrl);
-                        this.handlesToWaitOn.push(rootHandle);
+                        this.handlesByPath.set("", rootHandle);
                     }
-                    if (this.handlesToWaitOn.length > 0) {
-                        await (0, network_sync_1.waitForSync)(this.handlesToWaitOn, this.config.sync_server_storage_id);
-                        // CRITICAL: Wait a bit after our changes reach the server to allow
-                        // time for WebSocket to deliver OTHER peers' changes to us.
-                        // waitForSync only ensures OUR changes reached the server, not that
-                        // we've RECEIVED changes from other peers. This delay allows the
-                        // WebSocket protocol to propagate peer changes before we re-detect.
-                        // Without this, concurrent operations on different peers can miss
-                        // each other due to timing races.
-                        //
-                        // Optimization: Only wait if we pushed changes (shorter delay if no changes)
-                        await new Promise((resolve) => setTimeout(resolve, POST_SYNC_DELAY_MS));
+                    if (this.handlesByPath.size > 0) {
+                        // Sort handles leaf-first (deepest paths first, then shallower)
+                        const sortedHandles = this.sortHandlesLeafFirst();
+                        await (0, network_sync_1.waitForSync)(sortedHandles, this.config.sync_server_storage_id);
                     }
+                    // Wait for bidirectional sync to stabilize.
+                    // This polls document heads until they stop changing, which indicates
+                    // that both our outgoing changes and any incoming peer changes have
+                    // been received.
+                    await (0, network_sync_1.waitForBidirectionalSync)(this.repo, snapshot.rootDirectoryUrl, this.config.sync_server_storage_id, {
+                        timeoutMs: BIDIRECTIONAL_SYNC_TIMEOUT_MS,
+                        pollIntervalMs: 100,
+                        stableChecksRequired: 3,
+                    });
                 }
                 catch (error) {
                     output_1.out.taskLine(`Network sync failed: ${error}`, true);
                     result.warnings.push(`Network sync failed: ${error}`);
                 }
             }
-            // Re-detect remote changes after network sync to ensure fresh state
-            // This fixes race conditions where we detect changes before server propagation
-            // NOTE: We DON'T update snapshot heads yet - that would prevent detecting remote changes!
+            // Re-detect changes after network sync for fresh state
             const freshChanges = await this.changeDetector.detectChanges(snapshot);
             const freshRemoteChanges = freshChanges.filter((c) => c.changeType === types_1.ChangeType.REMOTE_ONLY ||
                 c.changeType === types_1.ChangeType.BOTH_CHANGED);
@@ -201,10 +224,7 @@ class SyncEngine {
             result.directoriesChanged += phase2Result.directoriesChanged;
             result.errors.push(...phase2Result.errors);
             result.warnings.push(...phase2Result.warnings);
-            // CRITICAL FIX: Update snapshot heads AFTER pulling remote changes
-            // This ensures that change detection can find remote changes, and we only
-            // update the snapshot after the filesystem is in sync with the documents
-            // Update file document heads
+            // Update snapshot heads after pulling remote changes
             for (const [filePath, snapshotEntry] of snapshot.files.entries()) {
                 try {
                     const handle = await this.repo.find(snapshotEntry.url);
@@ -340,8 +360,7 @@ class SyncEngine {
      */
     async applyLocalChangeToRemote(change, snapshot) {
         const snapshotEntry = snapshot.files.get(change.path);
-        // CRITICAL: Check for null explicitly, not falsy values
-        // Empty strings "" and empty Uint8Array are valid file content!
+        // Check for null (empty string/Uint8Array are valid content)
         if (change.localContent === null) {
             // File was deleted locally
             if (snapshotEntry) {
@@ -356,12 +375,12 @@ class SyncEngine {
             // New file
             const handle = await this.createRemoteFile(change);
             if (handle) {
-                await this.addFileToDirectory(snapshot, change.path, handle.url);
-                // CRITICAL FIX: Update snapshot with heads AFTER adding to directory
-                // The addFileToDirectory call above may have changed the document heads
+                // Use versioned URL (includes heads) so clients fetch correct version
+                const versionedUrl = this.getVersionedUrl(handle);
+                await this.addFileToDirectory(snapshot, change.path, versionedUrl);
                 this.snapshotManager.updateFileEntry(snapshot, change.path, {
                     path: (0, utils_1.joinAndNormalizePath)(this.rootPath, change.path),
-                    url: handle.url,
+                    url: versionedUrl,
                     head: handle.heads(),
                     extension: (0, utils_1.getFileExtension)(change.path),
                     mimeType: (0, utils_1.getEnhancedMimeType)(change.path),
@@ -381,8 +400,7 @@ class SyncEngine {
         if (!change.remoteHead) {
             throw new Error(`No remote head found for remote change to ${change.path}`);
         }
-        // CRITICAL: Check for null explicitly, not falsy values
-        // Empty strings "" and empty Uint8Array are valid file content!
+        // Check for null (empty string/Uint8Array are valid content)
         if (change.remoteContent === null) {
             // File was deleted remotely
             await (0, utils_1.removePath)(localPath);
@@ -404,9 +422,12 @@ class SyncEngine {
                 try {
                     const fileEntry = await (0, utils_1.findFileInDirectoryHierarchy)(this.repo, snapshot.rootDirectoryUrl, change.path);
                     if (fileEntry) {
+                        // Get versioned URL from handle (includes heads)
+                        const fileHandle = await this.repo.find(fileEntry.url);
+                        const versionedUrl = this.getVersionedUrl(fileHandle);
                         this.snapshotManager.updateFileEntry(snapshot, change.path, {
                             path: localPath,
-                            url: fileEntry.url,
+                            url: versionedUrl,
                             head: change.remoteHead,
                             extension: (0, utils_1.getFileExtension)(change.path),
                             mimeType: (0, utils_1.getEnhancedMimeType)(change.path),
@@ -435,12 +456,12 @@ class SyncEngine {
         if (move.fromPath !== move.toPath) {
             await this.removeFileFromDirectory(snapshot, move.fromPath);
         }
-        // 2) Ensure destination directory document exists and add file entry there
+        // 2) Ensure destination directory document exists
         await this.ensureDirectoryDocument(snapshot, toDirPath);
-        await this.addFileToDirectory(snapshot, move.toPath, fromEntry.url);
         // 3) Update the FileDocument name and content to match new location/state
         try {
-            const handle = await this.repo.find(fromEntry.url);
+            // Use plain URL for mutable handle
+            const handle = await this.repo.find((0, utils_1.getPlainUrl)(fromEntry.url));
             const heads = fromEntry.head;
             // Update both name and content (if content changed during move)
             if (heads && heads.length > 0) {
@@ -471,27 +492,30 @@ class SyncEngine {
                     }
                 });
             }
+            // Get versioned URL after changes (includes current heads)
+            const versionedUrl = this.getVersionedUrl(handle);
+            // 4) Add file entry to destination directory with versioned URL
+            await this.addFileToDirectory(snapshot, move.toPath, versionedUrl);
             // Track file handle for network sync
-            this.handlesToWaitOn.push(handle);
+            this.handlesByPath.set(move.toPath, handle);
+            // 5) Update snapshot entries
+            this.snapshotManager.removeFileEntry(snapshot, move.fromPath);
+            this.snapshotManager.updateFileEntry(snapshot, move.toPath, {
+                ...fromEntry,
+                path: (0, utils_1.joinAndNormalizePath)(this.rootPath, move.toPath),
+                url: versionedUrl,
+                head: handle.heads(),
+            });
         }
         catch (e) {
             // Failed to update file name - file may have been deleted
             output_1.out.taskLine(`Warning: Failed to rename ${move.fromPath} to ${move.toPath}`, true);
         }
-        // 4) Update snapshot entries
-        this.snapshotManager.removeFileEntry(snapshot, move.fromPath);
-        this.snapshotManager.updateFileEntry(snapshot, move.toPath, {
-            ...fromEntry,
-            path: (0, utils_1.joinAndNormalizePath)(this.rootPath, move.toPath),
-            head: fromEntry.head, // will be updated later when heads advance
-        });
     }
     /**
      * Create new remote file document
      */
     async createRemoteFile(change) {
-        // CRITICAL: Check for null explicitly, not falsy values
-        // Empty strings "" and empty Uint8Array are valid file content!
         if (change.localContent === null)
             return null;
         const isText = this.isTextContent(change.localContent);
@@ -519,20 +543,20 @@ class SyncEngine {
         }
         // Always track newly created files for network sync
         // (they always represent a change that needs to sync)
-        this.handlesToWaitOn.push(handle);
+        this.handlesByPath.set(change.path, handle);
         return handle;
     }
     /**
      * Update existing remote file document
      */
     async updateRemoteFile(url, content, snapshot, filePath) {
-        const handle = await this.repo.find(url);
+        // Use plain URL for mutable handle
+        const handle = await this.repo.find((0, utils_1.getPlainUrl)(url));
         // Check if content actually changed before tracking for sync
         const doc = await handle.doc();
         const currentContent = doc?.content;
         const contentChanged = !(0, content_1.isContentEqual)(content, currentContent);
-        // CRITICAL FIX: Always update snapshot heads, even when content is identical
-        // This prevents stale head issues that cause false change detection
+        // Update snapshot heads even when content is identical
         const snapshotEntry = snapshot.files.get(filePath);
         if (snapshotEntry) {
             // Update snapshot with current document heads
@@ -566,7 +590,7 @@ class SyncEngine {
             });
         }
         // Only track files that actually changed content
-        this.handlesToWaitOn.push(handle);
+        this.handlesByPath.set(filePath, handle);
     }
     /**
      * Delete remote file document
@@ -575,7 +599,8 @@ class SyncEngine {
         // In Automerge, we don't actually delete documents
         // They become orphaned and will be garbage collected
         // For now, we just mark them as deleted by clearing content
-        const handle = await this.repo.find(url);
+        // Use plain URL for mutable handle
+        const handle = await this.repo.find((0, utils_1.getPlainUrl)(url));
         // const doc = await handle.doc(); // no longer needed
         let heads;
         if (snapshot && filePath) {
@@ -603,7 +628,8 @@ class SyncEngine {
         const directoryPath = pathParts.join("/");
         // Get or create the parent directory document
         const parentDirUrl = await this.ensureDirectoryDocument(snapshot, directoryPath);
-        const dirHandle = await this.repo.find(parentDirUrl);
+        // Use plain URL for mutable handle
+        const dirHandle = await this.repo.find((0, utils_1.getPlainUrl)(parentDirUrl));
         let didChange = false;
         const snapshotEntry = snapshot.directories.get(directoryPath);
         const heads = snapshotEntry?.head;
@@ -633,13 +659,10 @@ class SyncEngine {
                 }
             });
         }
-        if (didChange) {
-            this.handlesToWaitOn.push(dirHandle);
-            // CRITICAL FIX: Update snapshot with new directory heads immediately
-            // This prevents stale head issues that cause convergence problems
-            if (snapshotEntry) {
-                snapshotEntry.head = dirHandle.heads();
-            }
+        // Always track the directory (even if unchanged) for proper leaf-first sync ordering
+        this.handlesByPath.set(directoryPath, dirHandle);
+        if (didChange && snapshotEntry) {
+            snapshotEntry.head = dirHandle.heads();
         }
     }
     /**
@@ -673,15 +696,19 @@ class SyncEngine {
                     // Directory entries in parent docs may not carry valid heads
                     try {
                         const childDirHandle = await this.repo.find(existingDirEntry.url);
-                        const childHeads = childDirHandle.heads();
-                        // Update snapshot with discovered directory using validated heads
+                        // Track discovered directory for sync
+                        this.handlesByPath.set(directoryPath, childDirHandle);
+                        // Get versioned URL for storage (includes current heads)
+                        const versionedUrl = this.getVersionedUrl(childDirHandle);
+                        // Update snapshot with discovered directory using versioned URL
                         this.snapshotManager.updateDirectoryEntry(snapshot, directoryPath, {
                             path: (0, utils_1.joinAndNormalizePath)(this.rootPath, directoryPath),
-                            url: existingDirEntry.url,
-                            head: childHeads,
+                            url: versionedUrl,
+                            head: childDirHandle.heads(),
                             entries: [],
                         });
-                        return existingDirEntry.url;
+                        // Return versioned URL (callers use getPlainUrl() when they need to modify)
+                        return versionedUrl;
                     }
                     catch (resolveErr) {
                         // Failed to resolve directory - fall through to create a fresh directory document
@@ -698,8 +725,11 @@ class SyncEngine {
             docs: [],
         };
         const dirHandle = this.repo.create(dirDoc);
+        // Get versioned URL for the new directory (includes heads)
+        const versionedDirUrl = this.getVersionedUrl(dirHandle);
         // Add this directory to its parent
-        const parentHandle = await this.repo.find(parentDirUrl);
+        // Use plain URL for mutable handle
+        const parentHandle = await this.repo.find((0, utils_1.getPlainUrl)(parentDirUrl));
         let didChange = false;
         parentHandle.change((doc) => {
             // Double-check that entry doesn't exist (race condition protection)
@@ -708,30 +738,29 @@ class SyncEngine {
                 doc.docs.push({
                     name: currentDirName,
                     type: "folder",
-                    url: dirHandle.url,
+                    url: versionedDirUrl,
                 });
                 didChange = true;
             }
         });
         // Track directory handles for sync
-        this.handlesToWaitOn.push(dirHandle);
+        this.handlesByPath.set(directoryPath, dirHandle);
         if (didChange) {
-            this.handlesToWaitOn.push(parentHandle);
-            // CRITICAL FIX: Update parent directory heads in snapshot immediately
-            // This prevents stale head issues when parent directory is modified
+            this.handlesByPath.set(parentPath, parentHandle);
             const parentSnapshotEntry = snapshot.directories.get(parentPath);
             if (parentSnapshotEntry) {
                 parentSnapshotEntry.head = parentHandle.heads();
             }
         }
-        // Update snapshot with new directory
+        // Update snapshot with new directory (use versioned URL for storage)
         this.snapshotManager.updateDirectoryEntry(snapshot, directoryPath, {
             path: (0, utils_1.joinAndNormalizePath)(this.rootPath, directoryPath),
-            url: dirHandle.url,
+            url: versionedDirUrl,
             head: dirHandle.heads(),
             entries: [],
         });
-        return dirHandle.url;
+        // Return versioned URL (callers use getPlainUrl() when they need to modify)
+        return versionedDirUrl;
     }
     /**
      * Remove file entry from directory document
@@ -756,9 +785,10 @@ class SyncEngine {
             parentDirUrl = existingDir.url;
         }
         try {
-            const dirHandle = await this.repo.find(parentDirUrl);
+            // Use plain URL for mutable handle
+            const dirHandle = await this.repo.find((0, utils_1.getPlainUrl)(parentDirUrl));
             // Track this handle for network sync waiting
-            this.handlesToWaitOn.push(dirHandle);
+            this.handlesByPath.set(directoryPath, dirHandle);
             const snapshotEntry = snapshot.directories.get(directoryPath);
             const heads = snapshotEntry?.head;
             let didChange = false;
@@ -782,14 +812,11 @@ class SyncEngine {
                     }
                 });
             }
-            // CRITICAL FIX: Update snapshot with new directory heads immediately
-            // This prevents stale head issues that cause convergence problems
             if (didChange && snapshotEntry) {
                 snapshotEntry.head = dirHandle.heads();
             }
         }
         catch (error) {
-            // Failed to remove from directory - re-throw for caller to handle
             throw error;
         }
     }
@@ -892,9 +919,7 @@ class SyncEngine {
                 });
             }
             // Track root directory for network sync
-            this.handlesToWaitOn.push(rootHandle);
-            // CRITICAL FIX: Update root directory heads in snapshot immediately
-            // This prevents stale head issues when root directory is modified
+            this.handlesByPath.set("", rootHandle);
             if (snapshotEntry) {
                 snapshotEntry.head = rootHandle.heads();
             }
@@ -903,6 +928,241 @@ class SyncEngine {
             // Failed to update root directory timestamp
         }
     }
+    /**
+     * Sort tracked handles leaf-first (deepest paths first).
+     * Returns handles in sorted order, logging URLs with heads for debugging.
+     */
+    sortHandlesLeafFirst() {
+        // Sort paths by depth (descending - deepest first), then alphabetically
+        const sortedPaths = Array.from(this.handlesByPath.keys()).sort((a, b) => {
+            const depthA = a ? a.split("/").length : 0;
+            const depthB = b ? b.split("/").length : 0;
+            // Deepest first
+            if (depthA !== depthB) {
+                return depthB - depthA;
+            }
+            // Alphabetically by path
+            return a.localeCompare(b);
+        });
+        // Log the sync order with versioned URLs for debugging (keep on complete)
+        const handles = [];
+        for (const path of sortedPaths) {
+            const handle = this.handlesByPath.get(path);
+            const versionedUrl = this.getVersionedUrl(handle);
+            output_1.out.taskLine(`Sync: ${path || "(root)"} -> ${versionedUrl}`, true);
+            handles.push(handle);
+        }
+        return handles;
+    }
+    /**
+     * Update all URLs (files and directories) in directory documents with current heads.
+     *
+     * This MUST be called AFTER all changes are applied but BEFORE network sync.
+     * The problem it solves:
+     * 1. When we create/update a file or directory and store its URL, the URL captures
+     *    the heads at that moment
+     * 2. Later operations may advance the document's heads
+     * 3. But the URL stored in the parent directory has stale heads
+     * 4. Clients reading the directory would get old views of entries
+     *
+     * The fix: walk leaf-first and update all entry URLs with current heads,
+     * AFTER all changes have been applied. This ensures clients get consistent,
+     * up-to-date versioned URLs.
+     */
+    async updateDirectoryUrlsLeafFirst(snapshot) {
+        // First, update file URLs in their parent directories
+        await this.updateFileUrlsInDirectories(snapshot);
+        // Then, update directory URLs in their parent directories (leaf-first)
+        await this.updateSubdirectoryUrls(snapshot);
+    }
+    /**
+     * Update file URLs in directory documents with current heads.
+     */
+    async updateFileUrlsInDirectories(snapshot) {
+        // Group files by their parent directory
+        const filesByDir = new Map();
+        for (const filePath of snapshot.files.keys()) {
+            const pathParts = filePath.split("/");
+            pathParts.pop(); // Remove filename
+            const dirPath = pathParts.join("/");
+            if (!filesByDir.has(dirPath)) {
+                filesByDir.set(dirPath, []);
+            }
+            filesByDir.get(dirPath).push(filePath);
+        }
+        // Process each directory that has files
+        for (const [dirPath, filePaths] of filesByDir.entries()) {
+            try {
+                // Get the directory URL
+                let dirUrl;
+                if (!dirPath || dirPath === "") {
+                    if (!snapshot.rootDirectoryUrl)
+                        continue;
+                    dirUrl = snapshot.rootDirectoryUrl;
+                }
+                else {
+                    const dirEntry = snapshot.directories.get(dirPath);
+                    if (!dirEntry)
+                        continue;
+                    dirUrl = dirEntry.url;
+                }
+                // Get directory handle
+                const dirHandle = await this.repo.find((0, utils_1.getPlainUrl)(dirUrl));
+                // Get current heads for changeAt
+                const snapshotEntry = snapshot.directories.get(dirPath);
+                const heads = snapshotEntry?.head;
+                // Build a map of file names to their current versioned URLs
+                const fileUrlUpdates = new Map();
+                for (const filePath of filePaths) {
+                    const fileEntry = snapshot.files.get(filePath);
+                    if (!fileEntry)
+                        continue;
+                    // Get current handle for this file
+                    const fileHandle = await this.repo.find((0, utils_1.getPlainUrl)(fileEntry.url));
+                    // Get versioned URL with current heads
+                    const currentVersionedUrl = this.getVersionedUrl(fileHandle);
+                    // Update snapshot entry
+                    snapshot.files.set(filePath, {
+                        ...fileEntry,
+                        url: currentVersionedUrl,
+                        head: fileHandle.heads(),
+                    });
+                    // Store for directory update
+                    const fileName = filePath.split("/").pop() || "";
+                    fileUrlUpdates.set(fileName, currentVersionedUrl);
+                }
+                // Update all file entries in the directory document
+                let didChange = false;
+                if (heads) {
+                    dirHandle.changeAt(heads, (doc) => {
+                        for (const [fileName, newUrl] of fileUrlUpdates) {
+                            const existingIndex = doc.docs.findIndex((entry) => entry.name === fileName && entry.type === "file");
+                            if (existingIndex !== -1 && doc.docs[existingIndex].url !== newUrl) {
+                                doc.docs[existingIndex].url = newUrl;
+                                didChange = true;
+                            }
+                        }
+                    });
+                }
+                else {
+                    dirHandle.change((doc) => {
+                        for (const [fileName, newUrl] of fileUrlUpdates) {
+                            const existingIndex = doc.docs.findIndex((entry) => entry.name === fileName && entry.type === "file");
+                            if (existingIndex !== -1 && doc.docs[existingIndex].url !== newUrl) {
+                                doc.docs[existingIndex].url = newUrl;
+                                didChange = true;
+                            }
+                        }
+                    });
+                }
+                // Track directory and update heads
+                if (didChange) {
+                    this.handlesByPath.set(dirPath, dirHandle);
+                    if (snapshotEntry) {
+                        snapshotEntry.head = dirHandle.heads();
+                    }
+                }
+            }
+            catch (error) {
+                output_1.out.taskLine(`Warning: Failed to update file URLs in directory ${dirPath}`, true);
+            }
+        }
+    }
+    /**
+     * Update subdirectory URLs in parent directories with current heads.
+     * Processes leaf-first (deepest directories first).
+     */
+    async updateSubdirectoryUrls(snapshot) {
+        // Get all directory paths and sort leaf-first (deepest first)
+        const directoryPaths = Array.from(snapshot.directories.keys()).sort((a, b) => {
+            const depthA = a ? a.split("/").length : 0;
+            const depthB = b ? b.split("/").length : 0;
+            // Deepest first
+            if (depthA !== depthB) {
+                return depthB - depthA;
+            }
+            // Alphabetically by path
+            return a.localeCompare(b);
+        });
+        // Update each directory's URL in its parent
+        for (const dirPath of directoryPaths) {
+            // Skip root directory (has no parent)
+            if (!dirPath || dirPath === "") {
+                continue;
+            }
+            const dirEntry = snapshot.directories.get(dirPath);
+            if (!dirEntry)
+                continue;
+            try {
+                // Get current handle for this directory (use plain URL to get mutable handle)
+                const dirHandle = await this.repo.find((0, utils_1.getPlainUrl)(dirEntry.url));
+                // Get versioned URL with CURRENT heads (after all children populated)
+                const currentVersionedUrl = this.getVersionedUrl(dirHandle);
+                // Update snapshot entry with current heads and versioned URL
+                snapshot.directories.set(dirPath, {
+                    ...dirEntry,
+                    url: currentVersionedUrl,
+                    head: dirHandle.heads(),
+                });
+                // Get parent path
+                const pathParts = dirPath.split("/");
+                const dirName = pathParts.pop() || "";
+                const parentPath = pathParts.join("/");
+                // Get parent directory handle
+                let parentDirUrl;
+                if (!parentPath || parentPath === "") {
+                    // Parent is root
+                    if (!snapshot.rootDirectoryUrl)
+                        continue;
+                    parentDirUrl = snapshot.rootDirectoryUrl;
+                }
+                else {
+                    const parentEntry = snapshot.directories.get(parentPath);
+                    if (!parentEntry)
+                        continue;
+                    parentDirUrl = parentEntry.url;
+                }
+                // Update the directory entry in the parent with the new versioned URL
+                const parentHandle = await this.repo.find((0, utils_1.getPlainUrl)(parentDirUrl));
+                // Get parent's current heads for changeAt
+                const parentSnapshotEntry = parentPath === ""
+                    ? snapshot.directories.get("")
+                    : snapshot.directories.get(parentPath);
+                const parentHeads = parentSnapshotEntry?.head;
+                let didChange = false;
+                if (parentHeads) {
+                    parentHandle.changeAt(parentHeads, (doc) => {
+                        const existingIndex = doc.docs.findIndex((entry) => entry.name === dirName && entry.type === "folder");
+                        if (existingIndex !== -1) {
+                            // Update the URL with current versioned URL
+                            doc.docs[existingIndex].url = currentVersionedUrl;
+                            didChange = true;
+                        }
+                    });
+                }
+                else {
+                    parentHandle.change((doc) => {
+                        const existingIndex = doc.docs.findIndex((entry) => entry.name === dirName && entry.type === "folder");
+                        if (existingIndex !== -1) {
+                            // Update the URL with current versioned URL
+                            doc.docs[existingIndex].url = currentVersionedUrl;
+                            didChange = true;
+                        }
+                    });
+                }
+                // Track parent for sync and update its heads in snapshot
+                if (didChange) {
+                    this.handlesByPath.set(parentPath, parentHandle);
+                    if (parentSnapshotEntry) {
+                        parentSnapshotEntry.head = parentHandle.heads();
+                    }
+                }
+            }
+            catch (error) {
+                output_1.out.taskLine(`Warning: Failed to update directory URL for ${dirPath}`, true);
+            }
+        }
+    }
 }
 exports.SyncEngine = SyncEngine;
 //# sourceMappingURL=sync-engine.js.map