@filen/sync 0.2.1 → 0.3.2

package/tests/scenarios/p-remote-originated.test.ts

@@ -0,0 +1,306 @@
+import { describe, it, expect } from "vitest"
+import { runScenario, runCycle, remoteMutate, localMutate, control } from "../harness/runner"
+import { BASE_TIME } from "../harness/world"
+import { transferKinds, allOps } from "../harness/snapshot"
+import { renameLocal, readLocal, existsLocal } from "../harness/mutations"
+
+/**
+ * Category P — remote-originated propagation (the download direction) and cross-directory moves.
+ *
+ * The bulk of the suite is LOCAL-originated (uploads). This file deliberately drives the cloud→local
+ * direction (`mode:"cloudToLocal"`) so the engine has to CREATE/DOWNLOAD/DELETE/RENAME on the local
+ * side, plus the local→cloud cross-parent MOVE branches.
+ *
+ * Cache timing: the previous local/remote trees are observed at cycle START, and a just-downloaded
+ * file only enters the previous LOCAL tree on the following scan. So remote-originated mutations are
+ * applied after TWO settle cycles (the item is then present in both previous trees), which lands the
+ * mutation's propagation in `result.cycles[2]`. Local-originated moves settle in ONE cycle (the local
+ * inode is already known), landing in `result.cycles[1]`.
+ *
+ * Identity: a rename/move keeps the node identity (remote uuid / local inode) — it is NOT a
+ * delete+add — and a directory rename/move/delete collapses its children into the single parent op.
+ */
+const SECOND = 1000
+
+describe("Category P — remote-originated & cross-directory moves", () => {
+	// ===== DOWNLOAD direction (cloudToLocal) =====
+
+	it("P1: a new remote file downloads to local with its content (downloadFile)", async () => {
+		const result = await runScenario({
+			name: "P1",
+			mode: "cloudToLocal",
+			initialRemote: { "/a.txt": { content: "hello-remote", mtimeMs: BASE_TIME + 1 * SECOND } },
+			steps: [runCycle(), runCycle(), runCycle()]
+		})
+
+		expect(transferKinds(result.cycles[0]!.messages)).toContain("downloadFile")
+		expect(result.cycles[0]!.local["/a.txt"]).toMatchObject({ type: "file", size: "hello-remote".length })
+		// The content actually landed on disk, not just a tree entry.
+		expect(readLocal(result.world, "a.txt")).toBe("hello-remote")
+		// Idempotence: no further transfers once converged.
+		expect(allOps(result.cycles[2]!.messages)).toEqual([])
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("P2: a remote directory tree creates the local dirs and downloads its files", async () => {
+		const result = await runScenario({
+			name: "P2",
+			mode: "cloudToLocal",
+			initialRemote: {
+				"/sub/a.txt": { content: "A", mtimeMs: BASE_TIME + 1 * SECOND },
+				"/sub/deep/b.txt": { content: "B", mtimeMs: BASE_TIME + 2 * SECOND }
+			},
+			steps: [runCycle(), runCycle(), runCycle()]
+		})
+
+		const kinds = transferKinds(result.cycles[0]!.messages)
+
+		// Both the intermediate directory and the nested directory are created locally…
+		expect(kinds).toContain("createLocalDirectory")
+		// …and the files are downloaded (not the dirs masquerading as files).
+		expect(kinds).toContain("downloadFile")
+
+		expect(result.finalLocal["/sub"]).toMatchObject({ type: "directory" })
+		expect(result.finalLocal["/sub/deep"]).toMatchObject({ type: "directory" })
+		expect(result.finalLocal["/sub/a.txt"]).toMatchObject({ type: "file", size: 1 })
+		expect(result.finalLocal["/sub/deep/b.txt"]).toMatchObject({ type: "file", size: 1 })
+		expect(readLocal(result.world, "sub/deep/b.txt")).toBe("B")
+		expect(allOps(result.cycles[2]!.messages)).toEqual([])
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("P3: deleting a remote file deletes the local copy (to .filen.trash.local)", async () => {
+		const result = await runScenario({
+			name: "P3",
+			mode: "cloudToLocal",
+			initialRemote: { "/a.txt": { content: "content", mtimeMs: BASE_TIME + 1 * SECOND } },
+			steps: [
+				runCycle(),
+				runCycle(),
+				remoteMutate(world => world.cloud.controls.trashPath("/a.txt")),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(transferKinds(result.cycles[2]!.messages)).toContain("deleteLocalFile")
+		// Gone from the synced tree on both sides…
+		expect(result.finalLocal["/a.txt"]).toBeUndefined()
+		expect(result.finalRemote["/a.txt"]).toBeUndefined()
+		// …but moved to the local trash (no data loss), not hard-deleted.
+		expect(existsLocal(result.world, ".filen.trash.local/a.txt")).toBe(true)
+		expect(allOps(result.cycles[3]!.messages)).toEqual([])
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("P4: deleting a remote directory subtree emits ONE local delete (children collapsed)", async () => {
+		const result = await runScenario({
+			name: "P4",
+			mode: "cloudToLocal",
+			initialRemote: {
+				"/d/a.txt": { content: "a", mtimeMs: BASE_TIME + 1 * SECOND },
+				"/d/deep/b.txt": { content: "b", mtimeMs: BASE_TIME + 2 * SECOND }
+			},
+			steps: [
+				runCycle(),
+				runCycle(),
+				remoteMutate(world => world.cloud.controls.trashPath("/d")),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		const kinds = transferKinds(result.cycles[2]!.messages)
+
+		// Exercises local.ts' subtree cache-prune loop + the deltas collapse: only the parent dir is
+		// deleted, the per-child deletes are collapsed away.
+		expect(kinds.filter(kind => kind === "deleteLocalDirectory")).toHaveLength(1)
+		expect(kinds).not.toContain("deleteLocalFile")
+
+		expect(result.finalLocal["/d"]).toBeUndefined()
+		expect(result.finalLocal["/d/a.txt"]).toBeUndefined()
+		expect(result.finalLocal["/d/deep/b.txt"]).toBeUndefined()
+		expect(allOps(result.cycles[3]!.messages)).toEqual([])
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	// ===== RENAME / MOVE direction =====
+
+	it("P5: a remote file rename renames the local copy (same identity, no re-download)", async () => {
+		let originalUUID: string | undefined
+		let originalInode: number | null = null
+
+		const result = await runScenario({
+			name: "P5",
+			mode: "cloudToLocal",
+			initialRemote: { "/a.txt": { content: "content", mtimeMs: BASE_TIME + 1 * SECOND } },
+			steps: [
+				runCycle(),
+				runCycle(),
+				control(world => {
+					originalUUID = world.cloud.controls.getByPath("/a.txt")?.uuid
+					originalInode = world.vfs.controls.getInode("/local/a.txt")
+				}),
+				remoteMutate(world => world.cloud.controls.movePath("/a.txt", "/b.txt")),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(transferKinds(result.cycles[2]!.messages)).toContain("renameLocalFile")
+		// A rename is not a transfer: the content is not re-downloaded.
+		expect(transferKinds(result.cycles[2]!.messages)).not.toContain("downloadFile")
+
+		expect(result.finalLocal["/a.txt"]).toBeUndefined()
+		expect(result.finalLocal["/b.txt"]).toMatchObject({ type: "file", size: "content".length })
+		expect(readLocal(result.world, "b.txt")).toBe("content")
+
+		// The remote node kept its uuid (a move, not a re-create)…
+		expect(originalUUID).toBeDefined()
+		expect(result.world.cloud.controls.getByPath("/b.txt")?.uuid).toBe(originalUUID)
+		// …and the LOCAL file kept its inode (renamed in place, not deleted+re-downloaded).
+		expect(originalInode).not.toBeNull()
+		expect(result.world.vfs.controls.getInode("/local/b.txt")).toBe(originalInode)
+
+		expect(allOps(result.cycles[3]!.messages)).toEqual([])
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("P6: a remote directory rename renames the subtree locally (ONE op, children reparented)", async () => {
+		const result = await runScenario({
+			name: "P6",
+			mode: "cloudToLocal",
+			initialRemote: {
+				"/d/a.txt": { content: "a", mtimeMs: BASE_TIME + 1 * SECOND },
+				"/d/deep/b.txt": { content: "b", mtimeMs: BASE_TIME + 2 * SECOND }
+			},
+			steps: [
+				runCycle(),
+				runCycle(),
+				remoteMutate(world => world.cloud.controls.movePath("/d", "/e")),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		const kinds = transferKinds(result.cycles[2]!.messages)
+
+		// Exercises local.ts' subtree reparent loop + the deltas collapse: one parent rename carries
+		// the whole subtree — no per-child renames and (crucially) no re-downloads.
+		expect(kinds.filter(kind => kind === "renameLocalDirectory")).toHaveLength(1)
+		expect(kinds).not.toContain("renameLocalFile")
+		expect(kinds).not.toContain("downloadFile")
+
+		expect(result.finalLocal["/d"]).toBeUndefined()
+		expect(result.finalLocal["/d/a.txt"]).toBeUndefined()
+		expect(result.finalLocal["/e"]).toMatchObject({ type: "directory" })
+		expect(result.finalLocal["/e/a.txt"]).toMatchObject({ type: "file", size: 1 })
+		expect(result.finalLocal["/e/deep/b.txt"]).toMatchObject({ type: "file", size: 1 })
+		// The children were carried, not re-fetched — content intact.
+		expect(readLocal(result.world, "e/deep/b.txt")).toBe("b")
+		expect(allOps(result.cycles[3]!.messages)).toEqual([])
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("P7: a local move into a subdirectory moves the remote node (same uuid, no re-upload)", async () => {
+		let originalUUID: string | undefined
+
+		const result = await runScenario({
+			name: "P7",
+			mode: "twoWay",
+			initialLocal: {
+				"/local/dir1/a.txt": "content",
+				// An already-settled empty destination directory, so the move's mkdir is a no-op.
+				"/local/dir2": null
+			},
+			steps: [
+				runCycle(),
+				control(world => {
+					originalUUID = world.cloud.controls.getByPath("/dir1/a.txt")?.uuid
+				}),
+				localMutate(world => renameLocal(world, "dir1/a.txt", "dir2/a.txt")),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		// Move-into-subdir branch of remote.rename (basename unchanged → straight move).
+		expect(transferKinds(result.cycles[1]!.messages)).toContain("renameRemoteFile")
+		expect(transferKinds(result.cycles[1]!.messages)).not.toContain("upload")
+
+		expect(result.finalRemote["/dir1/a.txt"]).toBeUndefined()
+		expect(result.finalRemote["/dir2/a.txt"]).toMatchObject({ type: "file", size: "content".length })
+
+		expect(originalUUID).toBeDefined()
+		expect(result.world.cloud.controls.getByPath("/dir2/a.txt")?.uuid).toBe(originalUUID)
+		expect(allOps(result.cycles[2]!.messages)).toEqual([])
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("P8: a local move to the sync ROOT moves the remote node (same uuid)", async () => {
+		let originalUUID: string | undefined
+
+		const result = await runScenario({
+			name: "P8",
+			mode: "twoWay",
+			initialLocal: { "/local/dir/a.txt": "content" },
+			steps: [
+				runCycle(),
+				control(world => {
+					originalUUID = world.cloud.controls.getByPath("/dir/a.txt")?.uuid
+				}),
+				localMutate(world => renameLocal(world, "dir/a.txt", "a.txt")),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		// Move-to-root branch of remote.rename.
+		expect(transferKinds(result.cycles[1]!.messages)).toContain("renameRemoteFile")
+		expect(transferKinds(result.cycles[1]!.messages)).not.toContain("upload")
+
+		expect(result.finalRemote["/dir/a.txt"]).toBeUndefined()
+		expect(result.finalRemote["/a.txt"]).toMatchObject({ type: "file", size: "content".length })
+		// The (now empty) source directory is untouched on both sides.
+		expect(result.finalRemote["/dir"]).toMatchObject({ type: "directory" })
+
+		expect(originalUUID).toBeDefined()
+		expect(result.world.cloud.controls.getByPath("/a.txt")?.uuid).toBe(originalUUID)
+		expect(allOps(result.cycles[2]!.messages)).toEqual([])
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("P9: a local move that also renames across parents moves the remote node (same uuid)", async () => {
+		let originalUUID: string | undefined
+
+		const result = await runScenario({
+			name: "P9",
+			mode: "twoWay",
+			initialLocal: {
+				"/local/dir1/a.txt": "content",
+				"/local/dir2": null
+			},
+			steps: [
+				runCycle(),
+				control(world => {
+					originalUUID = world.cloud.controls.getByPath("/dir1/a.txt")?.uuid
+				}),
+				localMutate(world => renameLocal(world, "dir1/a.txt", "dir2/b.txt")),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		// Rename-then-move branch of remote.rename (basename changes AND parent changes).
+		expect(transferKinds(result.cycles[1]!.messages)).toContain("renameRemoteFile")
+		expect(transferKinds(result.cycles[1]!.messages)).not.toContain("upload")
+
+		expect(result.finalRemote["/dir1/a.txt"]).toBeUndefined()
+		expect(result.finalRemote["/dir2/b.txt"]).toMatchObject({ type: "file", size: "content".length })
+
+		expect(originalUUID).toBeDefined()
+		expect(result.world.cloud.controls.getByPath("/dir2/b.txt")?.uuid).toBe(originalUUID)
+		expect(allOps(result.cycles[2]!.messages)).toEqual([])
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+})

package/tests/scenarios/q-cycle-lifecycle.test.ts

@@ -0,0 +1,234 @@
+import { describe, it, expect, vi } from "vitest"
+import pathModule from "path"
+import { SYNC_INTERVAL, LOCAL_TRASH_NAME } from "../../src/constants"
+import { createWorld, BASE_TIME, type CreateWorldOptions, type World } from "../harness/world"
+import { snapshotRemote, messagesOfType, countMessages } from "../harness/snapshot"
+import { rmLocal } from "../harness/mutations"
+import { makeErrnoError } from "../fakes/virtual-fs"
+import { type SyncMessage } from "../../src/types"
+
+/**
+ * Category Q — cycle lifecycle internals (behavioral spec §I, §8). These pin the parts of
+ * `Sync.smokeTest` / `Sync.runCycle` / `Sync.cleanupLocalTrash` that the happy-path suite never
+ * reaches: the smoke-test retry loop (local writable/readable + remote-present), the per-cycle gate
+ * that refuses to proceed while an unresolved task error is pending, the catch-all `cycleError`, the
+ * deletion-confirmation re-prompt, and the 30-day local-trash eviction.
+ *
+ * Like Categories G and I these cycles are driven MANUALLY (the smoke-test and confirmation paths
+ * block on real timers), so fake timers are installed, the clock pinned to BASE_TIME, and the sync
+ * interval pumped before each {@link Sync.runCycle}.
+ */
+const FAKE_TIMERS = ["setTimeout", "clearTimeout", "setInterval", "clearInterval", "Date"] as const
+const DAY_MS = 86400000
+
+async function withWorld(options: CreateWorldOptions, body: (world: World) => Promise<void>): Promise<void> {
+	vi.useFakeTimers({ toFake: [...FAKE_TIMERS] })
+	vi.setSystemTime(BASE_TIME)
+
+	try {
+		const world = await createWorld(options)
+
+		await body(world)
+	} finally {
+		vi.useRealTimers()
+	}
+}
+
+/** Drive exactly one cycle (advance the interval so the local-change wait passes, then run). */
+async function plainCycle(world: World): Promise<void> {
+	await vi.advanceTimersByTimeAsync(SYNC_INTERVAL + 1)
+
+	await world.sync.runCycle()
+}
+
+/** The messages appended to the world's stream while `body` runs (a per-cycle slice). */
+async function capture(world: World, body: () => Promise<void>): Promise<SyncMessage[]> {
+	const mark = world.messages.length
+
+	await body()
+
+	return world.messages.slice(mark)
+}
+
+describe("Category Q — cycle lifecycle internals", () => {
+	it("Q1: a failed local writable smoke test emits cycleLocalSmokeTestFailed and retries until the path heals", async () => {
+		await withWorld({ mode: "twoWay" }, async world => {
+			// twoWay smoke-tests the local path for WRITABILITY; an injected EACCES makes isPathWritable false.
+			world.vfs.controls.setError(world.syncPair.localPath, makeErrnoError("EACCES"))
+
+			const messages = await capture(world, async () => {
+				const smoke = world.sync.smokeTest()
+
+				// Let the first attempt fail and schedule its SYNC_INTERVAL retry…
+				await vi.advanceTimersByTimeAsync(1)
+
+				// …then heal the fault so the scheduled retry passes and smokeTest resolves.
+				world.vfs.controls.clearError(world.syncPair.localPath)
+
+				await vi.advanceTimersByTimeAsync(SYNC_INTERVAL + 1)
+				await smoke
+			})
+
+			expect(messagesOfType(messages, "cycleLocalSmokeTestFailed").length).toBeGreaterThan(0)
+			// It recovered (the promise resolved) rather than failing the remote check.
+			expect(messagesOfType(messages, "cycleRemoteSmokeTestFailed").length).toBe(0)
+		})
+	})
+
+	it("Q2: a read-only mode smoke-tests readability instead, and a failed read also retries to recovery", async () => {
+		await withWorld({ mode: "localToCloud" }, async world => {
+			// localToCloud smoke-tests the local path for READABILITY (isPathReadable), a distinct branch.
+			world.vfs.controls.setError(world.syncPair.localPath, makeErrnoError("EACCES"))
+
+			const messages = await capture(world, async () => {
+				const smoke = world.sync.smokeTest()
+
+				await vi.advanceTimersByTimeAsync(1)
+
+				world.vfs.controls.clearError(world.syncPair.localPath)
+
+				await vi.advanceTimersByTimeAsync(SYNC_INTERVAL + 1)
+				await smoke
+			})
+
+			expect(messagesOfType(messages, "cycleLocalSmokeTestFailed").length).toBeGreaterThan(0)
+		})
+	})
+
+	it("Q3: a failed remote smoke test emits cycleRemoteSmokeTestFailed and retries until the remote is present", async () => {
+		await withWorld({ mode: "twoWay" }, async world => {
+			// The local check passes; the remote presence probe throws, so remoteDirPathExisting returns false.
+			world.cloud.controls.setError("present", new Error("present unavailable"))
+
+			const messages = await capture(world, async () => {
+				const smoke = world.sync.smokeTest()
+
+				await vi.advanceTimersByTimeAsync(1)
+
+				world.cloud.controls.clearError("present")
+
+				await vi.advanceTimersByTimeAsync(SYNC_INTERVAL + 1)
+				await smoke
+			})
+
+			expect(messagesOfType(messages, "cycleRemoteSmokeTestFailed").length).toBeGreaterThan(0)
+			// The local smoke test was never the problem here.
+			expect(messagesOfType(messages, "cycleLocalSmokeTestFailed").length).toBe(0)
+		})
+	})
+
+	it("Q4: cleanupLocalTrash evicts entries older than 30 days and keeps recent ones", async () => {
+		await withWorld({ mode: "twoWay" }, async world => {
+			const trashDir = pathModule.posix.join(world.syncPair.localPath, LOCAL_TRASH_NAME)
+
+			world.vfs.ifs.mkdirSync(trashDir, { recursive: true })
+			world.vfs.ifs.writeFileSync(pathModule.posix.join(trashDir, "old.txt"), "stale")
+			world.vfs.ifs.writeFileSync(pathModule.posix.join(trashDir, "fresh.txt"), "recent")
+
+			const now = Date.now()
+			// old.txt: last accessed 31 days ago (beyond the 30-day retention) → evicted.
+			const staleSeconds = (now - DAY_MS * 31) / 1000
+			// fresh.txt: accessed 1 day ago → retained.
+			const recentSeconds = (now - DAY_MS) / 1000
+
+			world.vfs.ifs.utimesSync(pathModule.posix.join(trashDir, "old.txt"), staleSeconds, staleSeconds)
+			world.vfs.ifs.utimesSync(pathModule.posix.join(trashDir, "fresh.txt"), recentSeconds, recentSeconds)
+
+			// Register the eviction interval, then fire one tick (the glob + rm settle within the advance).
+			world.sync.cleanupLocalTrash()
+
+			await vi.advanceTimersByTimeAsync(300000 + 1)
+			await vi.advanceTimersByTimeAsync(1)
+
+			expect(world.vfs.ifs.existsSync(pathModule.posix.join(trashDir, "old.txt"))).toBe(false)
+			expect(world.vfs.ifs.existsSync(pathModule.posix.join(trashDir, "fresh.txt"))).toBe(true)
+		})
+	})
+
+	it("Q5: a cycle that starts with an unresolved task error re-reports it and restarts without doing work", async () => {
+		await withWorld({ mode: "twoWay", initialRemote: { "/dir/a.txt": "content" } }, async world => {
+			// Settle twice so both previous trees + the engine's remote uuid cache are populated.
+			await plainCycle(world)
+			await plainCycle(world)
+
+			// Delete locally but force the remote trash to fail → the failing cycle records a task error.
+			rmLocal(world, "dir/a.txt")
+			world.cloud.controls.setError("trashFile", new Error("backend unavailable"))
+			world.triggerWatcher()
+
+			await plainCycle(world)
+
+			// The NEXT cycle is NOT reset, so it observes the pending task error at the very top and gates:
+			// it re-emits taskErrors + cycleRestarting and returns BEFORE starting the cycle body.
+			const gated = await capture(world, () => plainCycle(world))
+
+			expect(messagesOfType(gated, "taskErrors").length).toBeGreaterThan(0)
+			expect(messagesOfType(gated, "cycleRestarting").length).toBeGreaterThan(0)
+			expect(countMessages(gated, "cycleStarted")).toBe(0)
+		})
+	})
+
+	it("Q6: an error thrown while fetching the trees is caught and surfaced as cycleError", async () => {
+		await withWorld({ mode: "twoWay", initialLocal: { "/local/a.txt": "x" } }, async world => {
+			await plainCycle(world)
+
+			// Make the remote tree fetch throw inside the cycle body (after the lock + smoke test).
+			world.cloud.controls.setError("tree", new Error("tree fetch boom"))
+			world.triggerWatcher()
+
+			const errored = await capture(world, () => plainCycle(world))
+
+			expect(messagesOfType(errored, "cycleError").length).toBeGreaterThan(0)
+		})
+	})
+
+	it("Q7: the deletion-confirmation prompt is re-emitted every second while it waits for a decision", async () => {
+		await withWorld(
+			{
+				mode: "twoWay",
+				requireConfirmationOnLargeDeletion: true,
+				initialLocal: { "/local/a.txt": "a", "/local/b.txt": "b" }
+			},
+			async world => {
+				await plainCycle(world)
+
+				rmLocal(world, "a.txt")
+				rmLocal(world, "b.txt")
+				world.triggerWatcher()
+
+				await vi.advanceTimersByTimeAsync(SYNC_INTERVAL + 1)
+
+				let settled = false
+				const cyclePromise = world.sync.runCycle().finally(() => {
+					settled = true
+				})
+
+				// Advance (without delivering a decision) until the prompt opens.
+				for (let tick = 0; tick < 30 && messagesOfType(world.messages, "confirmDeletion").length === 0; tick++) {
+					await vi.advanceTimersByTimeAsync(1000)
+				}
+
+				const afterOpen = messagesOfType(world.messages, "confirmDeletion").length
+
+				expect(afterOpen).toBeGreaterThan(0)
+
+				// One more second with no decision → the prompt is re-emitted (the waiting branch).
+				await vi.advanceTimersByTimeAsync(1000)
+
+				expect(messagesOfType(world.messages, "confirmDeletion").length).toBeGreaterThan(afterOpen)
+
+				// Now deliver the decision each tick until the cycle completes.
+				for (let tick = 0; tick < 30 && !settled; tick++) {
+					world.worker.confirmDeletion(world.syncPair.uuid, "delete")
+
+					await vi.advanceTimersByTimeAsync(1000)
+				}
+
+				await cyclePromise
+
+				// "delete" was confirmed, so the emptying proceeded.
+				expect(snapshotRemote(world)).toEqual({})
+			}
+		)
+	})
+})