@filen/sync 0.2.1 → 0.3.2

package/tests/scenarios/r-rename-stress.test.ts

@@ -0,0 +1,208 @@
+import { describe, it, expect } from "vitest"
+import { runScenario, runCycle, localMutate, type Step } from "../harness/runner"
+import { BASE_TIME } from "../harness/world"
+import { allOps, transferKinds } from "../harness/snapshot"
+import { renameLocal, writeLocalAt } from "../harness/mutations"
+
+/**
+ * Category R — rename/move stress (BUG-004 reproduction net). The delta engine collapses child
+ * rename/move/delete ops into their parent directory op (deltas.ts ~553-612). This pass composes
+ * nested and chained renames; these deterministic cases hammer that composition to surface any
+ * mis-collapse (a duplicated op, a dropped op, or a wrong from-path) that a black-box cycle CAN
+ * reproduce. The catalogued BUG-004 also has a pure mid-cycle timing component (mutations landing
+ * between tree-read and task-exec) which only the Phase 3 live e2e can exercise; this file pins the
+ * deterministic half so a regression there is caught here.
+ *
+ * Every case asserts convergence (worlds identical) and idempotence (a settled cycle does no work).
+ */
+const SECOND = 1000
+
+function expectConverged(result: { finalLocal: Record<string, unknown>; finalRemote: Record<string, unknown>; cycles: { messages: unknown[] }[] }): void {
+	expect(result.finalLocal).toEqual(result.finalRemote)
+
+	const lastCycle = result.cycles[result.cycles.length - 1]!
+
+	expect(allOps(lastCycle.messages as never)).toEqual([])
+}
+
+describe("Category R — rename/move stress (BUG-004 net)", () => {
+	it("RS1: a parent-dir rename composed with a child rename converges (child from-path rewritten)", async () => {
+		const result = await runScenario({
+			name: "RS1",
+			mode: "twoWay",
+			initialLocal: { "/local/a/c.txt": "x" },
+			steps: [
+				runCycle(),
+				runCycle(),
+				// Rename the parent dir, THEN rename the (now-moved) child to a new name in the same beat.
+				localMutate(world => {
+					renameLocal(world, "a", "b")
+					renameLocal(world, "b/c.txt", "b/d.txt")
+				}),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/b/d.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/a"]).toBeUndefined()
+		expect(result.finalRemote["/b/c.txt"]).toBeUndefined()
+		expectConverged(result)
+	})
+
+	it("RS2: a chained directory rename within one beat (a -> b -> e) converges", async () => {
+		const result = await runScenario({
+			name: "RS2",
+			mode: "twoWay",
+			initialLocal: { "/local/a/c.txt": "x", "/local/a/deep/d.txt": "y" },
+			steps: [
+				runCycle(),
+				runCycle(),
+				localMutate(world => {
+					renameLocal(world, "a", "b")
+					renameLocal(world, "b", "e")
+				}),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/e/c.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/e/deep/d.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/a"]).toBeUndefined()
+		expect(result.finalRemote["/b"]).toBeUndefined()
+		expectConverged(result)
+	})
+
+	it("RS3: a three-level nested directory rename collapses to a single parent op", async () => {
+		const result = await runScenario({
+			name: "RS3",
+			mode: "twoWay",
+			initialLocal: { "/local/x/y/z/file.txt": "deep" },
+			steps: [
+				runCycle(),
+				runCycle(),
+				localMutate(world => renameLocal(world, "x", "x2")),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/x2/y/z/file.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/x"]).toBeUndefined()
+		// Collapse: exactly one renameRemote op (the parent dir), not one per descendant.
+		const renameOps = transferKinds(result.cycles[2]!.messages).filter(kind => kind.startsWith("rename"))
+
+		expect(renameOps.length).toBeLessThanOrEqual(1)
+		expectConverged(result)
+	})
+
+	it("RS4: moving a child OUT of a renamed directory converges", async () => {
+		const result = await runScenario({
+			name: "RS4",
+			mode: "twoWay",
+			initialLocal: { "/local/a/c.txt": "x", "/local/other": null },
+			steps: [
+				runCycle(),
+				runCycle(),
+				localMutate(world => {
+					// Move the child out to a sibling, THEN rename the now-empty-ish parent.
+					renameLocal(world, "a/c.txt", "other/c.txt")
+					renameLocal(world, "a", "b")
+				}),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/other/c.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/b"]).toMatchObject({ type: "directory" })
+		expect(result.finalRemote["/a"]).toBeUndefined()
+		expect(result.finalRemote["/a/c.txt"]).toBeUndefined()
+		expectConverged(result)
+	})
+
+	it("RS5: a rename concurrent with a sibling content change converges (both applied)", async () => {
+		const result = await runScenario({
+			name: "RS5",
+			mode: "twoWay",
+			initialLocal: { "/local/dir/a.txt": "a", "/local/keep.txt": "keep-v1" },
+			steps: [
+				runCycle(),
+				runCycle(),
+				localMutate(world => {
+					renameLocal(world, "dir", "dir-renamed")
+					writeLocalAt(world, "keep.txt", "keep-v2-longer", BASE_TIME + 10 * SECOND)
+				}),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/dir-renamed/a.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/keep.txt"]).toMatchObject({ type: "file", size: "keep-v2-longer".length })
+		expect(result.finalRemote["/dir"]).toBeUndefined()
+		expectConverged(result)
+	})
+
+	it("RS6: a deep subtree rename plus an in-subtree child rename converges", async () => {
+		const steps: Step[] = [
+			runCycle(),
+			runCycle(),
+			localMutate(world => {
+				// Rename the top dir, then rename a deep descendant to a new basename.
+				renameLocal(world, "root", "root2")
+				renameLocal(world, "root2/mid/leaf.txt", "root2/mid/leaf-renamed.txt")
+			}),
+			runCycle(),
+			runCycle()
+		]
+
+		const result = await runScenario({
+			name: "RS6",
+			mode: "twoWay",
+			initialLocal: { "/local/root/mid/leaf.txt": "L", "/local/root/mid/other.txt": "O" },
+			steps
+		})
+
+		expect(result.finalRemote["/root2/mid/leaf-renamed.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/root2/mid/other.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/root"]).toBeUndefined()
+		expect(result.finalRemote["/root2/mid/leaf.txt"]).toBeUndefined()
+		expectConverged(result)
+	})
+
+	it("RS7: a child under TWO overlapping renamed parents converges (sibling edit preserved)", async () => {
+		// Full-cycle guard for the multi-overlapping-parent collapse case (BUG-004's deterministic half).
+		// Two overlapping parent renames in one beat (/a -> /x then /x/b -> /x/y) make the child
+		// /a/b/c.txt match both, and a sibling edit adds an unrelated delta that must survive. NOTE: the
+		// engine re-runs and self-heals, so a corrupt FIRST cycle would still converge here — the
+		// deterministic corruption (dropped/duplicated op) is pinned directly at
+		// tests/unit/collapse-deltas.test.ts. This case proves the end-to-end path still converges.
+		const result = await runScenario({
+			name: "RS7",
+			mode: "twoWay",
+			initialLocal: {
+				"/local/a/b/c.txt": "child",
+				"/local/sibling.txt": "sib"
+			},
+			steps: [
+				runCycle(),
+				runCycle(),
+				localMutate(world => {
+					renameLocal(world, "a", "x")
+					renameLocal(world, "x/b", "x/y")
+					writeLocalAt(world, "sibling.txt", "sib-v2-longer", BASE_TIME + 10 * SECOND)
+				}),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/x/y/c.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/sibling.txt"]).toMatchObject({ type: "file", size: "sib-v2-longer".length })
+		expect(result.finalRemote["/a"]).toBeUndefined()
+		expect(result.finalRemote["/x/b"]).toBeUndefined()
+		expectConverged(result)
+	})
+})

package/tests/scenarios/s-upgrade-transition.test.ts

@@ -0,0 +1,171 @@
+import { describe, it, expect } from "vitest"
+import { runScenario, runCycle, restart, localMutate, control, type Step } from "../harness/runner"
+import { DB_ROOT } from "../harness/world"
+import { transferKinds, messagesOfType } from "../harness/snapshot"
+import pathModule from "path"
+
+/**
+ * Category S — upgrade transition (the backwards-compat safety net).
+ *
+ * The desktop client bundles this sync engine. When a user updates the client they keep the on-disk
+ * state the PREVIOUS engine wrote (`state/v2/<uuid>/…` trees, the `deviceId`, the local file hashes).
+ * The guarantee: the first cycle after the upgrade over an unchanged sync is a no-op — no re-sync the
+ * user notices, no spurious deletion, no data loss.
+ *
+ * `restart()` reloads that persisted v2 state over the SAME virtual fs + cloud (so inodes and uuids are
+ * preserved), faithfully simulating "a sync was settled, then a new engine boots on its state". These
+ * cases assert the Phase 2 behavior changes (empty-file handling, symlink skip, deletion gating, the
+ * msgpack tree fetch) do not disturb a tree that was already settled. The state FORMAT itself is pinned
+ * by S5 so a future serialization change that would silently break old state fails loudly here.
+ */
+function settle(): Step[] {
+	return [runCycle(), runCycle()]
+}
+
+const statePath = (uuid: string): string => pathModule.join(DB_ROOT, "state", "v2", uuid)
+const deviceIdPath = (uuid: string): string => pathModule.join(DB_ROOT, "deviceId", "v1", uuid)
+
+describe("Category S — upgrade transition (backwards compat)", () => {
+	it("S1: a settled two-way sync does ZERO work on the first cycle after an upgrade/restart", async () => {
+		const result = await runScenario({
+			name: "S1",
+			mode: "twoWay",
+			initialLocal: {
+				"/local/a.txt": "alpha",
+				"/local/dir/b.txt": "bravo",
+				"/local/dir/sub/c.txt": "charlie"
+			},
+			steps: [...settle(), restart(), runCycle()]
+		})
+
+		const settled = result.cycles[1]!
+		const afterUpgrade = result.cycles[2]!
+
+		// The post-upgrade cycle moved no bytes and prompted no deletion.
+		expect(transferKinds(afterUpgrade.messages)).toEqual([])
+		expect(messagesOfType(afterUpgrade.messages, "confirmDeletion")).toEqual([])
+		// Nothing added or removed on either side; both sides still match the settled state exactly.
+		expect(afterUpgrade.local).toEqual(settled.local)
+		expect(afterUpgrade.remote).toEqual(settled.remote)
+		expect(afterUpgrade.local).toEqual(afterUpgrade.remote)
+		// Sanity: a non-empty tree was actually synced.
+		expect(Object.keys(settled.local).length).toBeGreaterThan(0)
+	})
+
+	it("S2: the deviceId is reused across a restart (server-side tree cache stays valid)", async () => {
+		let before: string | null = null
+		let after: string | null = null
+
+		const result = await runScenario({
+			name: "S2",
+			mode: "twoWay",
+			initialLocal: { "/local/keep.txt": "k" },
+			steps: [
+				...settle(),
+				control(async world => {
+					before = (await world.vfs.fs.readFile(deviceIdPath(world.syncPair.uuid), { encoding: "utf-8" })) as unknown as string
+				}),
+				restart(),
+				control(async world => {
+					after = (await world.vfs.fs.readFile(deviceIdPath(world.syncPair.uuid), { encoding: "utf-8" })) as unknown as string
+				}),
+				runCycle()
+			]
+		})
+
+		expect(before).toBeTruthy()
+		// A regenerated deviceId would invalidate the server's per-device tree cache and force a full
+		// re-download storm on every client update — it must survive the restart unchanged.
+		expect(after).toBe(before)
+		expect(transferKinds(result.cycles[2]!.messages)).toEqual([])
+	})
+
+	it("S3: a settled sync with large-deletion confirmation enabled raises NO deletion prompt after upgrade (BUG-001)", async () => {
+		// The deletion-gating fix must not misfire when a fresh engine reloads a settled tree: the
+		// previous trees are non-empty and the current trees match them, so nothing looks deleted.
+		const result = await runScenario({
+			name: "S3",
+			mode: "twoWay",
+			requireConfirmationOnLargeDeletion: true,
+			initialLocal: {
+				"/local/x.txt": "x",
+				"/local/y.txt": "y",
+				"/local/z/w.txt": "w"
+			},
+			steps: [...settle(), restart(), runCycle()]
+		})
+
+		const afterUpgrade = result.cycles[2]!
+
+		expect(messagesOfType(afterUpgrade.messages, "confirmDeletion")).toEqual([])
+		expect(transferKinds(afterUpgrade.messages)).toEqual([])
+		expect(afterUpgrade.local).toEqual(afterUpgrade.remote)
+	})
+
+	it("S4: after upgrade a newly-visible empty file uploads WITHOUT disturbing already-synced files (BUG-002)", async () => {
+		// The old engine ignored 0-byte files, so they were never in its state. The new engine includes
+		// them — uploading the empty file is the intended new behavior, but it must be purely additive:
+		// the previously-synced file is neither re-uploaded nor deleted.
+		const result = await runScenario({
+			name: "S4",
+			mode: "twoWay",
+			initialLocal: { "/local/keep.txt": "content" },
+			steps: [
+				...settle(),
+				restart(),
+				localMutate(world => world.vfs.ifs.writeFileSync("/local/empty.txt", "")),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/empty.txt"]).toMatchObject({ type: "file", size: 0 })
+		expect(result.finalRemote["/keep.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("S5: persisted state is the stable v2 line-delimited {prop,data} JSON (old state stays readable)", async () => {
+		let localTreeRaw = ""
+		let remoteTreeRaw = ""
+
+		await runScenario({
+			name: "S5",
+			mode: "twoWay",
+			initialLocal: { "/local/a.txt": "alpha", "/local/d/b.txt": "bravo" },
+			steps: [
+				...settle(),
+				control(async world => {
+					const base = statePath(world.syncPair.uuid)
+
+					localTreeRaw = (await world.vfs.fs.readFile(pathModule.join(base, "previousLocalTree"), { encoding: "utf-8" })) as unknown as string
+					remoteTreeRaw = (await world.vfs.fs.readFile(pathModule.join(base, "previousRemoteTree"), { encoding: "utf-8" })) as unknown as string
+				})
+			]
+		})
+
+		const localLines = localTreeRaw.trim().split("\n").filter(Boolean)
+
+		expect(localLines.length).toBeGreaterThan(0)
+
+		for (const line of localLines) {
+			const parsed = JSON.parse(line)
+
+			expect(parsed).toHaveProperty("prop")
+			expect(parsed.data).toHaveProperty("path")
+			expect(parsed.data).toHaveProperty("inode")
+			expect(parsed.data).toHaveProperty("type")
+		}
+
+		const remoteLines = remoteTreeRaw.trim().split("\n").filter(Boolean)
+
+		expect(remoteLines.length).toBeGreaterThan(0)
+
+		for (const line of remoteLines) {
+			const parsed = JSON.parse(line)
+
+			expect(parsed).toHaveProperty("prop")
+			expect(parsed.data).toHaveProperty("uuid")
+			expect(parsed.data).toHaveProperty("path")
+		}
+	})
+})

package/tests/scenarios/t-type-change.test.ts

@@ -0,0 +1,144 @@
+import { describe, it, expect } from "vitest"
+import { runScenario, runCycle, localMutate, remoteMutate } from "../harness/runner"
+import { writeLocal, rmLocal } from "../harness/mutations"
+
+/**
+ * Category T — type changes at a path (file ↔ directory). The path exists on BOTH sides but as
+ * different types, so the rename pass (inode/uuid differ), the deletion passes (path still present),
+ * and the addition passes (other side's same-path item exists) all miss it. Without dedicated
+ * handling the stale-type item lingers and its replacement can't be created (E2E-BUG-001).
+ *
+ * The fix attributes the change against the last-synced base (whoever's type diverged from base is
+ * authoritative; local wins a tie/both), deletes the stale-type item, and creates the new type from
+ * the authoritative side. The phase-ordered executor guarantees the delete runs before the create.
+ */
+describe("Category T — file ↔ directory type changes", () => {
+	it("T1: local file → directory (remote still a file) replaces the remote file with the directory", async () => {
+		const result = await runScenario({
+			name: "T1",
+			mode: "twoWay",
+			initialLocal: { "/local/thing": "i am a file" },
+			steps: [
+				runCycle(),
+				localMutate(world => {
+					rmLocal(world, "thing")
+					writeLocal(world, "thing/inside.txt", "now a dir")
+				}),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/thing"]).toMatchObject({ type: "directory" })
+		expect(result.finalRemote["/thing/inside.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("T2: local directory → file (remote still a directory with children) replaces the tree with the file", async () => {
+		const result = await runScenario({
+			name: "T2",
+			mode: "twoWay",
+			initialLocal: { "/local/thing/a.txt": "child a", "/local/thing/b.txt": "child b" },
+			steps: [
+				runCycle(),
+				localMutate(world => {
+					rmLocal(world, "thing")
+					writeLocal(world, "thing", "now a file")
+				}),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/thing"]).toMatchObject({ type: "file" })
+		expect(result.finalRemote["/thing/a.txt"]).toBeUndefined()
+		expect(result.finalRemote["/thing/b.txt"]).toBeUndefined()
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("T3: remote file → directory (local still a file) replaces the local file with the directory", async () => {
+		const result = await runScenario({
+			name: "T3",
+			mode: "twoWay",
+			initialLocal: { "/local/thing": "i am a file" },
+			steps: [
+				runCycle(),
+				remoteMutate(world => {
+					world.cloud.controls.deletePath("/thing")
+					world.cloud.controls.addDir("/thing")
+					world.cloud.controls.addFile("/thing/inside.txt", "remote dir now")
+				}),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalLocal["/thing"]).toMatchObject({ type: "directory" })
+		expect(result.finalLocal["/thing/inside.txt"]).toMatchObject({ type: "file" })
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("T4: remote directory → file (local still a directory with children) replaces the tree with the file", async () => {
+		const result = await runScenario({
+			name: "T4",
+			mode: "twoWay",
+			initialLocal: { "/local/thing/a.txt": "child a", "/local/thing/b.txt": "child b" },
+			steps: [
+				runCycle(),
+				remoteMutate(world => {
+					world.cloud.controls.deletePath("/thing")
+					world.cloud.controls.addFile("/thing", "now a file")
+				}),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalLocal["/thing"]).toMatchObject({ type: "file" })
+		expect(result.finalLocal["/thing/a.txt"]).toBeUndefined()
+		expect(result.finalLocal["/thing/b.txt"]).toBeUndefined()
+		expect(result.finalLocal).toEqual(result.finalRemote)
+	})
+
+	it("T5: localToCloud — local file → directory replaces the remote file", async () => {
+		const result = await runScenario({
+			name: "T5",
+			mode: "localToCloud",
+			initialLocal: { "/local/thing": "i am a file" },
+			steps: [
+				runCycle(),
+				localMutate(world => {
+					rmLocal(world, "thing")
+					writeLocal(world, "thing/inside.txt", "now a dir")
+				}),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalRemote["/thing"]).toMatchObject({ type: "directory" })
+		expect(result.finalRemote["/thing/inside.txt"]).toMatchObject({ type: "file" })
+	})
+
+	it("T6: cloudToLocal — remote file → directory replaces the local file", async () => {
+		const result = await runScenario({
+			name: "T6",
+			mode: "cloudToLocal",
+			initialLocal: {},
+			initialRemote: { "/thing": "i am a file" },
+			steps: [
+				runCycle(),
+				remoteMutate(world => {
+					world.cloud.controls.deletePath("/thing")
+					world.cloud.controls.addDir("/thing")
+					world.cloud.controls.addFile("/thing/inside.txt", "remote dir now")
+				}),
+				runCycle(),
+				runCycle()
+			]
+		})
+
+		expect(result.finalLocal["/thing"]).toMatchObject({ type: "directory" })
+		expect(result.finalLocal["/thing/inside.txt"]).toMatchObject({ type: "file" })
+	})
+})