pushwork 1.1.4 → 2.0.0-a.sub.1

package/dist/core/sync-engine.js

@@ -1,50 +1,14 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-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");
-const content_1 = require("../utils/content");
-const network_sync_1 = require("../utils/network-sync");
-const snapshot_1 = require("./snapshot");
-const change_detection_1 = require("./change-detection");
-const move_detection_1 = require("./move-detection");
-const output_1 = require("../utils/output");
-const path = __importStar(require("path"));
+import { parseAutomergeUrl, stringifyAutomergeUrl, } from "@automerge/automerge-repo";
+import * as A from "@automerge/automerge";
+import { ChangeType, FileType, } from "../types/index.js";
+import { writeFileContent, removePath, getFileExtension, getEnhancedMimeType, formatRelativePath, findFileInDirectoryHierarchy, joinAndNormalizePath, getPlainUrl, updateTextContent, readDocContent, } from "../utils/index.js";
+import { isContentEqual, contentHash } from "../utils/content.js";
+import { waitForSync, waitForBidirectionalSync } from "../utils/network-sync.js";
+import { SnapshotManager } from "./snapshot.js";
+import { ChangeDetector } from "./change-detection.js";
+import { MoveDetector } from "./move-detection.js";
+import { out } from "../utils/output.js";
+import * as path from "path";
 const isDebug = !!process.env.DEBUG;
 function debug(...args) {
     if (isDebug)
@@ -69,7 +33,7 @@ const BIDIRECTIONAL_SYNC_TIMEOUT_MS = 5000; // Timeout for bidirectional sync st
 /**
  * Bidirectional sync engine implementing two-phase sync
  */
-class SyncEngine {
+export class SyncEngine {
     constructor(repo, rootPath, config) {
         this.repo = repo;
         this.rootPath = rootPath;
@@ -77,9 +41,9 @@ class SyncEngine {
         // 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, config.artifact_directories || []);
-        this.moveDetector = new move_detection_1.MoveDetector(config.sync.move_detection_threshold);
+        this.snapshotManager = new SnapshotManager(rootPath);
+        this.changeDetector = new ChangeDetector(repo, rootPath, config.exclude_patterns, config.artifact_directories || []);
+        this.moveDetector = new MoveDetector(config.sync.move_detection_threshold);
     }
     /**
      * Determine if content should be treated as text for Automerge text operations
@@ -95,9 +59,9 @@ class SyncEngine {
      * This ensures clients can fetch the exact version of the document.
      */
     getVersionedUrl(handle) {
-        const { documentId } = (0, automerge_repo_1.parseAutomergeUrl)(handle.url);
+        const { documentId } = parseAutomergeUrl(handle.url);
         const heads = handle.heads();
-        return (0, automerge_repo_1.stringifyAutomergeUrl)({ documentId, heads });
+        return stringifyAutomergeUrl({ documentId, heads });
     }
     /**
      * Determine if a file path is inside an artifact directory.
@@ -109,7 +73,7 @@ class SyncEngine {
         return artifactDirs.some(dir => filePath === dir || filePath.startsWith(dir + "/"));
     }
     /**
-     * Get the appropriate URL for a directory entry.
+     * Get the appropriate URL for a file's directory entry.
      * Artifact paths get versioned URLs (with heads) for exact version fetching.
      * Non-artifact paths get plain URLs for collaborative editing.
      */
@@ -117,7 +81,15 @@ class SyncEngine {
         if (this.isArtifactPath(filePath)) {
             return this.getVersionedUrl(handle);
         }
-        return (0, utils_1.getPlainUrl)(handle.url);
+        return getPlainUrl(handle.url);
+    }
+    /**
+     * Get the appropriate URL for a subdirectory's directory entry.
+     * Always uses plain URLs — versioned URLs on directories can cause
+     * issues where consumers see a version without the docs array.
+     */
+    getDirEntryUrl(handle) {
+        return getPlainUrl(handle.url);
     }
     /**
      * Set the root directory URL in the snapshot
@@ -153,7 +125,7 @@ class SyncEngine {
             return;
         // Clear the root directory document's entries
         if (snapshot.rootDirectoryUrl) {
-            const rootHandle = await this.repo.find((0, utils_1.getPlainUrl)(snapshot.rootDirectoryUrl));
+            const rootHandle = await this.repo.find(getPlainUrl(snapshot.rootDirectoryUrl));
             rootHandle.change((doc) => {
                 doc.docs.splice(0, doc.docs.length);
             });
@@ -189,11 +161,8 @@ class SyncEngine {
             result.directoriesChanged += commitResult.directoriesChanged;
             result.errors.push(...commitResult.errors);
             result.warnings.push(...commitResult.warnings);
-            // Touch root directory if any changes were made
-            const hasChanges = result.filesChanged > 0 || result.directoriesChanged > 0;
-            if (hasChanges) {
-                await this.touchRootDirectory(snapshot);
-            }
+            // Always touch root directory after commit
+            await this.touchRootDirectory(snapshot);
             // Save updated snapshot
             await this.snapshotManager.save(snapshot);
             result.success = result.errors.length === 0;
@@ -216,15 +185,15 @@ class SyncEngine {
      * Returns new handles that should be retried for sync.
      */
     async recreateFailedDocuments(failedHandles, snapshot) {
-        const failedUrls = new Set(failedHandles.map(h => (0, utils_1.getPlainUrl)(h.url)));
+        const failedUrls = new Set(failedHandles.map(h => getPlainUrl(h.url)));
         const newHandles = [];
         // Find which paths correspond to the failed handles
         for (const [filePath, entry] of snapshot.files.entries()) {
-            const plainUrl = (0, utils_1.getPlainUrl)(entry.url);
+            const plainUrl = getPlainUrl(entry.url);
             if (!failedUrls.has(plainUrl))
                 continue;
             debug(`recreate: recreating document for ${filePath} (${plainUrl})`);
-            output_1.out.taskLine(`Recreating document for ${filePath}`);
+            out.taskLine(`Recreating document for ${filePath}`);
             try {
                 // Read the current content from the old handle
                 const oldHandle = await this.repo.find(plainUrl);
@@ -233,7 +202,7 @@ class SyncEngine {
                     debug(`recreate: could not read doc for ${filePath}, skipping`);
                     continue;
                 }
-                const content = (0, utils_1.readDocContent)(doc.content);
+                const content = readDocContent(doc.content);
                 if (content === null) {
                     debug(`recreate: null content for ${filePath}, skipping`);
                     continue;
@@ -241,8 +210,8 @@ class SyncEngine {
                 // Create a fresh document
                 const fakeChange = {
                     path: filePath,
-                    changeType: types_1.ChangeType.LOCAL_ONLY,
-                    fileType: this.isTextContent(content) ? types_1.FileType.TEXT : types_1.FileType.BINARY,
+                    changeType: ChangeType.LOCAL_ONLY,
+                    fileType: this.isTextContent(content) ? FileType.TEXT : FileType.BINARY,
                     localContent: content,
                     remoteContent: null,
                 };
@@ -255,7 +224,7 @@ class SyncEngine {
                     ...entry,
                     url: entryUrl,
                     head: newHandle.heads(),
-                    ...(this.isArtifactPath(filePath) ? { contentHash: (0, content_1.contentHash)(content) } : {}),
+                    ...(this.isArtifactPath(filePath) ? { contentHash: contentHash(content) } : {}),
                 });
                 // Update parent directory entry to point to new document
                 const pathParts = filePath.split("/");
@@ -271,7 +240,7 @@ class SyncEngine {
                         continue;
                     dirUrl = dirEntry.url;
                 }
-                const dirHandle = await this.repo.find((0, utils_1.getPlainUrl)(dirUrl));
+                const dirHandle = await this.repo.find(getPlainUrl(dirUrl));
                 dirHandle.change((d) => {
                     const idx = d.docs.findIndex(e => e.name === fileName && e.type === "file");
                     if (idx !== -1) {
@@ -287,18 +256,18 @@ class SyncEngine {
             }
             catch (error) {
                 debug(`recreate: failed for ${filePath}: ${error}`);
-                output_1.out.taskLine(`Failed to recreate ${filePath}: ${error}`, true);
+                out.taskLine(`Failed to recreate ${filePath}: ${error}`, true);
             }
         }
         // Also check directory documents
         for (const [dirPath, entry] of snapshot.directories.entries()) {
-            const plainUrl = (0, utils_1.getPlainUrl)(entry.url);
+            const plainUrl = getPlainUrl(entry.url);
             if (!failedUrls.has(plainUrl))
                 continue;
             // Directory docs can't be easily recreated (they reference children).
             // Just log a warning — the child recreation above should handle most cases.
             debug(`recreate: directory ${dirPath || "(root)"} failed to sync, cannot recreate`);
-            output_1.out.taskLine(`Warning: directory ${dirPath || "(root)"} failed to sync`, true);
+            out.taskLine(`Warning: directory ${dirPath || "(root)"} failed to sync`, true);
         }
         return newHandles;
     }
@@ -324,12 +293,12 @@ class SyncEngine {
             // Wait for initial sync to receive any pending remote changes
             if (this.config.sync_enabled && snapshot.rootDirectoryUrl) {
                 debug("sync: waiting for root document to be ready");
-                output_1.out.update("Waiting for root document from server");
+                out.update("Waiting for root document from server");
                 // Wait for the root document to be fetched from the network.
                 // repo.find() rejects with "unavailable" if the server doesn't
                 // have the document yet, so we retry with backoff.
                 // This is critical for clone scenarios.
-                const plainRootUrl = (0, utils_1.getPlainUrl)(snapshot.rootDirectoryUrl);
+                const plainRootUrl = getPlainUrl(snapshot.rootDirectoryUrl);
                 const maxAttempts = 6;
                 for (let attempt = 1; attempt <= maxAttempts; attempt++) {
                     try {
@@ -343,32 +312,32 @@ class SyncEngine {
                         if (isUnavailable && attempt < maxAttempts) {
                             const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000);
                             debug(`sync: root document not available (attempt ${attempt}/${maxAttempts}), retrying in ${delay}ms`);
-                            output_1.out.update(`Waiting for root document (attempt ${attempt}/${maxAttempts})`);
+                            out.update(`Waiting for root document (attempt ${attempt}/${maxAttempts})`);
                             await new Promise(r => setTimeout(r, delay));
                         }
                         else {
                             debug(`sync: root document unavailable after ${maxAttempts} attempts: ${error}`);
-                            output_1.out.taskLine(`Root document unavailable: ${error}`, true);
+                            out.taskLine(`Root document unavailable: ${error}`, true);
                             break;
                         }
                     }
                 }
                 debug("sync: waiting for initial bidirectional sync");
-                output_1.out.update("Waiting for initial sync from server");
+                out.update("Waiting for initial sync from server");
                 try {
-                    await (0, network_sync_1.waitForBidirectionalSync)(this.repo, snapshot.rootDirectoryUrl, this.config.sync_server_storage_id, {
+                    await waitForBidirectionalSync(this.repo, snapshot.rootDirectoryUrl, {
                         timeoutMs: 5000, // Increased timeout for initial sync
                         pollIntervalMs: 100,
                         stableChecksRequired: 3,
                     });
                 }
                 catch (error) {
-                    output_1.out.taskLine(`Initial sync: ${error}`, true);
+                    out.taskLine(`Initial sync: ${error}`, true);
                 }
             }
             // Detect all changes
             debug("sync: detecting changes");
-            output_1.out.update("Detecting local and remote changes");
+            out.update("Detecting local and remote changes");
             // Capture pre-push snapshot file paths to detect deletions after push
             const prePushFilePaths = new Set(snapshot.files.keys());
             const changes = await this.changeDetector.detectChanges(snapshot);
@@ -396,17 +365,17 @@ class SyncEngine {
                         const allHandles = Array.from(this.handlesByPath.values());
                         const handlePaths = Array.from(this.handlesByPath.keys());
                         debug(`sync: waiting for ${allHandles.length} handles to sync to server: ${handlePaths.slice(0, 10).map(p => p || "(root)").join(", ")}${handlePaths.length > 10 ? ` ...and ${handlePaths.length - 10} more` : ""}`);
-                        output_1.out.update(`Uploading ${allHandles.length} documents to sync server`);
-                        const { failed } = await (0, network_sync_1.waitForSync)(allHandles, this.config.sync_server_storage_id);
+                        out.update(`Uploading ${allHandles.length} documents to sync server`);
+                        const { failed } = await waitForSync(allHandles);
                         // Recreate failed documents and retry once
                         if (failed.length > 0) {
                             debug(`sync: ${failed.length} documents failed, recreating`);
-                            output_1.out.update(`Recreating ${failed.length} failed documents`);
+                            out.update(`Recreating ${failed.length} failed documents`);
                             const retryHandles = await this.recreateFailedDocuments(failed, snapshot);
                             if (retryHandles.length > 0) {
                                 debug(`sync: retrying ${retryHandles.length} recreated handles`);
-                                output_1.out.update(`Retrying ${retryHandles.length} recreated documents`);
-                                const retry = await (0, network_sync_1.waitForSync)(retryHandles, this.config.sync_server_storage_id);
+                                out.update(`Retrying ${retryHandles.length} recreated documents`);
+                                const retry = await waitForSync(retryHandles);
                                 if (retry.failed.length > 0) {
                                     const msg = `${retry.failed.length} documents failed to sync to server after recreation`;
                                     debug(`sync: ${msg}`);
@@ -425,29 +394,18 @@ class SyncEngine {
                     // Use tracked handles for post-push check (cheaper than full tree scan)
                     const changedHandles = Array.from(this.handlesByPath.values());
                     debug(`sync: waiting for bidirectional sync to stabilize (${changedHandles.length} tracked handles)`);
-                    output_1.out.update("Waiting for bidirectional sync to stabilize");
-                    await (0, network_sync_1.waitForBidirectionalSync)(this.repo, snapshot.rootDirectoryUrl, this.config.sync_server_storage_id, {
+                    out.update("Waiting for bidirectional sync to stabilize");
+                    await waitForBidirectionalSync(this.repo, snapshot.rootDirectoryUrl, {
                         timeoutMs: BIDIRECTIONAL_SYNC_TIMEOUT_MS,
                         pollIntervalMs: 100,
                         stableChecksRequired: 3,
                         handles: changedHandles.length > 0 ? changedHandles : undefined,
                     });
-                    // Touch root directory AFTER all docs are synced and stable.
-                    // This signals consumers (e.g. Patchwork) that new content is
-                    // available. Because file docs are already on the server,
-                    // consumers can immediately fetch them when they see the root change.
-                    const hasPhase1Changes = phase1Result.filesChanged > 0 || phase1Result.directoriesChanged > 0;
-                    if (hasPhase1Changes && snapshot.rootDirectoryUrl) {
-                        await this.touchRootDirectory(snapshot);
-                        const rootHandle = await this.repo.find(snapshot.rootDirectoryUrl);
-                        debug("sync: syncing root directory touch to server");
-                        output_1.out.update("Syncing root directory update");
-                        await (0, network_sync_1.waitForSync)([rootHandle], this.config.sync_server_storage_id);
-                    }
+                    // Root directory touch + sync moved to end of sync() so it always runs
                 }
                 catch (error) {
                     debug(`sync: network sync error: ${error}`);
-                    output_1.out.taskLine(`Network sync failed: ${error}`, true);
+                    out.taskLine(`Network sync failed: ${error}`, true);
                     result.errors.push({
                         path: "sync",
                         operation: "network-sync",
@@ -469,11 +427,11 @@ class SyncEngine {
             }
             debug("sync: re-detecting changes after network sync");
             const freshChanges = await this.changeDetector.detectChanges(snapshot, deletedPaths);
-            const freshRemoteChanges = freshChanges.filter(c => c.changeType === types_1.ChangeType.REMOTE_ONLY ||
-                c.changeType === types_1.ChangeType.BOTH_CHANGED);
+            const freshRemoteChanges = freshChanges.filter(c => c.changeType === ChangeType.REMOTE_ONLY ||
+                c.changeType === ChangeType.BOTH_CHANGED);
             debug(`sync: phase 2 - pulling ${freshRemoteChanges.length} remote changes`);
             if (freshRemoteChanges.length > 0) {
-                output_1.out.update(`Pulling ${freshRemoteChanges.length} remote changes`);
+                out.update(`Pulling ${freshRemoteChanges.length} remote changes`);
             }
             // Phase 2: Pull remote changes to local using fresh detection
             const phase2Result = await this.pullRemoteChanges(freshRemoteChanges, snapshot);
@@ -492,7 +450,7 @@ class SyncEngine {
             // can't find the entries to splice out).
             for (const [filePath, snapshotEntry] of snapshot.files.entries()) {
                 try {
-                    const handle = await this.repo.find((0, utils_1.getPlainUrl)(snapshotEntry.url));
+                    const handle = await this.repo.find(getPlainUrl(snapshotEntry.url));
                     const currentHeads = handle.heads();
                     if (!A.equals(currentHeads, snapshotEntry.head)) {
                         // Update snapshot with current heads after pulling changes
@@ -509,7 +467,7 @@ class SyncEngine {
             // Update directory document heads
             for (const [dirPath, snapshotEntry] of snapshot.directories.entries()) {
                 try {
-                    const handle = await this.repo.find((0, utils_1.getPlainUrl)(snapshotEntry.url));
+                    const handle = await this.repo.find(getPlainUrl(snapshotEntry.url));
                     const currentHeads = handle.heads();
                     if (!A.equals(currentHeads, snapshotEntry.head)) {
                         // Update snapshot with current heads after pulling changes
@@ -523,7 +481,40 @@ class SyncEngine {
                     // Handle might not exist if directory was deleted
                 }
             }
-            // Save updated snapshot if not dry run
+            // Small pause before touching root to let everything settle
+            await new Promise(r => setTimeout(r, 100));
+            // Always touch root directory after sync completes
+            await this.touchRootDirectory(snapshot);
+            if (this.config.sync_enabled && snapshot.rootDirectoryUrl) {
+                const rootHandle = await this.repo.find(snapshot.rootDirectoryUrl);
+                debug("sync: syncing root directory touch to server");
+                out.update("Syncing root directory update");
+                await waitForSync([rootHandle]);
+                // Wait for the touch to fully stabilize on the server
+                debug("sync: waiting for root touch to stabilize");
+                await waitForBidirectionalSync(this.repo, snapshot.rootDirectoryUrl, {
+                    timeoutMs: 5000,
+                    pollIntervalMs: 100,
+                    stableChecksRequired: 3,
+                    handles: [rootHandle],
+                });
+                // Flush repo to ensure everything is persisted
+                await this.repo.flush();
+                // Small grace period to ensure server has flushed
+                await new Promise(r => setTimeout(r, 100));
+            }
+            // Update root directory snapshot heads after touch
+            const rootSnapshotEntry = snapshot.directories.get("");
+            if (rootSnapshotEntry && snapshot.rootDirectoryUrl) {
+                try {
+                    const rootHandle = await this.repo.find(getPlainUrl(snapshot.rootDirectoryUrl));
+                    rootSnapshotEntry.head = rootHandle.heads();
+                }
+                catch (error) {
+                    debug(`sync: failed to update root snapshot heads after touch: ${error}`);
+                }
+            }
+            // Save updated snapshot
             await this.snapshotManager.save(snapshot);
             result.success = result.errors.length === 0;
             return result;
@@ -557,13 +548,13 @@ class SyncEngine {
         // Process moves first - all detected moves are applied
         if (moves.length > 0) {
             debug(`push: processing ${moves.length} moves`);
-            output_1.out.update(`Processing ${moves.length} move${moves.length > 1 ? "s" : ""}`);
+            out.update(`Processing ${moves.length} move${moves.length > 1 ? "s" : ""}`);
         }
         for (let i = 0; i < moves.length; i++) {
             const move = moves[i];
             try {
                 debug(`push: move ${i + 1}/${moves.length}: ${move.fromPath} -> ${move.toPath}`);
-                output_1.out.taskLine(`Moving ${move.fromPath} -> ${move.toPath}`);
+                out.taskLine(`Moving ${move.fromPath} -> ${move.toPath}`);
                 await this.applyMoveToRemote(move, snapshot);
                 result.filesChanged++;
             }
@@ -578,8 +569,8 @@ class SyncEngine {
             }
         }
         // Filter to local changes only
-        const localChanges = changes.filter(c => c.changeType === types_1.ChangeType.LOCAL_ONLY ||
-            c.changeType === types_1.ChangeType.BOTH_CHANGED);
+        const localChanges = changes.filter(c => c.changeType === ChangeType.LOCAL_ONLY ||
+            c.changeType === ChangeType.BOTH_CHANGED);
         if (localChanges.length === 0) {
             debug("push: no local changes to push");
             return result;
@@ -588,7 +579,7 @@ class SyncEngine {
         const modifiedFiles = localChanges.filter(c => snapshot.files.has(c.path) && c.localContent !== null);
         const deletedFiles = localChanges.filter(c => c.localContent === null && snapshot.files.has(c.path));
         debug(`push: ${localChanges.length} local changes (${newFiles.length} new, ${modifiedFiles.length} modified, ${deletedFiles.length} deleted)`);
-        output_1.out.update(`Pushing ${localChanges.length} local changes (${newFiles.length} new, ${modifiedFiles.length} modified, ${deletedFiles.length} deleted)`);
+        out.update(`Pushing ${localChanges.length} local changes (${newFiles.length} new, ${modifiedFiles.length} modified, ${deletedFiles.length} deleted)`);
         // Group changes by parent directory path
         const changesByDir = new Map();
         for (const change of localChanges) {
@@ -647,7 +638,7 @@ class SyncEngine {
                     if (change.localContent === null && snapshotEntry) {
                         // Delete file
                         debug(`push: [${filesProcessed}/${totalFiles}] delete ${change.path}`);
-                        output_1.out.update(`Pushing local changes [${filesProcessed}/${totalFiles}] deleting ${change.path}`);
+                        out.update(`Pushing local changes [${filesProcessed}/${totalFiles}] deleting ${change.path}`);
                         await this.deleteRemoteFile(snapshotEntry.url, snapshot, change.path);
                         deletedNames.push(fileName);
                         this.snapshotManager.removeFileEntry(snapshot, change.path);
@@ -656,19 +647,19 @@ class SyncEngine {
                     else if (!snapshotEntry) {
                         // New file
                         debug(`push: [${filesProcessed}/${totalFiles}] create ${change.path} (${change.fileType})`);
-                        output_1.out.update(`Pushing local changes [${filesProcessed}/${totalFiles}] creating ${change.path}`);
+                        out.update(`Pushing local changes [${filesProcessed}/${totalFiles}] creating ${change.path}`);
                         const handle = await this.createRemoteFile(change);
                         if (handle) {
                             const entryUrl = this.getEntryUrl(handle, change.path);
                             newEntries.push({ name: fileName, url: entryUrl });
                             this.snapshotManager.updateFileEntry(snapshot, change.path, {
-                                path: (0, utils_1.joinAndNormalizePath)(this.rootPath, change.path),
+                                path: joinAndNormalizePath(this.rootPath, change.path),
                                 url: entryUrl,
                                 head: handle.heads(),
-                                extension: (0, utils_1.getFileExtension)(change.path),
-                                mimeType: (0, utils_1.getEnhancedMimeType)(change.path),
+                                extension: getFileExtension(change.path),
+                                mimeType: getEnhancedMimeType(change.path),
                                 ...(this.isArtifactPath(change.path) && change.localContent
-                                    ? { contentHash: (0, content_1.contentHash)(change.localContent) }
+                                    ? { contentHash: contentHash(change.localContent) }
                                     : {}),
                             });
                             result.filesChanged++;
@@ -681,12 +672,12 @@ class SyncEngine {
                             ? `${change.localContent.length} chars`
                             : `${change.localContent.length} bytes`;
                         debug(`push: [${filesProcessed}/${totalFiles}] update ${change.path} (${contentSize})`);
-                        output_1.out.update(`Pushing local changes [${filesProcessed}/${totalFiles}] updating ${change.path}`);
+                        out.update(`Pushing local changes [${filesProcessed}/${totalFiles}] updating ${change.path}`);
                         await this.updateRemoteFile(snapshotEntry.url, change.localContent, snapshot, change.path);
                         // Get current entry URL (updateRemoteFile updates snapshot)
                         const updatedFileEntry = snapshot.files.get(change.path);
                         if (updatedFileEntry) {
-                            const fileHandle = await this.repo.find((0, utils_1.getPlainUrl)(updatedFileEntry.url));
+                            const fileHandle = await this.repo.find(getPlainUrl(updatedFileEntry.url));
                             updatedEntries.push({
                                 name: fileName,
                                 url: this.getEntryUrl(fileHandle, change.path),
@@ -697,7 +688,7 @@ class SyncEngine {
                 }
                 catch (error) {
                     debug(`push: error processing ${change.path}: ${error}`);
-                    output_1.out.taskLine(`Error pushing ${change.path}: ${error}`, true);
+                    out.taskLine(`Error pushing ${change.path}: ${error}`, true);
                     result.errors.push({
                         path: change.path,
                         operation: "local-to-remote",
@@ -716,10 +707,10 @@ class SyncEngine {
                 if (parentOfModified === dirPath) {
                     const dirEntry = snapshot.directories.get(modifiedDir);
                     if (dirEntry) {
-                        const childHandle = await this.repo.find((0, utils_1.getPlainUrl)(dirEntry.url));
+                        const childHandle = await this.repo.find(getPlainUrl(dirEntry.url));
                         subdirUpdates.push({
                             name: childName,
-                            url: this.getEntryUrl(childHandle, modifiedDir),
+                            url: this.getDirEntryUrl(childHandle),
                         });
                     }
                 }
@@ -751,8 +742,8 @@ class SyncEngine {
             warnings: [],
         };
         // Process remote changes
-        const remoteChanges = changes.filter(c => c.changeType === types_1.ChangeType.REMOTE_ONLY ||
-            c.changeType === types_1.ChangeType.BOTH_CHANGED);
+        const remoteChanges = changes.filter(c => c.changeType === ChangeType.REMOTE_ONLY ||
+            c.changeType === ChangeType.BOTH_CHANGED);
         // Sort changes by dependency order (parents before children)
         const sortedChanges = this.sortChangesByDependency(remoteChanges);
         for (const change of sortedChanges) {
@@ -775,19 +766,19 @@ class SyncEngine {
      * Apply remote change to local filesystem
      */
     async applyRemoteChangeToLocal(change, snapshot) {
-        const localPath = (0, utils_1.joinAndNormalizePath)(this.rootPath, change.path);
+        const localPath = joinAndNormalizePath(this.rootPath, change.path);
         if (!change.remoteHead) {
             throw new Error(`No remote head found for remote change to ${change.path}`);
         }
         // Check for null (empty string/Uint8Array are valid content)
         if (change.remoteContent === null) {
             // File was deleted remotely
-            await (0, utils_1.removePath)(localPath);
+            await removePath(localPath);
             this.snapshotManager.removeFileEntry(snapshot, change.path);
             return;
         }
         // Create or update local file
-        await (0, utils_1.writeFileContent)(localPath, change.remoteContent);
+        await writeFileContent(localPath, change.remoteContent);
         // Update or create snapshot entry for this file
         const snapshotEntry = snapshot.files.get(change.path);
         if (snapshotEntry) {
@@ -804,7 +795,7 @@ class SyncEngine {
             // We need to find the remote file's URL from the directory hierarchy
             if (snapshot.rootDirectoryUrl) {
                 try {
-                    const fileEntry = await (0, utils_1.findFileInDirectoryHierarchy)(this.repo, snapshot.rootDirectoryUrl, change.path);
+                    const fileEntry = await findFileInDirectoryHierarchy(this.repo, snapshot.rootDirectoryUrl, change.path);
                     if (fileEntry) {
                         const fileHandle = await this.repo.find(fileEntry.url);
                         const entryUrl = this.getEntryUrl(fileHandle, change.path);
@@ -812,14 +803,14 @@ class SyncEngine {
                             path: localPath,
                             url: entryUrl,
                             head: change.remoteHead,
-                            extension: (0, utils_1.getFileExtension)(change.path),
-                            mimeType: (0, utils_1.getEnhancedMimeType)(change.path),
+                            extension: getFileExtension(change.path),
+                            mimeType: getEnhancedMimeType(change.path),
                         });
                     }
                 }
                 catch (error) {
                     // Failed to update snapshot - file may have been deleted
-                    output_1.out.taskLine(`Warning: Failed to update snapshot for remote file ${change.path}`, true);
+                    out.taskLine(`Warning: Failed to update snapshot for remote file ${change.path}`, true);
                 }
             }
         }
@@ -849,11 +840,11 @@ class SyncEngine {
                 // Artifact files use RawString — no diffing needed, just create a fresh doc
                 const content = move.newContent !== undefined
                     ? move.newContent
-                    : (0, utils_1.readDocContent)((await (await this.repo.find((0, utils_1.getPlainUrl)(fromEntry.url))).doc())?.content);
+                    : readDocContent((await (await this.repo.find(getPlainUrl(fromEntry.url))).doc())?.content);
                 const fakeChange = {
                     path: move.toPath,
-                    changeType: types_1.ChangeType.LOCAL_ONLY,
-                    fileType: content != null && typeof content === "string" ? types_1.FileType.TEXT : types_1.FileType.BINARY,
+                    changeType: ChangeType.LOCAL_ONLY,
+                    fileType: content != null && typeof content === "string" ? FileType.TEXT : FileType.BINARY,
                     localContent: content,
                     remoteContent: null,
                 };
@@ -865,7 +856,7 @@ class SyncEngine {
             }
             else {
                 // Use plain URL for mutable handle
-                const handle = await this.repo.find((0, utils_1.getPlainUrl)(fromEntry.url));
+                const handle = await this.repo.find(getPlainUrl(fromEntry.url));
                 const heads = fromEntry.head;
                 // Update both name and content (if content changed during move)
                 changeWithOptionalHeads(handle, heads, (doc) => {
@@ -873,7 +864,7 @@ class SyncEngine {
                     // If new content is provided, update it (handles move + modification case)
                     if (move.newContent !== undefined) {
                         if (typeof move.newContent === "string") {
-                            (0, utils_1.updateTextContent)(doc, ["content"], move.newContent);
+                            updateTextContent(doc, ["content"], move.newContent);
                         }
                         else {
                             doc.content = move.newContent;
@@ -891,17 +882,17 @@ class SyncEngine {
             this.snapshotManager.removeFileEntry(snapshot, move.fromPath);
             this.snapshotManager.updateFileEntry(snapshot, move.toPath, {
                 ...fromEntry,
-                path: (0, utils_1.joinAndNormalizePath)(this.rootPath, move.toPath),
+                path: joinAndNormalizePath(this.rootPath, move.toPath),
                 url: entryUrl,
                 head: finalHeads,
                 ...(this.isArtifactPath(move.toPath) && move.newContent != null
-                    ? { contentHash: (0, content_1.contentHash)(move.newContent) }
+                    ? { contentHash: contentHash(move.newContent) }
                     : {}),
             });
         }
         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);
+            out.taskLine(`Warning: Failed to rename ${move.fromPath} to ${move.toPath}`, true);
         }
     }
     /**
@@ -917,8 +908,8 @@ class SyncEngine {
         const fileDoc = {
             "@patchwork": { type: "file" },
             name: change.path.split("/").pop() || "",
-            extension: (0, utils_1.getFileExtension)(change.path),
-            mimeType: (0, utils_1.getEnhancedMimeType)(change.path),
+            extension: getFileExtension(change.path),
+            mimeType: getEnhancedMimeType(change.path),
             content: isText && isArtifact
                 ? new A.RawString(change.localContent)
                 : isText
@@ -932,7 +923,7 @@ class SyncEngine {
         // For non-artifact text files, splice in the content so it's stored as collaborative text
         if (isText && !isArtifact && typeof change.localContent === "string") {
             handle.change((doc) => {
-                (0, utils_1.updateTextContent)(doc, ["content"], change.localContent);
+                updateTextContent(doc, ["content"], change.localContent);
             });
         }
         // Always track newly created files for network sync
@@ -945,7 +936,7 @@ class SyncEngine {
      */
     async updateRemoteFile(url, content, snapshot, filePath) {
         // Use plain URL for mutable handle
-        const handle = await this.repo.find((0, utils_1.getPlainUrl)(url));
+        const handle = await this.repo.find(getPlainUrl(url));
         // Check if content actually changed before tracking for sync
         const doc = await handle.doc();
         const rawContent = doc?.content;
@@ -957,14 +948,14 @@ class SyncEngine {
             !doc ||
             (rawContent != null && A.isImmutableString(rawContent))) {
             if (!isArtifact) {
-                output_1.out.taskLine(`Replacing ${!doc ? 'unavailable' : 'immutable string'} document for ${filePath}`, true);
+                out.taskLine(`Replacing ${!doc ? 'unavailable' : 'immutable string'} document for ${filePath}`, true);
             }
             const fakeChange = {
                 path: filePath,
-                changeType: types_1.ChangeType.LOCAL_ONLY,
+                changeType: ChangeType.LOCAL_ONLY,
                 fileType: this.isTextContent(content)
-                    ? types_1.FileType.TEXT
-                    : types_1.FileType.BINARY,
+                    ? FileType.TEXT
+                    : FileType.BINARY,
                 localContent: content,
                 remoteContent: null,
             };
@@ -972,20 +963,20 @@ class SyncEngine {
             if (newHandle) {
                 const entryUrl = this.getEntryUrl(newHandle, filePath);
                 this.snapshotManager.updateFileEntry(snapshot, filePath, {
-                    path: (0, utils_1.joinAndNormalizePath)(this.rootPath, filePath),
+                    path: joinAndNormalizePath(this.rootPath, filePath),
                     url: entryUrl,
                     head: newHandle.heads(),
-                    extension: (0, utils_1.getFileExtension)(filePath),
-                    mimeType: (0, utils_1.getEnhancedMimeType)(filePath),
+                    extension: getFileExtension(filePath),
+                    mimeType: getEnhancedMimeType(filePath),
                     ...(this.isArtifactPath(filePath)
-                        ? { contentHash: (0, content_1.contentHash)(content) }
+                        ? { contentHash: contentHash(content) }
                         : {}),
                 });
             }
             return;
         }
-        const currentContent = (0, utils_1.readDocContent)(rawContent);
-        const contentChanged = !(0, content_1.isContentEqual)(content, currentContent);
+        const currentContent = readDocContent(rawContent);
+        const contentChanged = !isContentEqual(content, currentContent);
         // Update snapshot heads even when content is identical
         const snapshotEntry = snapshot.files.get(filePath);
         if (snapshotEntry) {
@@ -1006,7 +997,7 @@ class SyncEngine {
         }
         handle.changeAt(heads, (doc) => {
             if (typeof content === "string") {
-                (0, utils_1.updateTextContent)(doc, ["content"], content);
+                updateTextContent(doc, ["content"], content);
             }
             else {
                 doc.content = content;
@@ -1043,7 +1034,7 @@ class SyncEngine {
         // Get or create the parent directory document
         const parentDirUrl = await this.ensureDirectoryDocument(snapshot, directoryPath);
         // Use plain URL for mutable handle
-        const dirHandle = await this.repo.find((0, utils_1.getPlainUrl)(parentDirUrl));
+        const dirHandle = await this.repo.find(getPlainUrl(parentDirUrl));
         let didChange = false;
         const snapshotEntry = snapshot.directories.get(directoryPath);
         const heads = snapshotEntry?.head;
@@ -1098,10 +1089,10 @@ class SyncEngine {
                         // Track discovered directory for sync
                         this.handlesByPath.set(directoryPath, childDirHandle);
                         // Get appropriate URL for directory entry
-                        const entryUrl = this.getEntryUrl(childDirHandle, directoryPath);
+                        const entryUrl = this.getDirEntryUrl(childDirHandle);
                         // Update snapshot with discovered directory
                         this.snapshotManager.updateDirectoryEntry(snapshot, directoryPath, {
-                            path: (0, utils_1.joinAndNormalizePath)(this.rootPath, directoryPath),
+                            path: joinAndNormalizePath(this.rootPath, directoryPath),
                             url: entryUrl,
                             head: childDirHandle.heads(),
                             entries: [],
@@ -1126,10 +1117,10 @@ class SyncEngine {
         };
         const dirHandle = this.repo.create(dirDoc);
         // Get appropriate URL for directory entry
-        const dirEntryUrl = this.getEntryUrl(dirHandle, directoryPath);
+        const dirEntryUrl = this.getDirEntryUrl(dirHandle);
         // Add this directory to its parent
         // Use plain URL for mutable handle
-        const parentHandle = await this.repo.find((0, utils_1.getPlainUrl)(parentDirUrl));
+        const parentHandle = await this.repo.find(getPlainUrl(parentDirUrl));
         let didChange = false;
         parentHandle.change((doc) => {
             // Double-check that entry doesn't exist (race condition protection)
@@ -1154,7 +1145,7 @@ class SyncEngine {
         }
         // Update snapshot with new directory
         this.snapshotManager.updateDirectoryEntry(snapshot, directoryPath, {
-            path: (0, utils_1.joinAndNormalizePath)(this.rootPath, directoryPath),
+            path: joinAndNormalizePath(this.rootPath, directoryPath),
             url: dirEntryUrl,
             head: dirHandle.heads(),
             entries: [],
@@ -1185,7 +1176,7 @@ class SyncEngine {
         }
         try {
             // Use plain URL for mutable handle
-            const dirHandle = await this.repo.find((0, utils_1.getPlainUrl)(parentDirUrl));
+            const dirHandle = await this.repo.find(getPlainUrl(parentDirUrl));
             // Track this handle for network sync waiting
             this.handlesByPath.set(directoryPath, dirHandle);
             const snapshotEntry = snapshot.directories.get(directoryPath);
@@ -1196,7 +1187,7 @@ class SyncEngine {
                 if (indexToRemove !== -1) {
                     doc.docs.splice(indexToRemove, 1);
                     didChange = true;
-                    output_1.out.taskLine(`Removed ${fileName} from ${(0, utils_1.formatRelativePath)(directoryPath) || "root"}`);
+                    out.taskLine(`Removed ${fileName} from ${formatRelativePath(directoryPath) || "root"}`);
                 }
             });
             if (didChange && snapshotEntry) {
@@ -1224,7 +1215,7 @@ class SyncEngine {
                 return;
             dirUrl = dirEntry.url;
         }
-        const dirHandle = await this.repo.find((0, utils_1.getPlainUrl)(dirUrl));
+        const dirHandle = await this.repo.find(getPlainUrl(dirUrl));
         const snapshotEntry = snapshot.directories.get(dirPath);
         const heads = snapshotEntry?.head;
         // Determine directory name
@@ -1240,7 +1231,7 @@ class SyncEngine {
                 const idx = doc.docs.findIndex(entry => entry.name === name && entry.type === "file");
                 if (idx !== -1) {
                     doc.docs.splice(idx, 1);
-                    output_1.out.taskLine(`Removed ${name} from ${(0, utils_1.formatRelativePath)(dirPath) || "root"}`);
+                    out.taskLine(`Removed ${name} from ${formatRelativePath(dirPath) || "root"}`);
                 }
             }
             // Update URLs for modified files
@@ -1328,11 +1319,11 @@ class SyncEngine {
      * Generate human-readable summary of changes
      */
     generateChangeSummary(changes, moves) {
-        const localChanges = changes.filter(c => c.changeType === types_1.ChangeType.LOCAL_ONLY ||
-            c.changeType === types_1.ChangeType.BOTH_CHANGED).length;
-        const remoteChanges = changes.filter(c => c.changeType === types_1.ChangeType.REMOTE_ONLY ||
-            c.changeType === types_1.ChangeType.BOTH_CHANGED).length;
-        const conflicts = changes.filter(c => c.changeType === types_1.ChangeType.BOTH_CHANGED).length;
+        const localChanges = changes.filter(c => c.changeType === ChangeType.LOCAL_ONLY ||
+            c.changeType === ChangeType.BOTH_CHANGED).length;
+        const remoteChanges = changes.filter(c => c.changeType === ChangeType.REMOTE_ONLY ||
+            c.changeType === ChangeType.BOTH_CHANGED).length;
+        const conflicts = changes.filter(c => c.changeType === ChangeType.BOTH_CHANGED).length;
         const parts = [];
         if (localChanges > 0) {
             parts.push(`${localChanges} local change${localChanges > 1 ? "s" : ""}`);
@@ -1360,24 +1351,29 @@ class SyncEngine {
         }
         try {
             const rootHandle = await this.repo.find(snapshot.rootDirectoryUrl);
-            const snapshotEntry = snapshot.directories.get("");
-            const heads = snapshotEntry?.head;
             const timestamp = Date.now();
-            const version = require("../../package.json").version;
-            changeWithOptionalHeads(rootHandle, heads, (doc) => {
+            let version;
+            try {
+                version = require("../../package.json").version;
+            }
+            catch {
+                version = "unknown";
+            }
+            debug(`touchRootDirectory: setting lastSyncAt=${timestamp} with=pushwork@${version}`);
+            rootHandle.change((doc) => {
                 doc.lastSyncAt = timestamp;
                 doc.with = `pushwork@${version}`;
             });
             // Track root directory for network sync
             this.handlesByPath.set("", rootHandle);
+            const snapshotEntry = snapshot.directories.get("");
             if (snapshotEntry) {
                 snapshotEntry.head = rootHandle.heads();
             }
         }
         catch (error) {
-            // Failed to update root directory timestamp
+            debug(`touchRootDirectory: failed: ${error}`);
         }
     }
 }
-exports.SyncEngine = SyncEngine;
 //# sourceMappingURL=sync-engine.js.map