@storacha/clawracha 0.0.3 → 0.0.5

package/test/handlers/process.test.ts

@@ -1,301 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import * as os from "node:os";
-
-import { Agent, Name, Revision } from "@storacha/ucn/pail";
-import * as Value from "@storacha/ucn/pail/value";
-import { MemoryBlockstore } from "@storacha/ucn/block";
-import type { ValueView } from "@storacha/ucn/pail/api";
-import type { Block } from "multiformats";
-
-import { processChanges } from "../../src/handlers/process.js";
-import type { FileChange } from "../../src/types/index.js";
-
-// --- Helpers ---
-
-const storeBlocks = async (
-  store: MemoryBlockstore,
-  blocks: Array<{ cid: unknown; bytes: Uint8Array }>,
-) => {
-  for (const block of blocks) {
-    await store.put(block as any);
-  }
-};
-
-/**
- * Create a block sink that collects blocks into an array.
- */
-const makeBlockCollector = () => {
-  const collected: Block[] = [];
-  const sink = async (block: Block) => { collected.push(block); };
-  return { sink, collected };
-};
-
-/**
- * Encode a file and extract root CID + blocks for bootstrapping pail state.
- */
-const encodeFileForBootstrap = async (
-  workspace: string,
-  relativePath: string,
-): Promise<{ rootCID: any; blocks: Block[] }> => {
-  const { encodeWorkspaceFile } = await import("../../src/utils/encoder.js");
-  const encoded = await encodeWorkspaceFile(workspace, relativePath);
-  const blocks: Block[] = [];
-  let rootCID: any = null;
-  const reader = encoded.blocks.getReader();
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    blocks.push(value);
-    rootCID = value.cid; // last block is the root
-  }
-  return { rootCID, blocks };
-};
-
-/**
- * Bootstrap a pail value with entries, no clock needed.
- */
-const bootstrapValue = async (
-  blocks: MemoryBlockstore,
-  entries: Record<string, string>,
-): Promise<{ value: ValueView }> => {
-  const agent = await Agent.generate();
-  const name = await Name.create(agent);
-
-  const keys = Object.keys(entries);
-  if (keys.length === 0) throw new Error("need at least one entry");
-
-  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "bootstrap-"));
-  for (const [key, content] of Object.entries(entries)) {
-    const filePath = path.join(tmpDir, key);
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.writeFile(filePath, content);
-  }
-
-  const firstKey = keys[0];
-  const firstEncoded = await encodeFileForBootstrap(tmpDir, firstKey);
-  for (const b of firstEncoded.blocks) await blocks.put(b as any);
-
-  const init = await Revision.v0Put(blocks, firstKey, firstEncoded.rootCID);
-  await storeBlocks(blocks, init.additions);
-  let value = (await Value.from(blocks, name, init.revision)).value;
-
-  for (const key of keys.slice(1)) {
-    const encoded = await encodeFileForBootstrap(tmpDir, key);
-    for (const b of encoded.blocks) await blocks.put(b as any);
-
-    const result = await Revision.put(blocks, value, key, encoded.rootCID);
-    await storeBlocks(blocks, result.additions);
-    value = (await Value.from(blocks, name, result.revision)).value;
-  }
-
-  await fs.rm(tmpDir, { recursive: true, force: true });
-  return { value };
-};
-
-// --- Tests ---
-
-describe("processChanges", () => {
-  let tmpDir: string;
-
-  beforeEach(async () => {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "clawracha-process-"));
-  });
-
-  afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true });
-  });
-
-  const writeFile = async (name: string, content: string) => {
-    const filePath = path.join(tmpDir, name);
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.writeFile(filePath, content);
-  };
-
-  it("no current + put → one put op", async () => {
-    await writeFile("hello.txt", "hello world");
-    const changes: FileChange[] = [{ type: "add", path: "hello.txt" }];
-
-    const { sink, collected } = makeBlockCollector();
-    const ops = await processChanges(changes, tmpDir, null, { get: async () => undefined }, sink);
-
-    expect(ops).toHaveLength(1);
-    expect(ops[0].type).toBe("put");
-    expect(ops[0].key).toBe("hello.txt");
-    expect(ops[0].value).toBeDefined();
-    expect(collected.length).toBeGreaterThan(0);
-  });
-
-  it("no current + delete → no op", async () => {
-    const changes: FileChange[] = [{ type: "unlink", path: "gone.txt" }];
-
-    const { sink, collected } = makeBlockCollector();
-    const ops = await processChanges(changes, tmpDir, null, { get: async () => undefined }, sink);
-
-    expect(ops).toHaveLength(0);
-    expect(collected).toHaveLength(0);
-  });
-
-  it("existing current + put new key → one put op", async () => {
-    const blocks = new MemoryBlockstore();
-    const { value } = await bootstrapValue(blocks, { "a.txt": "aaa" });
-
-    await writeFile("b.txt", "bbb");
-    const changes: FileChange[] = [{ type: "add", path: "b.txt" }];
-
-    const { sink } = makeBlockCollector();
-    const ops = await processChanges(changes, tmpDir, value, blocks, sink);
-
-    expect(ops).toHaveLength(1);
-    expect(ops[0].type).toBe("put");
-    expect(ops[0].key).toBe("b.txt");
-  });
-
-  it("existing current + put same key different value → one put op", async () => {
-    const blocks = new MemoryBlockstore();
-    const { value } = await bootstrapValue(blocks, { "a.txt": "old content" });
-
-    await writeFile("a.txt", "new content");
-    const changes: FileChange[] = [{ type: "change", path: "a.txt" }];
-
-    const { sink } = makeBlockCollector();
-    const ops = await processChanges(changes, tmpDir, value, blocks, sink);
-
-    expect(ops).toHaveLength(1);
-    expect(ops[0].type).toBe("put");
-    expect(ops[0].key).toBe("a.txt");
-  });
-
-  it("existing current + put same key same value → no op", async () => {
-    const blocks = new MemoryBlockstore();
-    const { value } = await bootstrapValue(blocks, { "a.txt": "same content" });
-
-    await writeFile("a.txt", "same content");
-    const changes: FileChange[] = [{ type: "change", path: "a.txt" }];
-
-    const { sink, collected } = makeBlockCollector();
-    const ops = await processChanges(changes, tmpDir, value, blocks, sink);
-
-    expect(ops).toHaveLength(0);
-    expect(collected.length).toBeGreaterThan(0);
-  });
-
-  it("existing current + delete existing key → one delete op", async () => {
-    const blocks = new MemoryBlockstore();
-    const { value } = await bootstrapValue(blocks, { "a.txt": "delete me" });
-
-    const changes: FileChange[] = [{ type: "unlink", path: "a.txt" }];
-
-    const { sink } = makeBlockCollector();
-    const ops = await processChanges(changes, tmpDir, value, blocks, sink);
-
-    expect(ops).toHaveLength(1);
-    expect(ops[0].type).toBe("del");
-    expect(ops[0].key).toBe("a.txt");
-  });
-
-  it("existing current + delete non-existing key → no op", async () => {
-    const blocks = new MemoryBlockstore();
-    const { value } = await bootstrapValue(blocks, { "a.txt": "keep me" });
-
-    const changes: FileChange[] = [{ type: "unlink", path: "nonexistent.txt" }];
-
-    const { sink } = makeBlockCollector();
-    const ops = await processChanges(changes, tmpDir, value, blocks, sink);
-
-    expect(ops).toHaveLength(0);
-  });
-
-  it("markdown file → mdsync v0Put (no current)", async () => {
-    await writeFile("notes.md", "# Notes\n\nHello world.\n");
-    const changes: FileChange[] = [{ type: "add", path: "notes.md" }];
-
-    const { sink, collected } = makeBlockCollector();
-    const stored: Block[] = [];
-    const store = async (block: Block) => { stored.push(block); };
-    const ops = await processChanges(changes, tmpDir, null, { get: async () => undefined }, sink, store);
-
-    expect(ops).toHaveLength(1);
-    expect(ops[0].type).toBe("put");
-    expect(ops[0].key).toBe("notes.md");
-    expect(ops[0].value).toBeDefined();
-    // Markdown blocks should be sinked for CAR upload AND stored locally
-    expect(collected.length).toBeGreaterThan(0);
-    expect(stored.length).toBeGreaterThan(0);
-    expect(collected.length).toBe(stored.length);
-  });
-
-  it("markdown file update → mdsync put (with current)", async () => {
-    const blocks = new MemoryBlockstore();
-    // Bootstrap with a markdown file via mdsync
-    const mdsync = await import("../../src/mdsync/index.js");
-    const { mdEntryCid, additions } = await mdsync.v0Put("# Old\n");
-    for (const b of additions) await blocks.put(b as any);
-
-    const { Agent, Name, Revision } = await import("@storacha/ucn/pail");
-    const agent = await Agent.generate();
-    const name = await Name.create(agent);
-    const init = await Revision.v0Put(blocks, "readme.md", mdEntryCid);
-    await storeBlocks(blocks, init.additions);
-    await blocks.put(init.revision.event as any);
-    const { value } = await (await import("@storacha/ucn/pail/value")).from(blocks, name, init.revision);
-
-    await writeFile("readme.md", "# New\n\nUpdated content.\n");
-    const changes: FileChange[] = [{ type: "change", path: "readme.md" }];
-
-    const { sink, collected } = makeBlockCollector();
-    const stored: Block[] = [];
-    const store = async (block: Block) => { stored.push(block); };
-    const ops = await processChanges(changes, tmpDir, value, blocks, sink, store);
-
-    expect(ops).toHaveLength(1);
-    expect(ops[0].type).toBe("put");
-    expect(ops[0].key).toBe("readme.md");
-    expect(collected.length).toBeGreaterThan(0);
-    expect(stored.length).toBeGreaterThan(0);
-  });
-
-  it("mixed markdown and regular files", async () => {
-    await writeFile("readme.md", "# Readme\n");
-    await writeFile("data.txt", "some data");
-    const changes: FileChange[] = [
-      { type: "add", path: "readme.md" },
-      { type: "add", path: "data.txt" },
-    ];
-
-    const { sink } = makeBlockCollector();
-    const ops = await processChanges(changes, tmpDir, null, { get: async () => undefined }, sink);
-
-    expect(ops).toHaveLength(2);
-    const mdOp = ops.find((o) => o.key === "readme.md");
-    const txtOp = ops.find((o) => o.key === "data.txt");
-    expect(mdOp).toBeDefined();
-    expect(mdOp!.type).toBe("put");
-    expect(txtOp).toBeDefined();
-    expect(txtOp!.type).toBe("put");
-  });
-
-  it("markdown delete → del op", async () => {
-    const blocks = new MemoryBlockstore();
-    const mdsync = await import("../../src/mdsync/index.js");
-    const { mdEntryCid, additions } = await mdsync.v0Put("# Delete me\n");
-    for (const b of additions) await blocks.put(b as any);
-
-    const { Agent, Name, Revision } = await import("@storacha/ucn/pail");
-    const agent = await Agent.generate();
-    const name = await Name.create(agent);
-    const init = await Revision.v0Put(blocks, "delete.md", mdEntryCid);
-    await storeBlocks(blocks, init.additions);
-    await blocks.put(init.revision.event as any);
-    const { value } = await (await import("@storacha/ucn/pail/value")).from(blocks, name, init.revision);
-
-    const changes: FileChange[] = [{ type: "unlink", path: "delete.md" }];
-    const { sink } = makeBlockCollector();
-    const ops = await processChanges(changes, tmpDir, value, blocks, sink);
-
-    expect(ops).toHaveLength(1);
-    expect(ops[0].type).toBe("del");
-    expect(ops[0].key).toBe("delete.md");
-  });
-});

package/test/handlers/remote.test.ts

@@ -1,182 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import * as os from "node:os";
-import * as http from "node:http";
-import { CID } from "multiformats/cid";
-import { sha256 } from "multiformats/hashes/sha2";
-import * as raw from "multiformats/codecs/raw";
-
-import { applyRemoteChanges } from "../../src/handlers/remote.js";
-
-// --- Helpers ---
-
-const createTestCID = async (content: string) => {
-  const bytes = new TextEncoder().encode(content);
-  const hash = await sha256.digest(bytes);
-  return CID.create(1, raw.code, hash);
-};
-
-/**
- * Spin up a minimal mock IPFS gateway that returns file bytes for known CIDs.
- */
-const createMockGateway = (
-  files: Map<string, Uint8Array>,
-): Promise<{ url: string; close: () => Promise<void> }> => {
-  return new Promise((resolve) => {
-    const server = http.createServer((req, res) => {
-      const cidStr = req.url?.replace("/ipfs/", "");
-      const data = cidStr ? files.get(cidStr) : undefined;
-      if (data) {
-        res.writeHead(200, { "Content-Type": "application/octet-stream" });
-        res.end(data);
-      } else {
-        res.writeHead(404);
-        res.end("Not Found");
-      }
-    });
-
-    server.listen(0, "127.0.0.1", () => {
-      const addr = server.address() as { port: number };
-      resolve({
-        url: `http://127.0.0.1:${addr.port}`,
-        close: () => new Promise((r) => server.close(() => r())),
-      });
-    });
-  });
-};
-
-// --- Tests ---
-
-describe("applyRemoteChanges", () => {
-  let tmpDir: string;
-
-  beforeEach(async () => {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "clawracha-remote-"));
-  });
-
-  afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true });
-  });
-
-  it("should fetch and write a new file from gateway", async () => {
-    const content = new TextEncoder().encode("hello from storacha");
-    const cid = await createTestCID("hello from storacha");
-
-    const gateway = await createMockGateway(new Map([[cid.toString(), content]]));
-    try {
-      const entries = new Map<string, CID>([["docs/hello.txt", cid]]);
-      await applyRemoteChanges(["docs/hello.txt"], entries, tmpDir, {
-        gateway: gateway.url,
-      });
-
-      const written = await fs.readFile(path.join(tmpDir, "docs/hello.txt"));
-      expect(new Uint8Array(written)).toEqual(content);
-    } finally {
-      await gateway.close();
-    }
-  });
-
-  it("should overwrite an existing file with new content", async () => {
-    // Write old content
-    await fs.writeFile(path.join(tmpDir, "file.txt"), "old");
-
-    const content = new TextEncoder().encode("new content");
-    const cid = await createTestCID("new content");
-
-    const gateway = await createMockGateway(new Map([[cid.toString(), content]]));
-    try {
-      const entries = new Map<string, CID>([["file.txt", cid]]);
-      await applyRemoteChanges(["file.txt"], entries, tmpDir, {
-        gateway: gateway.url,
-      });
-
-      const written = await fs.readFile(path.join(tmpDir, "file.txt"), "utf-8");
-      expect(written).toBe("new content");
-    } finally {
-      await gateway.close();
-    }
-  });
-
-  it("should delete a file that was removed remotely", async () => {
-    const filePath = path.join(tmpDir, "delete-me.txt");
-    await fs.writeFile(filePath, "goodbye");
-
-    // Entry missing from map = deleted
-    const entries = new Map<string, CID>();
-    await applyRemoteChanges(["delete-me.txt"], entries, tmpDir);
-
-    await expect(fs.access(filePath)).rejects.toThrow();
-  });
-
-  it("should not throw when deleting a file that doesn't exist", async () => {
-    const entries = new Map<string, CID>();
-    await expect(
-      applyRemoteChanges(["nonexistent.txt"], entries, tmpDir),
-    ).resolves.not.toThrow();
-  });
-
-  it("should create nested directories as needed", async () => {
-    const content = new TextEncoder().encode("deep file");
-    const cid = await createTestCID("deep file");
-
-    const gateway = await createMockGateway(new Map([[cid.toString(), content]]));
-    try {
-      const entries = new Map<string, CID>([["a/b/c/deep.txt", cid]]);
-      await applyRemoteChanges(["a/b/c/deep.txt"], entries, tmpDir, {
-        gateway: gateway.url,
-      });
-
-      const written = await fs.readFile(path.join(tmpDir, "a/b/c/deep.txt"));
-      expect(new Uint8Array(written)).toEqual(content);
-    } finally {
-      await gateway.close();
-    }
-  });
-
-  it("should throw on gateway fetch failure", async () => {
-    const cid = await createTestCID("missing");
-
-    // Gateway with no files → 404
-    const gateway = await createMockGateway(new Map());
-    try {
-      const entries = new Map<string, CID>([["fail.txt", cid]]);
-      await expect(
-        applyRemoteChanges(["fail.txt"], entries, tmpDir, {
-          gateway: gateway.url,
-        }),
-      ).rejects.toThrow(/Gateway fetch failed/);
-    } finally {
-      await gateway.close();
-    }
-  });
-
-  it("should resolve markdown file via mdsync instead of gateway", async () => {
-    // Set up a pail with a markdown entry
-    const { MemoryBlockstore } = await import("@storacha/ucn/block");
-    const { Agent, Name, Revision } = await import("@storacha/ucn/pail");
-    const Value = await import("@storacha/ucn/pail/value");
-    const mdsync = await import("../../src/mdsync/index.js");
-
-    const blocks = new MemoryBlockstore();
-    const md = "# Remote Doc\n\nFrom another device.\n";
-    const { mdEntryCid, additions } = await mdsync.v0Put(md);
-    for (const b of additions) await blocks.put(b as any);
-
-    const agent = await Agent.generate();
-    const name = await Name.create(agent);
-    const rev = await Revision.v0Put(blocks, "doc.md", mdEntryCid);
-    for (const b of rev.additions) await blocks.put(b as any);
-    await blocks.put(rev.revision.event as any);
-    const { value } = await Value.from(blocks, name, rev.revision);
-
-    const entries = new Map<string, CID>([["doc.md", mdEntryCid as unknown as CID]]);
-    await applyRemoteChanges(["doc.md"], entries, tmpDir, {
-      blocks,
-      current: value,
-    });
-
-    const written = await fs.readFile(path.join(tmpDir, "doc.md"), "utf-8");
-    expect(written).toBe(md);
-  });
-});

package/test/mdsync/mdsync.test.ts

@@ -1,120 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { MemoryBlockstore } from "@storacha/ucn/block";
-import * as Revision from "@storacha/ucn/pail/revision";
-import * as Value from "@storacha/ucn/pail/value";
-import { Block } from "multiformats";
-import * as mdsync from "../../src/mdsync/index.js";
-
-class TestBlockstore extends MemoryBlockstore {
-  async putMany(blocks: Block[]) {
-    for (const block of blocks) {
-      await this.put(block);
-    }
-  }
-}
-
-const mockName = {} as any;
-
-/** Helper: v0Put markdown, store blocks, create ValueView. */
-async function initPail(blocks: TestBlockstore, key: string, md: string) {
-  const { mdEntryCid, additions } = await mdsync.v0Put(md);
-  await blocks.putMany(additions);
-  const rev = await Revision.v0Put(blocks, key, mdEntryCid);
-  await blocks.putMany(rev.additions);
-  await blocks.put(rev.revision.event);
-  const { value } = await Value.from(blocks, mockName, rev.revision);
-  return value;
-}
-
-/** Helper: put markdown update, store blocks, create new ValueView. */
-async function updatePail(
-  blocks: TestBlockstore,
-  current: any,
-  key: string,
-  md: string,
-) {
-  const { mdEntryCid, additions } = await mdsync.put(blocks, current, key, md);
-  await blocks.putMany(additions);
-  const rev = await Revision.put(blocks, current, key, mdEntryCid);
-  await blocks.putMany(rev.additions);
-  await blocks.put(rev.revision.event);
-  const { value } = await Value.from(blocks, mockName, rev.revision);
-  return value;
-}
-
-describe("mdsync", () => {
-  it("v0Put then get returns the markdown", async () => {
-    const blocks = new TestBlockstore();
-    const md = "# Hello\n\nThis is a test.\n";
-
-    const value = await initPail(blocks, "test.md", md);
-    const retrieved = await mdsync.get(blocks, value, "test.md");
-    expect(retrieved).toBe(md);
-  });
-
-  it("put updates existing markdown", async () => {
-    const blocks = new TestBlockstore();
-    const md1 = "# Hello\n\nFirst version.\n";
-    const md2 = "# Hello\n\nSecond version.\n";
-
-    const v1 = await initPail(blocks, "test.md", md1);
-    const v2 = await updatePail(blocks, v1, "test.md", md2);
-
-    const retrieved = await mdsync.get(blocks, v2, "test.md");
-    expect(retrieved).toBe(md2);
-  });
-
-  it("get returns undefined for missing key", async () => {
-    const blocks = new TestBlockstore();
-    const value = await initPail(blocks, "test.md", "# Hello\n");
-
-    const retrieved = await mdsync.get(blocks, value, "missing.md");
-    expect(retrieved).toBeUndefined();
-  });
-
-  it("multiple sequential puts", async () => {
-    const blocks = new TestBlockstore();
-
-    const v1 = await initPail(blocks, "doc.md", "# V1\n");
-    const v2 = await updatePail(blocks, v1, "doc.md", "# V2\n\nNew paragraph.\n");
-    const v3 = await updatePail(blocks, v2, "doc.md", "# V3\n\nNew paragraph.\n\nAnother one.\n");
-
-    const retrieved = await mdsync.get(blocks, v3, "doc.md");
-    expect(retrieved).toBe("# V3\n\nNew paragraph.\n\nAnother one.\n");
-  });
-
-  it("resolves concurrent edits from two heads", async () => {
-    const blocks = new TestBlockstore();
-
-    // Common ancestor
-    const v0 = await initPail(blocks, "doc.md", "# Doc\n\nOriginal.\n");
-
-    // Two concurrent edits branching from v0
-    const { mdEntryCid: cid1, additions: a1 } = await mdsync.put(
-      blocks, v0, "doc.md", "# Doc\n\nOriginal.\n\nFrom replica 1.\n",
-    );
-    await blocks.putMany(a1);
-    const rev1 = await Revision.put(blocks, v0, "doc.md", cid1);
-    await blocks.putMany(rev1.additions);
-    await blocks.put(rev1.revision.event);
-
-    const { mdEntryCid: cid2, additions: a2 } = await mdsync.put(
-      blocks, v0, "doc.md", "# Doc\n\nOriginal.\n\nFrom replica 2.\n",
-    );
-    await blocks.putMany(a2);
-    const rev2 = await Revision.put(blocks, v0, "doc.md", cid2);
-    await blocks.putMany(rev2.additions);
-    await blocks.put(rev2.revision.event);
-
-    // Merge: ValueView with both heads
-    const { value: merged } = await Value.from(
-      blocks, mockName, rev1.revision, rev2.revision,
-    );
-
-    const result = await mdsync.get(blocks, merged, "doc.md");
-    expect(result).toBeDefined();
-    // Both edits should be present in the resolved document
-    expect(result).toContain("From replica 1.");
-    expect(result).toContain("From replica 2.");
-  });
-});

package/test/utils/differ.test.ts

@@ -1,94 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { CID } from "multiformats/cid";
-import { sha256 } from "multiformats/hashes/sha2";
-import * as raw from "multiformats/codecs/raw";
-import {
-  diffEntries,
-  diffRemoteChanges,
-  type PailEntries,
-  type LocalEntries,
-} from "../../src/utils/differ.js";
-
-const createCID = async (content: string) => {
-  const bytes = new TextEncoder().encode(content);
-  const hash = await sha256.digest(bytes);
-  return CID.create(1, raw.code, hash);
-};
-
-describe("diffEntries", () => {
-  it("should detect new files", async () => {
-    const local: LocalEntries = new Map([
-      ["new.md", await createCID("new content")],
-    ]);
-    const pail: PailEntries = new Map();
-
-    const ops = diffEntries(local, pail);
-
-    expect(ops).toHaveLength(1);
-    expect(ops[0].type).toBe("put");
-    expect(ops[0].key).toBe("new.md");
-  });
-
-  it("should detect changed files", async () => {
-    const cidOld = await createCID("old content");
-    const cidNew = await createCID("new content");
-
-    const local: LocalEntries = new Map([["file.md", cidNew]]);
-    const pail: PailEntries = new Map([["file.md", cidOld]]);
-
-    const ops = diffEntries(local, pail);
-
-    expect(ops).toHaveLength(1);
-    expect(ops[0].type).toBe("put");
-    expect(ops[0].key).toBe("file.md");
-  });
-
-  it("should detect deleted files", async () => {
-    const cid = await createCID("content");
-
-    const local: LocalEntries = new Map();
-    const pail: PailEntries = new Map([["deleted.md", cid]]);
-
-    const ops = diffEntries(local, pail);
-
-    expect(ops).toHaveLength(1);
-    expect(ops[0].type).toBe("del");
-    expect(ops[0].key).toBe("deleted.md");
-  });
-
-  it("should ignore unchanged files", async () => {
-    const cid = await createCID("same content");
-
-    const local: LocalEntries = new Map([["unchanged.md", cid]]);
-    const pail: PailEntries = new Map([["unchanged.md", cid]]);
-
-    const ops = diffEntries(local, pail);
-
-    expect(ops).toHaveLength(0);
-  });
-});
-
-describe("diffRemoteChanges", () => {
-  it("should detect files added remotely", async () => {
-    const cid = await createCID("remote file");
-
-    const before: PailEntries = new Map();
-    const after: PailEntries = new Map([["remote.md", cid]]);
-
-    const changes = diffRemoteChanges(before, after);
-
-    expect(changes).toEqual(["remote.md"]);
-  });
-
-  it("should detect files changed remotely", async () => {
-    const cidOld = await createCID("old");
-    const cidNew = await createCID("new");
-
-    const before: PailEntries = new Map([["file.md", cidOld]]);
-    const after: PailEntries = new Map([["file.md", cidNew]]);
-
-    const changes = diffRemoteChanges(before, after);
-
-    expect(changes).toEqual(["file.md"]);
-  });
-});