@filen/sync 0.2.1 → 0.3.2

package/tests/scenarios/y-conflict-matrix.test.ts

@@ -0,0 +1,292 @@
+import { describe, it, expect } from "vitest"
+import { runScenario, runCycle, localMutate, remoteMutate } from "../harness/runner"
+import { BASE_TIME } from "../harness/world"
+import { transferKinds } from "../harness/snapshot"
+import { writeLocalAt, renameLocal, rmLocal, readLocal, existsLocal } from "../harness/mutations"
+
+/**
+ * Category Y — the cross-side conflict matrix for twoWay (behavioral spec §C/§D/§E intersection). Every
+ * case here is a SAME-PATH (or same-identity) conflict where both sides acted since the last sync, plus
+ * the single-cycle rename+modify race. The engine must always reach a fixed point (finalLocal ===
+ * finalRemote) with NO silent data loss. Resolution policies (confirmed with the maintainer):
+ *
+ *   • newest-mtime wins for add-vs-add and modify-vs-modify (equal whole-second → local, §C6);
+ *   • a real CONTENT modification on EITHER side beats the other side's delete (resurrect) — symmetric;
+ *   • a rename whose source the other side deleted/modified/renamed degrades to keep-the-data (the
+ *     renamed file is re-added under its new name; the other side's change is applied too) so the worlds
+ *     still converge with both edits preserved;
+ *   • rename + in-place modify of the SAME file in ONE cycle keeps BOTH (the new name AND the new bytes).
+ *
+ * These pin the fixes for F1–F4/F7 (docs/hardening-findings.md). Convergence + no-data-loss is the
+ * invariant; exact surviving paths are asserted where the policy fixes them.
+ */
+const SECOND = 1000
+
+describe("Category Y — cross-side conflict matrix (twoWay)", () => {
+	it("Y1: add(local) vs add(remote) same path, local newer → local content wins, converges", async () => {
+		const result = await runScenario({
+			name: "Y1",
+			mode: "twoWay",
+			steps: [
+				localMutate(world => writeLocalAt(world, "x.txt", "LOCAL-NEWER", BASE_TIME + 5 * SECOND)),
+				remoteMutate(world => world.cloud.controls.addFile("/x.txt", "remote-older", { mtimeMs: BASE_TIME + 2 * SECOND })),
+				runCycle(),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalLocal).toEqual(result.finalRemote)
+		expect(result.finalRemote["/x.txt"]).toMatchObject({ type: "file", size: "LOCAL-NEWER".length })
+	})
+
+	it("Y2: add(local) vs add(remote) same path, remote newer → remote content wins, converges", async () => {
+		const result = await runScenario({
+			name: "Y2",
+			mode: "twoWay",
+			steps: [
+				localMutate(world => writeLocalAt(world, "x.txt", "local-older", BASE_TIME + 2 * SECOND)),
+				remoteMutate(world => world.cloud.controls.addFile("/x.txt", "REMOTE-NEWER-LONGER", { mtimeMs: BASE_TIME + 5 * SECOND })),
+				runCycle(),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalLocal).toEqual(result.finalRemote)
+		expect(result.finalLocal["/x.txt"]).toMatchObject({ type: "file", size: "REMOTE-NEWER-LONGER".length })
+	})
+
+	it("Y3: delete(local) vs delete(remote) same path → converges to empty, no error", async () => {
+		const result = await runScenario({
+			name: "Y3",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "data" },
+			steps: [
+				runCycle(),
+				localMutate(world => rmLocal(world, "a.txt")),
+				remoteMutate(world => world.cloud.controls.trashPath("/a.txt")),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalLocal["/a.txt"]).toBeUndefined()
+		expect(result.finalRemote["/a.txt"]).toBeUndefined()
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	// F7 — symmetric resurrect: a remote modification beats a local delete (mirror of OBS-001/D8).
+	it("Y4: delete(local) vs modify(remote, newer) → the remote modification wins, resurrected", async () => {
+		const result = await runScenario({
+			name: "Y4",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "v1" },
+			steps: [
+				runCycle(),
+				localMutate(world => rmLocal(world, "a.txt")),
+				remoteMutate(world => world.cloud.controls.updateFile("/a.txt", "REMOTE-MODIFIED-NEWER", { mtimeMs: BASE_TIME + 9 * SECOND })),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalLocal).toEqual(result.finalRemote)
+		expect(result.finalRemote["/a.txt"]).toMatchObject({ type: "file", size: "REMOTE-MODIFIED-NEWER".length })
+		expect(readLocal(result.world, "a.txt")).toBe("REMOTE-MODIFIED-NEWER")
+	})
+
+	// The pre-existing direction (OBS-001) stays correct: a local modification beats a remote delete.
+	it("Y5: modify(local) vs delete(remote) → the local modification wins, resurrected", async () => {
+		const result = await runScenario({
+			name: "Y5",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "v1" },
+			steps: [
+				runCycle(),
+				localMutate(world => writeLocalAt(world, "a.txt", "LOCAL-MODIFIED-LONGER", BASE_TIME + 9 * SECOND)),
+				remoteMutate(world => world.cloud.controls.deletePath("/a.txt")),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalLocal).toEqual(result.finalRemote)
+		expect(result.finalRemote["/a.txt"]).toMatchObject({ type: "file", size: "LOCAL-MODIFIED-LONGER".length })
+	})
+
+	// F1 — rename + in-place modify of the SAME file in ONE cycle: keep the new name AND the new bytes.
+	it("Y6: rename(local a→b) + modify b in one cycle → converges to b with the NEW content", async () => {
+		const result = await runScenario({
+			name: "Y6",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "original-content" },
+			steps: [
+				runCycle(),
+				localMutate(world => {
+					renameLocal(world, "a.txt", "b.txt")
+					writeLocalAt(world, "b.txt", "BRAND-NEW-CONTENT-X", BASE_TIME + 5 * SECOND)
+				}),
+				runCycle(),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalLocal).toEqual(result.finalRemote)
+		expect(result.finalRemote["/a.txt"]).toBeUndefined()
+		expect(result.finalRemote["/b.txt"]).toMatchObject({ type: "file", size: "BRAND-NEW-CONTENT-X".length })
+		expect(readLocal(result.world, "b.txt")).toBe("BRAND-NEW-CONTENT-X")
+	})
+
+	// F2 — local rename a→b races a remote delete of a. The renamed file (b) is data the user kept, so
+	// it survives on both sides; the remote's delete of the old name is moot.
+	it("Y7: rename(local a→b) vs delete(remote a) → converges to {b}, data preserved", async () => {
+		const result = await runScenario({
+			name: "Y7",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "data" },
+			steps: [
+				runCycle(),
+				localMutate(world => renameLocal(world, "a.txt", "b.txt")),
+				remoteMutate(world => world.cloud.controls.trashPath("/a.txt")),
+				runCycle(),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalLocal).toEqual(result.finalRemote)
+		expect(result.finalRemote["/a.txt"]).toBeUndefined()
+		expect(result.finalRemote["/b.txt"]).toMatchObject({ type: "file", size: "data".length })
+		expect(existsLocal(result.world, "b.txt")).toBe(true)
+	})
+
+	// F3 — local rename a→b races a remote modify of a. Keep-both: the remote's new content survives at
+	// a, the local rename result survives at b. No silent loss either way.
+	it("Y8: rename(local a→b) vs modify(remote a) → converges keeping both a and b", async () => {
+		const result = await runScenario({
+			name: "Y8",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "orig" },
+			steps: [
+				runCycle(),
+				localMutate(world => renameLocal(world, "a.txt", "b.txt")),
+				remoteMutate(world => world.cloud.controls.updateFile("/a.txt", "REMOTE-MOD", { mtimeMs: BASE_TIME + 9 * SECOND })),
+				runCycle(),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalLocal).toEqual(result.finalRemote)
+		expect(result.finalRemote["/a.txt"]).toMatchObject({ type: "file", size: "REMOTE-MOD".length })
+		expect(result.finalRemote["/b.txt"]).toMatchObject({ type: "file", size: "orig".length })
+	})
+
+	// F4 — both sides rename the same file to DIFFERENT names. Keep-both: each rename is preserved.
+	it("Y9: rename(local a→X) vs rename(remote a→Y) → converges keeping both X and Y", async () => {
+		const result = await runScenario({
+			name: "Y9",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "data" },
+			steps: [
+				runCycle(),
+				localMutate(world => renameLocal(world, "a.txt", "local-name.txt")),
+				remoteMutate(world => world.cloud.controls.movePath("/a.txt", "/remote-name.txt")),
+				runCycle(),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalLocal).toEqual(result.finalRemote)
+		expect(result.finalRemote["/local-name.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/remote-name.txt"]).toMatchObject({ type: "file" })
+	})
+
+	// F2 symmetric — remote rename a→b races a local delete of a.
+	it("Y10: rename(remote a→b) vs delete(local a) → converges to {b}, data preserved", async () => {
+		const result = await runScenario({
+			name: "Y10",
+			mode: "twoWay",
+			initialRemote: { "/a.txt": "data" },
+			steps: [
+				runCycle(),
+				remoteMutate(world => world.cloud.controls.movePath("/a.txt", "/b.txt")),
+				localMutate(world => rmLocal(world, "a.txt")),
+				runCycle(),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalLocal).toEqual(result.finalRemote)
+		expect(result.finalRemote["/a.txt"]).toBeUndefined()
+		expect(result.finalRemote["/b.txt"]).toMatchObject({ type: "file", size: "data".length })
+	})
+
+	// F3 symmetric — remote rename a→b races a local modify of a.
+	it("Y11: rename(remote a→b) vs modify(local a) → converges keeping both a and b", async () => {
+		const result = await runScenario({
+			name: "Y11",
+			mode: "twoWay",
+			initialRemote: { "/a.txt": "orig" },
+			steps: [
+				runCycle(),
+				remoteMutate(world => world.cloud.controls.movePath("/a.txt", "/b.txt")),
+				localMutate(world => writeLocalAt(world, "a.txt", "LOCAL-MOD", BASE_TIME + 9 * SECOND)),
+				runCycle(),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalLocal).toEqual(result.finalRemote)
+		expect(result.finalRemote["/a.txt"]).toMatchObject({ type: "file", size: "LOCAL-MOD".length })
+		expect(result.finalRemote["/b.txt"]).toMatchObject({ type: "file", size: "orig".length })
+	})
+
+	// Convergence under a same-cycle delete on one side and an unrelated add on the other (no false conflict).
+	it("Y12: delete(local a) + add(remote b) in one cycle → both applied, converges", async () => {
+		const result = await runScenario({
+			name: "Y12",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "data" },
+			steps: [
+				runCycle(),
+				localMutate(world => rmLocal(world, "a.txt")),
+				remoteMutate(world => world.cloud.controls.addFile("/b.txt", "new-remote", { mtimeMs: BASE_TIME + 3 * SECOND })),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalLocal).toEqual(result.finalRemote)
+		expect(result.finalRemote["/a.txt"]).toBeUndefined()
+		expect(result.finalRemote["/b.txt"]).toMatchObject({ type: "file" })
+	})
+
+	// A second settling pass must be a true fixed point for a representative conflict (idempotence).
+	it("Y13: a resolved conflict is idempotent (no work on the next settled cycle)", async () => {
+		const result = await runScenario({
+			name: "Y13",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "v1" },
+			steps: [
+				runCycle(),
+				localMutate(world => rmLocal(world, "a.txt")),
+				remoteMutate(world => world.cloud.controls.updateFile("/a.txt", "REMOTE-WINS", { mtimeMs: BASE_TIME + 9 * SECOND })),
+				runCycle(),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalLocal).toEqual(result.finalRemote)
+		// The last cycle did no file transfers.
+		const last = result.cycles[result.cycles.length - 1]!
+
+		expect(transferKinds(last.messages).filter(k => ["upload", "uploadFile", "download", "downloadFile"].includes(k))).toEqual([])
+	})
+})

package/tests/scenarios/z-cross-ops.test.ts

@@ -0,0 +1,285 @@
+import { describe, it, expect } from "vitest"
+import { runScenario, runCycle, localMutate } from "../harness/runner"
+import { BASE_TIME } from "../harness/world"
+import { allOps } from "../harness/snapshot"
+import { writeLocal, writeLocalAt, mkdirLocal, rmLocal, renameLocal, readLocal } from "../harness/mutations"
+
+/**
+ * Category Z — multiple operations composed in a SINGLE cycle (twoWay). These stress the phase-ordered
+ * runner and the rename/collapse/modify interplay together (the area that hid F1). Every case must reach
+ * a fixed point with the data intact. Distinct from Category E/R (rename mechanics), P (cross-dir moves),
+ * K (bulk), and Y (cross-side conflicts): here several DIFFERENT op types land in one beat on one side.
+ */
+const SECOND = 1000
+
+describe("Category Z — multi-op compositions in one cycle (twoWay)", () => {
+	it("Z1: move a file OUT of a directory and delete that directory in one cycle", async () => {
+		const result = await runScenario({
+			name: "Z1",
+			mode: "twoWay",
+			initialLocal: { "/local/dir/f.txt": "keepme", "/local/dir/other.txt": "other" },
+			steps: [
+				runCycle(),
+				localMutate(world => {
+					renameLocal(world, "dir/f.txt", "f.txt")
+					rmLocal(world, "dir")
+				}),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		// The moved-out file survives at the root; the directory (and its remaining child) are gone.
+		expect(result.finalRemote["/f.txt"]).toMatchObject({ type: "file", size: "keepme".length })
+		expect(result.finalRemote["/dir"]).toBeUndefined()
+		expect(result.finalRemote["/dir/other.txt"]).toBeUndefined()
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("Z2: rename a directory AND modify a child within it in one cycle (child's new content propagates)", async () => {
+		const result = await runScenario({
+			name: "Z2",
+			mode: "twoWay",
+			initialLocal: { "/local/dir/child.txt": "old", "/local/dir/sibling.txt": "sib" },
+			steps: [
+				runCycle(),
+				localMutate(world => {
+					renameLocal(world, "dir", "dir2")
+					writeLocalAt(world, "dir2/child.txt", "NEW-CONTENT-LONGER", BASE_TIME + 5 * SECOND)
+				}),
+				runCycle(),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/dir"]).toBeUndefined()
+		expect(result.finalRemote["/dir2/child.txt"]).toMatchObject({ type: "file", size: "NEW-CONTENT-LONGER".length })
+		expect(result.finalRemote["/dir2/sibling.txt"]).toMatchObject({ type: "file", size: "sib".length })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("Z3: move a subtree into another directory AND modify a file within the moved subtree", async () => {
+		const result = await runScenario({
+			name: "Z3",
+			mode: "twoWay",
+			initialLocal: { "/local/src/deep/data.txt": "old", "/local/dest/keep.txt": "k" },
+			steps: [
+				runCycle(),
+				localMutate(world => {
+					renameLocal(world, "src", "dest/src")
+					writeLocalAt(world, "dest/src/deep/data.txt", "MOVED-AND-CHANGED", BASE_TIME + 5 * SECOND)
+				}),
+				runCycle(),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/src"]).toBeUndefined()
+		expect(result.finalRemote["/dest/src/deep/data.txt"]).toMatchObject({ type: "file", size: "MOVED-AND-CHANGED".length })
+		expect(result.finalRemote["/dest/keep.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("Z4: rename a directory AND add a brand-new file into the renamed directory in one cycle", async () => {
+		const result = await runScenario({
+			name: "Z4",
+			mode: "twoWay",
+			initialLocal: { "/local/dir/existing.txt": "e" },
+			steps: [
+				runCycle(),
+				localMutate(world => {
+					renameLocal(world, "dir", "dir2")
+					writeLocal(world, "dir2/fresh.txt", "fresh")
+				}),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/dir"]).toBeUndefined()
+		expect(result.finalRemote["/dir2/existing.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/dir2/fresh.txt"]).toMatchObject({ type: "file", size: "fresh".length })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("Z5: swap two directory names (a↔b) via a temp in one cycle", async () => {
+		const result = await runScenario({
+			name: "Z5",
+			mode: "twoWay",
+			initialLocal: { "/local/a/fa.txt": "AAA", "/local/b/fb.txt": "BBB" },
+			steps: [
+				runCycle(),
+				localMutate(world => {
+					renameLocal(world, "a", "tmp")
+					renameLocal(world, "b", "a")
+					renameLocal(world, "tmp", "b")
+				}),
+				runCycle(),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		// a now holds B's content, b holds A's content.
+		expect(result.finalRemote["/a/fb.txt"]).toMatchObject({ type: "file", size: "BBB".length })
+		expect(result.finalRemote["/b/fa.txt"]).toMatchObject({ type: "file", size: "AAA".length })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("Z6: cross-directory move AND content modify of the same file in one cycle", async () => {
+		const result = await runScenario({
+			name: "Z6",
+			mode: "twoWay",
+			initialLocal: { "/local/from/f.txt": "original", "/local/to/keep.txt": "k" },
+			steps: [
+				runCycle(),
+				localMutate(world => {
+					renameLocal(world, "from/f.txt", "to/f.txt")
+					writeLocalAt(world, "to/f.txt", "MOVED-CONTENT", BASE_TIME + 5 * SECOND)
+				}),
+				runCycle(),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/from/f.txt"]).toBeUndefined()
+		expect(result.finalRemote["/to/f.txt"]).toMatchObject({ type: "file", size: "MOVED-CONTENT".length })
+		expect(readLocal(result.world, "to/f.txt")).toBe("MOVED-CONTENT")
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("Z7: delete one file, rename another, and add a third — all in one cycle", async () => {
+		const result = await runScenario({
+			name: "Z7",
+			mode: "twoWay",
+			initialLocal: { "/local/del.txt": "d", "/local/ren.txt": "r" },
+			steps: [
+				runCycle(),
+				localMutate(world => {
+					rmLocal(world, "del.txt")
+					renameLocal(world, "ren.txt", "renamed.txt")
+					writeLocal(world, "added.txt", "a")
+				}),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/del.txt"]).toBeUndefined()
+		expect(result.finalRemote["/ren.txt"]).toBeUndefined()
+		expect(result.finalRemote["/renamed.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/added.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("Z8: create a directory and move an existing file into it in one cycle", async () => {
+		const result = await runScenario({
+			name: "Z8",
+			mode: "twoWay",
+			initialLocal: { "/local/f.txt": "data" },
+			steps: [
+				runCycle(),
+				localMutate(world => {
+					mkdirLocal(world, "newdir")
+					renameLocal(world, "f.txt", "newdir/f.txt")
+				}),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/newdir"]).toMatchObject({ type: "directory" })
+		expect(result.finalRemote["/newdir/f.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/f.txt"]).toBeUndefined()
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("Z9: a rename round-trip across cycles (a→b→a) ends as an identity no-op", async () => {
+		let uuidBefore: string | undefined
+
+		const result = await runScenario({
+			name: "Z9",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "data" },
+			steps: [
+				runCycle(),
+				localMutate(world => {
+					uuidBefore = world.cloud.controls.getByPath("/a.txt")?.uuid
+					renameLocal(world, "a.txt", "b.txt")
+				}),
+				runCycle(),
+				localMutate(world => renameLocal(world, "b.txt", "a.txt")),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/a.txt"]).toMatchObject({ type: "file", size: "data".length })
+		expect(result.finalRemote["/b.txt"]).toBeUndefined()
+		// Identity preserved through the round trip (no re-upload, same remote node).
+		expect(result.world.cloud.controls.getByPath("/a.txt")?.uuid).toBe(uuidBefore)
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("Z10: modify a file and rename its parent directory in one cycle", async () => {
+		const result = await runScenario({
+			name: "Z10",
+			mode: "twoWay",
+			initialLocal: { "/local/parent/data.txt": "old", "/local/parent/static.txt": "s" },
+			steps: [
+				runCycle(),
+				localMutate(world => {
+					writeLocalAt(world, "parent/data.txt", "EDITED-IN-PLACE", BASE_TIME + 5 * SECOND)
+					renameLocal(world, "parent", "parent-renamed")
+				}),
+				runCycle(),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/parent"]).toBeUndefined()
+		expect(result.finalRemote["/parent-renamed/data.txt"]).toMatchObject({ type: "file", size: "EDITED-IN-PLACE".length })
+		expect(result.finalRemote["/parent-renamed/static.txt"]).toMatchObject({ type: "file" })
+		expect(readLocal(result.world, "parent-renamed/data.txt")).toBe("EDITED-IN-PLACE")
+		expect(result.finalLocal).toEqual(result.finalRemote)
+		// Settled.
+		expect(allOps(result.cycles[result.cycles.length - 1]!.messages)).toEqual([])
+	})
+
+	it("Z11: a deep mixed batch (adds, a delete, a move, a modify) converges and is idempotent", async () => {
+		const result = await runScenario({
+			name: "Z11",
+			mode: "twoWay",
+			initialLocal: {
+				"/local/keep/a.txt": "a",
+				"/local/keep/b.txt": "b",
+				"/local/gone/x.txt": "x",
+				"/local/move-me.txt": "m"
+			},
+			steps: [
+				runCycle(),
+				localMutate(world => {
+					writeLocal(world, "keep/c.txt", "c")
+					writeLocalAt(world, "keep/a.txt", "a-edited", BASE_TIME + 5 * SECOND)
+					rmLocal(world, "gone")
+					renameLocal(world, "move-me.txt", "keep/move-me.txt")
+				}),
+				runCycle(),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/keep/c.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/keep/a.txt"]).toMatchObject({ type: "file", size: "a-edited".length })
+		expect(result.finalRemote["/gone"]).toBeUndefined()
+		expect(result.finalRemote["/keep/move-me.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/move-me.txt"]).toBeUndefined()
+		expect(result.finalLocal).toEqual(result.finalRemote)
+		expect(allOps(result.cycles[result.cycles.length - 1]!.messages)).toEqual([])
+	})
+})