pushwork 1.1.1 → 1.1.3

package/src/core/sync-engine.ts

@@ -266,7 +266,7 @@ export class SyncEngine {
 			const plainUrl = getPlainUrl(entry.url)
 			if (!failedUrls.has(plainUrl)) continue
 
-			debug(`recreate: recreating document for ${filePath} (${plainUrl.slice(0, 20)}...)`)
+			debug(`recreate: recreating document for ${filePath} (${plainUrl})`)
 			out.taskLine(`Recreating document for ${filePath}`)
 
 			try {
@@ -335,7 +335,7 @@ export class SyncEngine {
 				newHandles.push(newHandle)
 				newHandles.push(dirHandle)
 
-				debug(`recreate: created new doc for ${filePath} -> ${newHandle.url.slice(0, 20)}...`)
+				debug(`recreate: created new doc for ${filePath} -> ${newHandle.url}`)
 			} catch (error) {
 				debug(`recreate: failed for ${filePath}: ${error}`)
 				out.taskLine(`Failed to recreate ${filePath}: ${error}`, true)
@@ -378,7 +378,7 @@ export class SyncEngine {
 				(await this.snapshotManager.load()) ||
 				this.snapshotManager.createEmpty()
 
-			debug(`sync: rootDirectoryUrl=${snapshot.rootDirectoryUrl?.slice(0, 30)}..., files=${snapshot.files.size}, dirs=${snapshot.directories.size}`)
+			debug(`sync: rootDirectoryUrl=${snapshot.rootDirectoryUrl}, files=${snapshot.files.size}, dirs=${snapshot.directories.size}`)
 
 			// Wait for initial sync to receive any pending remote changes
 			if (this.config.sync_enabled && snapshot.rootDirectoryUrl) {
@@ -583,9 +583,17 @@ export class SyncEngine {
 			result.warnings.push(...phase2Result.warnings)
 
 			// Update snapshot heads after pulling remote changes
+			// IMPORTANT: Use getPlainUrl() to strip version/heads from URLs.
+			// Artifact entries store versioned URLs (with heads baked in).
+			// repo.find(versionedUrl) returns a view handle whose .heads()
+			// returns the VERSION heads, not the current document heads.
+			// Using the versioned URL here would overwrite correct heads with
+			// stale ones, causing changeAt() to fork from the wrong point
+			// on the next sync (e.g. an empty directory state where deletions
+			// can't find the entries to splice out).
 			for (const [filePath, snapshotEntry] of snapshot.files.entries()) {
 				try {
-					const handle = await this.repo.find(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
@@ -602,7 +610,7 @@ export class SyncEngine {
 			// Update directory document heads
 			for (const [dirPath, snapshotEntry] of snapshot.directories.entries()) {
 				try {
-					const handle = await this.repo.find(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
@@ -797,7 +805,7 @@ export class SyncEngine {
 								}
 							)
 							result.filesChanged++
-							debug(`push: created ${change.path} -> ${handle.url.slice(0, 20)}...`)
+							debug(`push: created ${change.path} -> ${handle.url}`)
 						}
 					} else {
 						// Update existing file
@@ -958,6 +966,11 @@ export class SyncEngine {
 		if (snapshotEntry) {
 			// Update existing entry
 			snapshotEntry.head = change.remoteHead
+			// If the remote document was replaced (new URL), update the snapshot URL
+			if (change.remoteUrl) {
+				const fileHandle = await this.repo.find<FileDocument>(change.remoteUrl)
+				snapshotEntry.url = this.getEntryUrl(fileHandle, change.path)
+			}
 		} else {
 			// Create new snapshot entry for newly discovered remote file
 			// We need to find the remote file's URL from the directory hierarchy

package/src/types/documents.ts

@@ -41,7 +41,7 @@ export interface FileDocument {
 export enum FileType {
 	TEXT = "text",
 	BINARY = "binary",
-	DIRECTORY = "directory",
+	DIRECTORY = "directory"
 }
 
 /**
@@ -51,7 +51,7 @@ export enum ChangeType {
 	NO_CHANGE = "no_change",
 	LOCAL_ONLY = "local_only",
 	REMOTE_ONLY = "remote_only",
-	BOTH_CHANGED = "both_changed",
+	BOTH_CHANGED = "both_changed"
 }
 
 /**
@@ -86,4 +86,6 @@ export interface DetectedChange {
 	remoteContent: string | Uint8Array | null
 	localHead?: UrlHeads
 	remoteHead?: UrlHeads
+	/** New remote URL when the remote document was replaced (artifact URL change) */
+	remoteUrl?: AutomergeUrl
 }

package/src/utils/network-sync.ts

@@ -88,7 +88,7 @@ export async function waitForBidirectionalSync(
         const changedDocs: string[] = [];
         for (const [url, heads] of currentHeads) {
           if (lastSeenHeads.get(url) !== heads) {
-            changedDocs.push(url.slice(0, 20) + "...");
+            changedDocs.push(url);
           }
         }
         const newDocs = currentHeads.size - lastSeenHeads.size;
@@ -236,13 +236,13 @@ function waitForHandleSync(
     };
 
     const onConverged = () => {
-      debug(`waitForSync: ${handle.url.slice(0, 20)}... converged in ${Date.now() - startTime}ms`);
+      debug(`waitForSync: ${handle.url}... converged in ${Date.now() - startTime}ms`);
       cleanup();
       resolve(handle);
     };
 
     const timeout = setTimeout(() => {
-      debug(`waitForSync: ${handle.url.slice(0, 20)}... timed out after ${timeoutMs}ms`);
+      debug(`waitForSync: ${handle.url}... timed out after ${timeoutMs}ms`);
       cleanup();
       reject(handle);
     }, timeoutMs);
@@ -317,9 +317,9 @@ export async function waitForSync(
     const remoteHeads = syncInfo?.lastHeads;
     if (A.equals(heads, remoteHeads)) {
       alreadySynced++;
-      debug(`waitForSync: ${handle.url.slice(0, 20)}... already synced`);
+      debug(`waitForSync: ${handle.url}... already synced`);
     } else {
-      debug(`waitForSync: ${handle.url.slice(0, 20)}... needs sync (remoteHeads=${remoteHeads ? 'present' : 'missing'})`);
+      debug(`waitForSync: ${handle.url}... needs sync (remoteHeads=${remoteHeads ? 'present' : 'missing'})`);
       needsSync.push(handle);
     }
   }

package/test/integration/in-memory-sync.test.ts

@@ -391,6 +391,401 @@ describe("Sync Reliability Tests", () => {
     }, 30000);
   });
 
+  describe("Subdirectory File Deletion - Resurrection Bug", () => {
+    it("deleted file in artifact directory should not resurrect", async () => {
+      // Files in artifact directories (dist/ by default) resurrect after sync.
+      // Phase 1 (push) correctly removes the file entry from the directory doc,
+      // but the Automerge merge with the server's version re-introduces it.
+      // Phase 2 (pull) then sees it as a "new remote document" and re-creates it.
+      const repoA = path.join(tmpDir, "repo-a");
+      await fs.mkdir(repoA);
+
+      await fs.mkdir(path.join(repoA, "dist", "assets"), { recursive: true });
+      await fs.writeFile(path.join(repoA, "dist", "assets", "app.js"), "// build 1");
+      await pushwork(["init", "."], repoA);
+      await pushwork(["sync"], repoA);
+
+      // Delete the file
+      await fs.unlink(path.join(repoA, "dist", "assets", "app.js"));
+
+      // Sync - push deletion then pull
+      await pushwork(["sync"], repoA);
+
+      // File should stay deleted
+      expect(await pathExists(path.join(repoA, "dist", "assets", "app.js"))).toBe(false);
+
+      // Sync again - should NOT come back from server
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "dist", "assets", "app.js"))).toBe(false);
+    }, 60000);
+
+    it("deleted file in depth-1 subdirectory should not resurrect (control)", async () => {
+      // Control: depth-1 subdirectories work correctly
+      const repoA = path.join(tmpDir, "repo-a");
+      await fs.mkdir(repoA);
+
+      await fs.mkdir(path.join(repoA, "subdir"), { recursive: true });
+      await fs.writeFile(path.join(repoA, "subdir", "file.txt"), "content");
+      await pushwork(["init", "."], repoA);
+      await pushwork(["sync"], repoA);
+
+      await fs.unlink(path.join(repoA, "subdir", "file.txt"));
+
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "subdir", "file.txt"))).toBe(false);
+
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "subdir", "file.txt"))).toBe(false);
+    }, 60000);
+
+    it("deleted build artifacts should not resurrect after rebuild cycle", async () => {
+      // Real-world scenario: build step creates new hashed files and deletes
+      // old ones in dist/assets/. The deleted files come back from the server.
+      const repoA = path.join(tmpDir, "repo-a");
+      await fs.mkdir(repoA);
+
+      await fs.mkdir(path.join(repoA, "dist", "assets"), { recursive: true });
+      await fs.writeFile(path.join(repoA, "dist", "assets", "app-ABC123.js"), "// build 1");
+      await fs.writeFile(path.join(repoA, "dist", "assets", "vendor-DEF456.js"), "// vendor 1");
+      await fs.writeFile(path.join(repoA, "dist", "index.js"), "// index 1");
+      await pushwork(["init", "."], repoA);
+      await pushwork(["sync"], repoA);
+
+      // Simulate rebuild: new hashed files replace old ones
+      await fs.unlink(path.join(repoA, "dist", "assets", "app-ABC123.js"));
+      await fs.unlink(path.join(repoA, "dist", "assets", "vendor-DEF456.js"));
+      await fs.writeFile(path.join(repoA, "dist", "assets", "app-XYZ789.js"), "// build 2");
+      await fs.writeFile(path.join(repoA, "dist", "assets", "vendor-UVW012.js"), "// vendor 2");
+      await fs.writeFile(path.join(repoA, "dist", "index.js"), "// index 2");
+
+      await pushwork(["sync"], repoA);
+
+      // Old files should be gone, new files should exist
+      expect(await pathExists(path.join(repoA, "dist", "assets", "app-ABC123.js"))).toBe(false);
+      expect(await pathExists(path.join(repoA, "dist", "assets", "vendor-DEF456.js"))).toBe(false);
+      expect(await pathExists(path.join(repoA, "dist", "assets", "app-XYZ789.js"))).toBe(true);
+      expect(await pathExists(path.join(repoA, "dist", "assets", "vendor-UVW012.js"))).toBe(true);
+
+      // Sync again - old files should NOT come back from server
+      await pushwork(["sync"], repoA);
+
+      expect(await pathExists(path.join(repoA, "dist", "assets", "app-ABC123.js"))).toBe(false);
+      expect(await pathExists(path.join(repoA, "dist", "assets", "vendor-DEF456.js"))).toBe(false);
+    }, 60000);
+
+    it("deleted artifact files should not resurrect on clone", async () => {
+      // Two repos: A deletes files in an artifact directory, B should not
+      // see the deleted files after syncing.
+      const repoA = path.join(tmpDir, "repo-a");
+      const repoB = path.join(tmpDir, "repo-b");
+      await fs.mkdir(repoA);
+      await fs.mkdir(repoB);
+
+      await fs.mkdir(path.join(repoA, "dist", "assets"), { recursive: true });
+      await fs.writeFile(path.join(repoA, "dist", "assets", "app-ABC123.js"), "// build 1");
+      await fs.writeFile(path.join(repoA, "dist", "assets", "vendor-DEF456.js"), "// vendor 1");
+      await fs.writeFile(path.join(repoA, "dist", "index.js"), "// index 1");
+      await pushwork(["init", "."], repoA);
+
+      // Clone to B and converge
+      const { stdout: rootUrl } = await pushwork(["url"], repoA);
+      await pushwork(["clone", rootUrl.trim(), repoB], tmpDir);
+      await syncUntilConverged(repoA, repoB);
+
+      expect(await pathExists(path.join(repoB, "dist", "assets", "app-ABC123.js"))).toBe(true);
+
+      // A rebuilds
+      await fs.unlink(path.join(repoA, "dist", "assets", "app-ABC123.js"));
+      await fs.unlink(path.join(repoA, "dist", "assets", "vendor-DEF456.js"));
+      await fs.writeFile(path.join(repoA, "dist", "assets", "app-XYZ789.js"), "// build 2");
+      await fs.writeFile(path.join(repoA, "dist", "assets", "vendor-UVW012.js"), "// vendor 2");
+      await fs.writeFile(path.join(repoA, "dist", "index.js"), "// index 2");
+
+      // Sync A then B
+      await pushwork(["sync"], repoA);
+
+      // A should not have resurrected files
+      expect(await pathExists(path.join(repoA, "dist", "assets", "app-ABC123.js"))).toBe(false);
+      expect(await pathExists(path.join(repoA, "dist", "assets", "vendor-DEF456.js"))).toBe(false);
+
+      await pushwork(["sync"], repoB);
+
+      // B should have new files, NOT old files
+      expect(await pathExists(path.join(repoB, "dist", "assets", "app-ABC123.js"))).toBe(false);
+      expect(await pathExists(path.join(repoB, "dist", "assets", "vendor-DEF456.js"))).toBe(false);
+      expect(await pathExists(path.join(repoB, "dist", "assets", "app-XYZ789.js"))).toBe(true);
+    }, 90000);
+
+    it("deleted file in depth-3 subdirectory should not resurrect", async () => {
+      const repoA = path.join(tmpDir, "repo-a");
+      await fs.mkdir(repoA);
+
+      await fs.mkdir(path.join(repoA, "a", "b", "c"), { recursive: true });
+      await fs.writeFile(path.join(repoA, "a", "b", "c", "deep.txt"), "deep");
+      await pushwork(["init", "."], repoA);
+      await pushwork(["sync"], repoA);
+
+      await fs.unlink(path.join(repoA, "a", "b", "c", "deep.txt"));
+
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "a", "b", "c", "deep.txt"))).toBe(false);
+
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "a", "b", "c", "deep.txt"))).toBe(false);
+    }, 60000);
+
+    it("create+delete in same subdirectory should not resurrect deleted files", async () => {
+      // Regression guard: simultaneous create+delete in the same non-artifact
+      // subdirectory should work. This passes today but we don't want it to regress.
+      const repoA = path.join(tmpDir, "repo-a");
+      await fs.mkdir(repoA);
+
+      await fs.mkdir(path.join(repoA, "subdir"), { recursive: true });
+      await fs.writeFile(path.join(repoA, "subdir", "old.txt"), "old content");
+      await pushwork(["init", "."], repoA);
+      await pushwork(["sync"], repoA);
+
+      // Simultaneously create new file and delete old file in same dir
+      await fs.unlink(path.join(repoA, "subdir", "old.txt"));
+      await fs.writeFile(path.join(repoA, "subdir", "new.txt"), "new content");
+
+      await pushwork(["sync"], repoA);
+
+      expect(await pathExists(path.join(repoA, "subdir", "old.txt"))).toBe(false);
+      expect(await pathExists(path.join(repoA, "subdir", "new.txt"))).toBe(true);
+
+      // Sync again - old file should NOT come back
+      await pushwork(["sync"], repoA);
+
+      expect(await pathExists(path.join(repoA, "subdir", "old.txt"))).toBe(false);
+      expect(await pathExists(path.join(repoA, "subdir", "new.txt"))).toBe(true);
+    }, 60000);
+
+    it("deleted file in depth-2 with sibling dirs should not resurrect", async () => {
+      // The depth-3 test has intermediate dirs (a/b/c) with only one child each.
+      // The dist/assets test has dist/ containing both assets/ (subdir) and
+      // index.js (file). Test if having a file sibling alongside the subdir matters.
+      const repoA = path.join(tmpDir, "repo-a");
+      await fs.mkdir(repoA);
+
+      await fs.mkdir(path.join(repoA, "parent", "child"), { recursive: true });
+      await fs.writeFile(path.join(repoA, "parent", "sibling.txt"), "sibling at parent level");
+      await fs.writeFile(path.join(repoA, "parent", "child", "target.txt"), "will be deleted");
+      await pushwork(["init", "."], repoA);
+      await pushwork(["sync"], repoA);
+
+      await fs.unlink(path.join(repoA, "parent", "child", "target.txt"));
+
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "parent", "child", "target.txt"))).toBe(false);
+      expect(await pathExists(path.join(repoA, "parent", "sibling.txt"))).toBe(true);
+
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "parent", "child", "target.txt"))).toBe(false);
+    }, 60000);
+
+    it("deleted file in root directory should not resurrect", async () => {
+      const repoA = path.join(tmpDir, "repo-a");
+      await fs.mkdir(repoA);
+
+      await fs.writeFile(path.join(repoA, "root-file.txt"), "root content");
+      await fs.writeFile(path.join(repoA, "keep.txt"), "keep this");
+      await pushwork(["init", "."], repoA);
+      await pushwork(["sync"], repoA);
+
+      // Delete file in root
+      await fs.unlink(path.join(repoA, "root-file.txt"));
+
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "root-file.txt"))).toBe(false);
+      expect(await pathExists(path.join(repoA, "keep.txt"))).toBe(true);
+
+      // Sync again - should NOT come back
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "root-file.txt"))).toBe(false);
+    }, 60000);
+
+    it("deleted file in non-artifact subdirectory (src/) should not resurrect", async () => {
+      const repoA = path.join(tmpDir, "repo-a");
+      await fs.mkdir(repoA);
+
+      await fs.mkdir(path.join(repoA, "src"), { recursive: true });
+      await fs.writeFile(path.join(repoA, "src", "index.ts"), "export default 1");
+      await fs.writeFile(path.join(repoA, "src", "helper.ts"), "export function help() {}");
+      await pushwork(["init", "."], repoA);
+      await pushwork(["sync"], repoA);
+
+      // Delete one file in src/
+      await fs.unlink(path.join(repoA, "src", "helper.ts"));
+
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "src", "helper.ts"))).toBe(false);
+      expect(await pathExists(path.join(repoA, "src", "index.ts"))).toBe(true);
+
+      // Sync again - should NOT come back
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "src", "helper.ts"))).toBe(false);
+    }, 60000);
+
+    it("deleted files should not resurrect after multiple sync cycles", async () => {
+      // Simulate real-world usage: multiple syncs over time with deletions
+      const repoA = path.join(tmpDir, "repo-a");
+      await fs.mkdir(repoA);
+
+      await fs.mkdir(path.join(repoA, "src"), { recursive: true });
+      await fs.writeFile(path.join(repoA, "readme.txt"), "readme");
+      await fs.writeFile(path.join(repoA, "src", "app.ts"), "app");
+      await fs.writeFile(path.join(repoA, "src", "old.ts"), "old");
+      await pushwork(["init", "."], repoA);
+      await pushwork(["sync"], repoA);
+
+      // Cycle 1: delete root file
+      await fs.unlink(path.join(repoA, "readme.txt"));
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "readme.txt"))).toBe(false);
+
+      // Cycle 2: delete src file
+      await fs.unlink(path.join(repoA, "src", "old.ts"));
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "src", "old.ts"))).toBe(false);
+
+      // Cycle 3: just sync - nothing should come back
+      await pushwork(["sync"], repoA);
+      expect(await pathExists(path.join(repoA, "readme.txt"))).toBe(false);
+      expect(await pathExists(path.join(repoA, "src", "old.ts"))).toBe(false);
+      expect(await pathExists(path.join(repoA, "src", "app.ts"))).toBe(true);
+    }, 90000);
+
+    it("peer B should not see files deleted by peer A (root)", async () => {
+      const repoA = path.join(tmpDir, "repo-a");
+      const repoB = path.join(tmpDir, "repo-b");
+      await fs.mkdir(repoA);
+      await fs.mkdir(repoB);
+
+      await fs.writeFile(path.join(repoA, "keep.txt"), "keep");
+      await fs.writeFile(path.join(repoA, "delete-me.txt"), "gone");
+      await pushwork(["init", "."], repoA);
+
+      // Clone to B and converge
+      const { stdout: rootUrl } = await pushwork(["url"], repoA);
+      await pushwork(["clone", rootUrl.trim(), repoB], tmpDir);
+      await syncUntilConverged(repoA, repoB);
+
+      expect(await pathExists(path.join(repoB, "delete-me.txt"))).toBe(true);
+
+      // A deletes a root file
+      await fs.unlink(path.join(repoA, "delete-me.txt"));
+      await pushwork(["sync"], repoA);
+
+      // B syncs - should see the deletion
+      await pushwork(["sync"], repoB);
+      expect(await pathExists(path.join(repoB, "delete-me.txt"))).toBe(false);
+      expect(await pathExists(path.join(repoB, "keep.txt"))).toBe(true);
+
+      // B syncs again - should stay deleted
+      await pushwork(["sync"], repoB);
+      expect(await pathExists(path.join(repoB, "delete-me.txt"))).toBe(false);
+    }, 90000);
+
+    it("peer B should not see files deleted by peer A (src/)", async () => {
+      const repoA = path.join(tmpDir, "repo-a");
+      const repoB = path.join(tmpDir, "repo-b");
+      await fs.mkdir(repoA);
+      await fs.mkdir(repoB);
+
+      await fs.mkdir(path.join(repoA, "src"), { recursive: true });
+      await fs.writeFile(path.join(repoA, "src", "index.ts"), "export default 1");
+      await fs.writeFile(path.join(repoA, "src", "old.ts"), "old code");
+      await pushwork(["init", "."], repoA);
+
+      const { stdout: rootUrl } = await pushwork(["url"], repoA);
+      await pushwork(["clone", rootUrl.trim(), repoB], tmpDir);
+      await syncUntilConverged(repoA, repoB);
+
+      expect(await pathExists(path.join(repoB, "src", "old.ts"))).toBe(true);
+
+      // A deletes a file in src/
+      await fs.unlink(path.join(repoA, "src", "old.ts"));
+      await pushwork(["sync"], repoA);
+
+      // B syncs - should see the deletion
+      await pushwork(["sync"], repoB);
+      expect(await pathExists(path.join(repoB, "src", "old.ts"))).toBe(false);
+      expect(await pathExists(path.join(repoB, "src", "index.ts"))).toBe(true);
+
+      // B syncs again - should stay deleted
+      await pushwork(["sync"], repoB);
+      expect(await pathExists(path.join(repoB, "src", "old.ts"))).toBe(false);
+    }, 90000);
+
+    it("peer B should not see files deleted by peer A (dist/)", async () => {
+      const repoA = path.join(tmpDir, "repo-a");
+      const repoB = path.join(tmpDir, "repo-b");
+      await fs.mkdir(repoA);
+      await fs.mkdir(repoB);
+
+      await fs.mkdir(path.join(repoA, "dist", "assets"), { recursive: true });
+      await fs.writeFile(path.join(repoA, "dist", "index.js"), "// index");
+      await fs.writeFile(path.join(repoA, "dist", "assets", "app-ABC.js"), "// build 1");
+      await pushwork(["init", "."], repoA);
+
+      const { stdout: rootUrl } = await pushwork(["url"], repoA);
+      await pushwork(["clone", rootUrl.trim(), repoB], tmpDir);
+      await syncUntilConverged(repoA, repoB);
+
+      expect(await pathExists(path.join(repoB, "dist", "assets", "app-ABC.js"))).toBe(true);
+
+      // A rebuilds: delete old artifact, create new one
+      await fs.unlink(path.join(repoA, "dist", "assets", "app-ABC.js"));
+      await fs.writeFile(path.join(repoA, "dist", "assets", "app-XYZ.js"), "// build 2");
+      await pushwork(["sync"], repoA);
+
+      // A should not have resurrected
+      expect(await pathExists(path.join(repoA, "dist", "assets", "app-ABC.js"))).toBe(false);
+
+      // B syncs - should see new file, NOT old file
+      await pushwork(["sync"], repoB);
+      expect(await pathExists(path.join(repoB, "dist", "assets", "app-ABC.js"))).toBe(false);
+      expect(await pathExists(path.join(repoB, "dist", "assets", "app-XYZ.js"))).toBe(true);
+
+      // B syncs again - old file should stay gone
+      await pushwork(["sync"], repoB);
+      expect(await pathExists(path.join(repoB, "dist", "assets", "app-ABC.js"))).toBe(false);
+    }, 90000);
+
+    it("peer B should see artifact file content update after URL replacement", async () => {
+      // When peer A modifies an artifact file, the document is replaced entirely
+      // (new Automerge doc with a new URL). Peer B's snapshot still points to the
+      // old (now orphaned) URL. detectRemoteChanges sees no head change on the old
+      // doc, and detectNewRemoteDocuments skips paths already in the snapshot.
+      // Without URL replacement detection, B never sees the update.
+      const repoA = path.join(tmpDir, "repo-a");
+      const repoB = path.join(tmpDir, "repo-b");
+      await fs.mkdir(repoA);
+      await fs.mkdir(repoB);
+
+      await fs.mkdir(path.join(repoA, "dist"), { recursive: true });
+      await fs.writeFile(path.join(repoA, "dist", "app.js"), "// version 1");
+      await pushwork(["init", "."], repoA);
+
+      const { stdout: rootUrl } = await pushwork(["url"], repoA);
+      await pushwork(["clone", rootUrl.trim(), repoB], tmpDir);
+      await syncUntilConverged(repoA, repoB);
+
+      const bContentV1 = await fs.readFile(path.join(repoB, "dist", "app.js"), "utf-8");
+      expect(bContentV1).toBe("// version 1");
+
+      // A modifies the artifact file — this triggers nuclear replacement (new URL)
+      await fs.writeFile(path.join(repoA, "dist", "app.js"), "// version 2");
+      await pushwork(["sync"], repoA);
+
+      // B syncs — should pick up the new content despite the URL change
+      await pushwork(["sync"], repoB);
+      const bContentV2 = await fs.readFile(path.join(repoB, "dist", "app.js"), "utf-8");
+      expect(bContentV2).toBe("// version 2");
+    }, 90000);
+  });
+
   describe("Move/Rename Detection", () => {
     it("should handle file rename", async () => {
       const repoA = path.join(tmpDir, "repo-a");