@filen/sync 0.2.1 → 0.3.2

package/tests/scenarios/b-additions.test.ts

@@ -0,0 +1,160 @@
+import { describe, it, expect } from "vitest"
+import { runScenario, runCycle, localMutate, remoteMutate } from "../harness/runner"
+import { transferKinds, allOps, hadTransfers } from "../harness/snapshot"
+import { writeLocal } from "../harness/mutations"
+
+/**
+ * Category B — additions (behavioral spec §B). Additions are applied dynamically (after an initial
+ * converged cycle) so the delta-vs-previous-state path and the watcher trigger are exercised.
+ */
+describe("Category B — additions", () => {
+	it("B1: a file added locally uploads on the next cycle (twoWay)", async () => {
+		const result = await runScenario({
+			name: "B1",
+			mode: "twoWay",
+			steps: [runCycle(), localMutate(world => writeLocal(world, "a.txt", "added")), runCycle(), runCycle()]
+		})
+
+		expect(transferKinds(result.cycles[1]!.messages)).toContain("upload")
+		expect(result.cycles[1]!.remote["/a.txt"]).toMatchObject({ type: "file", size: 5 })
+		expect(allOps(result.cycles[2]!.messages)).toEqual([])
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("B2: a directory tree added locally creates the remote dirs and uploads its files", async () => {
+		const result = await runScenario({
+			name: "B2",
+			mode: "twoWay",
+			steps: [
+				runCycle(),
+				localMutate(world => {
+					writeLocal(world, "docs/x.txt", "x")
+					writeLocal(world, "docs/y.txt", "y")
+				}),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/docs"]).toMatchObject({ type: "directory" })
+		expect(result.finalRemote["/docs/x.txt"]).toMatchObject({ type: "file", size: 1 })
+		expect(result.finalRemote["/docs/y.txt"]).toMatchObject({ type: "file", size: 1 })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("B3: a file added remotely downloads on the next cycle (twoWay)", async () => {
+		const result = await runScenario({
+			name: "B3",
+			mode: "twoWay",
+			steps: [runCycle(), remoteMutate(world => world.cloud.controls.addFile("/r.txt", "remote")), runCycle(), runCycle()]
+		})
+
+		expect(transferKinds(result.cycles[1]!.messages)).toContain("download")
+		expect(result.cycles[1]!.local["/r.txt"]).toMatchObject({ type: "file", size: 6 })
+		expect(allOps(result.cycles[2]!.messages)).toEqual([])
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("B4: a directory tree added remotely creates the local dirs and downloads its files", async () => {
+		const result = await runScenario({
+			name: "B4",
+			mode: "twoWay",
+			steps: [
+				runCycle(),
+				remoteMutate(world => {
+					world.cloud.controls.addDir("/album")
+					world.cloud.controls.addFile("/album/p.txt", "pixels")
+				}),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalLocal["/album"]).toMatchObject({ type: "directory" })
+		expect(result.finalLocal["/album/p.txt"]).toMatchObject({ type: "file", size: 6 })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("B5: a deeply nested new path creates all intermediate directories", async () => {
+		const result = await runScenario({
+			name: "B5",
+			mode: "twoWay",
+			steps: [runCycle(), localMutate(world => writeLocal(world, "p/q/r/s/t.txt", "deep")), runCycle(), runCycle()]
+		})
+
+		expect(result.finalRemote["/p/q/r/s"]).toMatchObject({ type: "directory" })
+		expect(result.finalRemote["/p/q/r/s/t.txt"]).toMatchObject({ type: "file", size: 4 })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("B6: a bulk of new files all upload", async () => {
+		const fileCount = 25
+
+		const result = await runScenario({
+			name: "B6",
+			mode: "twoWay",
+			steps: [
+				runCycle(),
+				localMutate(world => {
+					for (let index = 0; index < fileCount; index++) {
+						writeLocal(world, `bulk/file-${index}.txt`, `content-${index}`)
+					}
+				}),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		for (let index = 0; index < fileCount; index++) {
+			expect(result.finalRemote[`/bulk/file-${index}.txt`]).toMatchObject({ type: "file" })
+		}
+
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("B7: distinct additions on both sides in the same cycle produce the union (twoWay)", async () => {
+		const result = await runScenario({
+			name: "B7",
+			mode: "twoWay",
+			steps: [
+				runCycle(),
+				localMutate(world => writeLocal(world, "local-only.txt", "L")),
+				remoteMutate(world => world.cloud.controls.addFile("/remote-only.txt", "R")),
+				runCycle(),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalLocal["/local-only.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalLocal["/remote-only.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/local-only.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/remote-only.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	// B8: 0-byte files sync normally. (BUG-002 fix: the size<=0 skip in the local and remote tree
+	// builds is removed, so empty files are tracked and transferred like any other file.)
+	it("B8: a new 0-byte file syncs to the remote", async () => {
+		const result = await runScenario({
+			name: "B8",
+			mode: "twoWay",
+			steps: [runCycle(), localMutate(world => writeLocal(world, "empty.txt", "")), runCycle(), runCycle()]
+		})
+
+		expect(result.finalRemote["/empty.txt"]).toMatchObject({ type: "file", size: 0 })
+		expect(hadTransfers(result.messages)).toBe(true)
+	})
+
+	it("B9: a remote 0-byte file downloads to local", async () => {
+		const result = await runScenario({
+			name: "B9",
+			mode: "twoWay",
+			initialRemote: { "/remote-empty.txt": "" },
+			steps: [runCycle(), runCycle()]
+		})
+
+		expect(result.finalLocal["/remote-empty.txt"]).toMatchObject({ type: "file", size: 0 })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+})

package/tests/scenarios/c-modifications.test.ts

@@ -0,0 +1,194 @@
+import { describe, it, expect } from "vitest"
+import { runScenario, runCycle, localMutate, remoteMutate } from "../harness/runner"
+import { BASE_TIME } from "../harness/world"
+import { transferKinds, allOps } from "../harness/snapshot"
+import { writeLocal, writeLocalAt } from "../harness/mutations"
+
+/**
+ * Category C — modifications (behavioral spec §C, §4). Change is attributed against the last-synced
+ * base (previousLocalTree): a local file changed iff its size OR whole-second mtime differs from the
+ * base; a remote file changed iff its uuid changed. Conflicts resolve latest-mtime-wins at whole-
+ * second precision, with an unorderable equal-second tie going to local (C6). Uploads are additionally
+ * deduped by the md5 differing from the stored hash (optional — older files have none), and downloads
+ * gated on the remote uuid having actually changed. The one irreducible gap (C11): a same-second AND
+ * same-size content swap on a file with no stored hash.
+ */
+const SECOND = 1000
+
+describe("Category C — modifications", () => {
+	it("C1: a locally modified file (newer mtime + changed content) uploads", async () => {
+		const result = await runScenario({
+			name: "C1",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "original" },
+			steps: [runCycle(), localMutate(world => writeLocal(world, "a.txt", "modified-longer")), runCycle(), runCycle()]
+		})
+
+		expect(transferKinds(result.cycles[1]!.messages)).toContain("upload")
+		expect(result.finalRemote["/a.txt"]).toMatchObject({ type: "file", size: "modified-longer".length })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("C2: a remotely modified file (newer mtime, new uuid) downloads", async () => {
+		const result = await runScenario({
+			name: "C2",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "original" },
+			steps: [runCycle(), remoteMutate(world => world.cloud.controls.updateFile("/a.txt", "remote-modified")), runCycle(), runCycle()]
+		})
+
+		expect(transferKinds(result.cycles[1]!.messages)).toContain("download")
+		expect(result.finalLocal["/a.txt"]).toMatchObject({ type: "file", size: "remote-modified".length })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("C3: a touch (newer mtime, identical content) does NOT upload (md5 guard)", async () => {
+		const result = await runScenario({
+			name: "C3",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "original" },
+			// Rewrite identical content at a newer mtime.
+			steps: [runCycle(), localMutate(world => writeLocal(world, "a.txt", "original")), runCycle(), runCycle()]
+		})
+
+		// A touch does not upload; content stays identical on both sides, but the local mtime is now
+		// newer than the (un-reuploaded) remote — so only content, not the whole snapshot, converges.
+		expect(allOps(result.cycles[1]!.messages)).toEqual([])
+		expect(allOps(result.cycles[2]!.messages)).toEqual([])
+		expect(result.finalLocal["/a.txt"]!.contentHash).toBe(result.finalRemote["/a.txt"]!.contentHash)
+		expect(result.finalLocal["/a.txt"]!.size).toBe(result.finalRemote["/a.txt"]!.size)
+	})
+
+	it("C4: both sides modified, local newer → local wins (upload)", async () => {
+		const result = await runScenario({
+			name: "C4",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "original" },
+			steps: [
+				runCycle(),
+				localMutate(world => writeLocalAt(world, "a.txt", "LLLLLLLLLL", BASE_TIME + 2 * SECOND)),
+				remoteMutate(world => world.cloud.controls.updateFile("/a.txt", "RRR", { mtimeMs: BASE_TIME + 1 * SECOND })),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/a.txt"]).toMatchObject({ type: "file", size: 10 })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("C5: both sides modified, remote newer → remote wins (download)", async () => {
+		const result = await runScenario({
+			name: "C5",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "original" },
+			steps: [
+				runCycle(),
+				localMutate(world => writeLocalAt(world, "a.txt", "LLL", BASE_TIME + 1 * SECOND)),
+				remoteMutate(world => world.cloud.controls.updateFile("/a.txt", "RRRRRRRRRR", { mtimeMs: BASE_TIME + 2 * SECOND })),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalLocal["/a.txt"]).toMatchObject({ type: "file", size: 10 })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("C6: both sides modified with equal whole-second mtime → local wins the tie (upload)", async () => {
+		const result = await runScenario({
+			name: "C6",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "original" },
+			steps: [
+				runCycle(),
+				localMutate(world => writeLocalAt(world, "a.txt", "LOCAL6", BASE_TIME + 1 * SECOND + 200)),
+				remoteMutate(world => world.cloud.controls.updateFile("/a.txt", "REMOTE-6", { mtimeMs: BASE_TIME + 1 * SECOND + 800 })),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		// Both sides changed since the base and their mtimes floor to the same second (unorderable). Per
+		// the confirmed tie policy local wins: the upload pass runs before the download pass and marks the
+		// path added, so local uploads and the worlds converge to the local content.
+		expect(transferKinds(result.cycles[1]!.messages)).toContain("upload")
+		expect(result.finalRemote["/a.txt"]).toMatchObject({ type: "file", size: "LOCAL6".length })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("C7: a remote mtime bump with an unchanged uuid does NOT download (uuid guard)", async () => {
+		const result = await runScenario({
+			name: "C7",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "original" },
+			steps: [runCycle(), remoteMutate(world => world.cloud.controls.touchRemote("/a.txt", BASE_TIME + 5 * SECOND)), runCycle(), runCycle()]
+		})
+
+		expect(allOps(result.cycles[1]!.messages)).toEqual([])
+		expect(allOps(result.cycles[2]!.messages)).toEqual([])
+		expect(result.finalLocal["/a.txt"]).toMatchObject({ type: "file", size: "original".length })
+	})
+
+	it("C9: truncating a synced file to 0 bytes propagates the empty version (BUG-002)", async () => {
+		// The md5 of an empty file differs from the non-empty original, so the upload gate fires and the
+		// remote becomes a real 0-byte file (rather than the change being skipped as an ignored "empty").
+		const result = await runScenario({
+			name: "C9",
+			mode: "twoWay",
+			initialLocal: { "/local/data.txt": "has content" },
+			steps: [
+				runCycle(),
+				localMutate(world => writeLocalAt(world, "data.txt", "", BASE_TIME + 5 * SECOND)),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/data.txt"]).toMatchObject({ type: "file", size: 0 })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("C10: a same-second size change uploads (base-relative detection, E2E-OBS-002)", async () => {
+		// The edit keeps the SAME whole-second mtime as the last sync but changes the SIZE. The old
+		// side-vs-side gate (local.mtime > remote.mtime) missed it; base-relative detection (size OR
+		// mtime vs previousLocalTree) catches it.
+		const result = await runScenario({
+			name: "C10",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "12345678" },
+			steps: [
+				runCycle(),
+				localMutate(world => writeLocalAt(world, "a.txt", "123", BASE_TIME)),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(transferKinds(result.cycles[1]!.messages)).toContain("upload")
+		expect(result.finalRemote["/a.txt"]).toMatchObject({ type: "file", size: 3 })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("C11: a same-second SAME-size content swap is NOT detected (documented irreducible limit)", async () => {
+		// Same whole-second mtime AND same size, only the bytes differ. With no mtime/size signal and no
+		// reliable stored hash, this is undetectable without re-hashing every file every cycle (which the
+		// perf budget forbids). Codified so a future "fix" that re-hashes unconditionally is a conscious
+		// choice, not an accident. Astronomically rare in practice (it needs an edit within the same
+		// wall-clock second as the last sync) and self-heals on the next edit in a later second.
+		const result = await runScenario({
+			name: "C11",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "AAAA" },
+			steps: [
+				runCycle(),
+				localMutate(world => writeLocalAt(world, "a.txt", "BBBB", BASE_TIME)),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(allOps(result.cycles[1]!.messages)).toEqual([])
+		expect(result.finalLocal["/a.txt"]!.contentHash).not.toBe(result.finalRemote["/a.txt"]!.contentHash)
+	})
+})

package/tests/scenarios/d-deletions.test.ts

@@ -0,0 +1,259 @@
+import { describe, it, expect } from "vitest"
+import { runScenario, runCycle, localMutate, remoteMutate, control } from "../harness/runner"
+import { BASE_TIME } from "../harness/world"
+import { transferKinds } from "../harness/snapshot"
+import { writeLocal, writeLocalAt, touchLocal, readLocal, rmLocal, existsLocal } from "../harness/mutations"
+
+const SECOND = 1000
+
+/**
+ * Category D — deletions and trash (behavioral spec §D, §3, §4). Deletions propagate per the mode
+ * matrix; the losing copy is sent to trash (cloud trash for remote, .filen.trash.local for local)
+ * rather than hard-deleted, unless localTrashDisabled. A directory deletion collapses to a single
+ * parent op (children implied).
+ */
+describe("Category D — deletions", () => {
+	// D1 — a local deletion removes the remote copy (to cloud trash) in both modes that propagate
+	// local→remote deletions: twoWay (diff vs previous) and localToCloud (mirror to current local).
+	for (const mode of ["twoWay", "localToCloud"] as const) {
+		it(`D1/${mode}: deleting a local file deletes the remote copy (to cloud trash)`, async () => {
+			let remoteUUID: string | undefined
+
+			const result = await runScenario({
+				name: `D1-${mode}`,
+				mode,
+				initialLocal: { "/local/a.txt": "content" },
+				steps: [
+					runCycle(),
+					control(world => {
+						remoteUUID = world.cloud.controls.getByPath("/a.txt")?.uuid
+					}),
+					localMutate(world => rmLocal(world, "a.txt")),
+					runCycle(),
+					runCycle()
+				]
+			})
+
+			expect(transferKinds(result.cycles[1]!.messages)).toContain("deleteRemoteFile")
+			expect(result.finalRemote["/a.txt"]).toBeUndefined()
+			expect(result.finalLocal["/a.txt"]).toBeUndefined()
+
+			// No data loss: the remote copy went to cloud trash, not a permanent delete.
+			expect(remoteUUID).toBeDefined()
+			expect(await result.world.cloud.sdk.api(3).dir().present({ uuid: remoteUUID! })).toEqual({ present: true, trash: true })
+		})
+	}
+
+	// D2 — a remote deletion removes the local copy (to .filen.trash.local) in both modes that
+	// propagate remote→local deletions: twoWay and cloudToLocal.
+	for (const mode of ["twoWay", "cloudToLocal"] as const) {
+		it(`D2/${mode}: deleting a remote file deletes the local copy (to .filen.trash.local)`, async () => {
+			const result = await runScenario({
+				name: `D2-${mode}`,
+				mode,
+				initialRemote: { "/a.txt": "content" },
+				steps: [
+					runCycle(),
+					remoteMutate(world => world.cloud.controls.trashPath("/a.txt")),
+					runCycle(),
+					runCycle()
+				]
+			})
+
+			expect(transferKinds(result.cycles[1]!.messages)).toContain("deleteLocalFile")
+			// The normalized snapshot excludes the trash dir, so the file is gone from the synced tree…
+			expect(result.finalLocal["/a.txt"]).toBeUndefined()
+			expect(result.finalRemote["/a.txt"]).toBeUndefined()
+			// …but it was moved to the local trash, not hard-deleted (no data loss).
+			expect(existsLocal(result.world, ".filen.trash.local/a.txt")).toBe(true)
+		})
+	}
+
+	it("D3: with localTrashDisabled, a remote deletion HARD-deletes the local copy (no trash)", async () => {
+		const result = await runScenario({
+			name: "D3",
+			mode: "twoWay",
+			localTrashDisabled: true,
+			initialRemote: { "/a.txt": "content" },
+			steps: [runCycle(), remoteMutate(world => world.cloud.controls.trashPath("/a.txt")), runCycle(), runCycle()]
+		})
+
+		expect(transferKinds(result.cycles[1]!.messages)).toContain("deleteLocalFile")
+		expect(result.finalLocal["/a.txt"]).toBeUndefined()
+		// Hard delete: the file is not in the local trash either.
+		expect(existsLocal(result.world, ".filen.trash.local/a.txt")).toBe(false)
+	})
+
+	it("D4: deleting a directory with children emits ONE parent delete (children collapsed)", async () => {
+		const result = await runScenario({
+			name: "D4",
+			mode: "twoWay",
+			initialLocal: {
+				"/local/dir/a.txt": "a",
+				"/local/dir/b.txt": "b",
+				"/local/dir/sub/c.txt": "c"
+			},
+			steps: [runCycle(), localMutate(world => rmLocal(world, "dir")), runCycle(), runCycle()]
+		})
+
+		const kinds = transferKinds(result.cycles[1]!.messages)
+
+		// Only the parent directory delete is emitted; the per-child file/dir deletes are collapsed.
+		expect(kinds).toContain("deleteRemoteDirectory")
+		expect(kinds.filter(kind => kind === "deleteRemoteDirectory")).toHaveLength(1)
+		expect(kinds).not.toContain("deleteRemoteFile")
+
+		expect(result.finalRemote["/dir"]).toBeUndefined()
+		expect(result.finalRemote["/dir/a.txt"]).toBeUndefined()
+		expect(result.finalRemote["/dir/sub/c.txt"]).toBeUndefined()
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("D5/localBackup: a local deletion does NOT propagate to the remote backup", async () => {
+		const result = await runScenario({
+			name: "D5-localBackup",
+			mode: "localBackup",
+			initialLocal: { "/local/a.txt": "content" },
+			steps: [runCycle(), localMutate(world => rmLocal(world, "a.txt")), runCycle(), runCycle()]
+		})
+
+		// Backup modes never delete the target. The remote keeps the file; local is not re-downloaded.
+		expect(transferKinds(result.messages)).not.toContain("deleteRemoteFile")
+		expect(result.finalRemote["/a.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalLocal["/a.txt"]).toBeUndefined()
+	})
+
+	it("D5/cloudBackup: a remote deletion does NOT propagate to the local backup", async () => {
+		const result = await runScenario({
+			name: "D5-cloudBackup",
+			mode: "cloudBackup",
+			initialRemote: { "/a.txt": "content" },
+			steps: [runCycle(), remoteMutate(world => world.cloud.controls.trashPath("/a.txt")), runCycle(), runCycle()]
+		})
+
+		// Backup modes never delete the target. Local keeps the file; it is not re-uploaded.
+		expect(transferKinds(result.messages)).not.toContain("deleteLocalFile")
+		expect(result.finalLocal["/a.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/a.txt"]).toBeUndefined()
+	})
+
+	it("D6: deleting one file leaves the sibling files on the target untouched", async () => {
+		const result = await runScenario({
+			name: "D6",
+			mode: "twoWay",
+			initialLocal: {
+				"/local/a.txt": "aaa",
+				"/local/b.txt": "bbb",
+				"/local/c.txt": "ccc"
+			},
+			steps: [runCycle(), localMutate(world => rmLocal(world, "b.txt")), runCycle(), runCycle()]
+		})
+
+		const kinds = transferKinds(result.cycles[1]!.messages)
+
+		// Exactly one delete; the untouched siblings are not re-transferred.
+		expect(kinds.filter(kind => kind === "deleteRemoteFile")).toHaveLength(1)
+		expect(result.finalRemote["/a.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/c.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/b.txt"]).toBeUndefined()
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("D7: deleting then re-creating the same name is a delete+add (fresh uuid), not a rename", async () => {
+		let originalUUID: string | undefined
+
+		const result = await runScenario({
+			name: "D7",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "v1" },
+			steps: [
+				runCycle(),
+				control(world => {
+					originalUUID = world.cloud.controls.getByPath("/a.txt")?.uuid
+				}),
+				localMutate(world => rmLocal(world, "a.txt")),
+				runCycle(),
+				localMutate(world => writeLocal(world, "a.txt", "version-2")),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		// The deletion is observed in its own cycle, the re-creation as an add in a later cycle.
+		expect(transferKinds(result.cycles[1]!.messages)).toContain("deleteRemoteFile")
+		expect(transferKinds(result.cycles[2]!.messages)).toContain("upload")
+
+		// Nothing is renamed at any point.
+		expect(transferKinds(result.messages).filter(kind => kind.startsWith("renameRemote"))).toEqual([])
+
+		// The recreated file is a brand-new remote node, not the resurrected original.
+		const finalUUID = result.world.cloud.controls.getByPath("/a.txt")?.uuid
+
+		expect(originalUUID).toBeDefined()
+		expect(finalUUID).toBeDefined()
+		expect(finalUUID).not.toBe(originalUUID)
+		expect(result.finalRemote["/a.txt"]).toMatchObject({ type: "file", size: "version-2".length })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	// D8–D10 — newer-modify-wins over a remote delete (E2E-OBS-001). When a file is deleted remotely
+	// but modified locally since the last sync, the local modification survives: the file is re-uploaded
+	// (resurrected) rather than deleted. "Modified" means a real CONTENT change (size differs, or the
+	// cached upload hash differs) — a bare mtime touch is not enough and lets the delete proceed.
+	it("D8: a local content modify (size changed) survives a remote delete — newer-modify-wins (E2E-OBS-001)", async () => {
+		const result = await runScenario({
+			name: "D8",
+			mode: "twoWay",
+			initialLocal: { "/local/f.txt": "v1" },
+			steps: [
+				runCycle(),
+				localMutate(world => writeLocalAt(world, "f.txt", "v2-modified-longer", BASE_TIME + 5 * SECOND)),
+				remoteMutate(world => world.cloud.controls.deletePath("/f.txt")),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(transferKinds(result.cycles[1]!.messages)).toContain("upload")
+		expect(result.finalRemote["/f.txt"]).toMatchObject({ type: "file", size: "v2-modified-longer".length })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+		expect(readLocal(result.world, "f.txt")).toBe("v2-modified-longer")
+	})
+
+	it("D9: a bare local touch (no content change) does NOT survive a remote delete — the delete wins", async () => {
+		const result = await runScenario({
+			name: "D9",
+			mode: "twoWay",
+			initialLocal: { "/local/f.txt": "v1" },
+			steps: [
+				runCycle(),
+				localMutate(world => touchLocal(world, "f.txt", BASE_TIME + 5 * SECOND)),
+				remoteMutate(world => world.cloud.controls.deletePath("/f.txt")),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/f.txt"]).toBeUndefined()
+		expect(existsLocal(result.world, "f.txt")).toBe(false)
+	})
+
+	it("D10: a same-size content change survives a remote delete via the cached upload hash (E2E-OBS-001)", async () => {
+		const result = await runScenario({
+			name: "D10",
+			mode: "twoWay",
+			initialLocal: { "/local/f.txt": "AAAA" },
+			steps: [
+				runCycle(),
+				localMutate(world => writeLocalAt(world, "f.txt", "BBBB", BASE_TIME + 5 * SECOND)),
+				remoteMutate(world => world.cloud.controls.deletePath("/f.txt")),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/f.txt"]).toMatchObject({ type: "file", size: 4 })
+		expect(readLocal(result.world, "f.txt")).toBe("BBBB")
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+})