release v0-3-0: improve package.json for esm module resolution; add more tests

Author: infiton

package.json

@@ -1,10 +1,19 @@
 {
   "name": "thumbdrive",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "An OPFS wrapper offering sync access and multi-tab support",
   "type": "module",
   "main": "dist/index.js",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "sideEffects": false,
   "repository": "gadget-inc/thumbdrive",
   "author": "Gadget Software Inc.",
   "license": "MIT",

spec/e2e/opfs-broker.spec.ts

@@ -14,8 +14,12 @@ declare global {
   }
 }
 
-function url(ns: string, arena: string) {
-  return `/testapp/index.html?ns=${encodeURIComponent(ns)}&arena=${encodeURIComponent(arena)}`;
+function url(ns: string, arena: string, options?: { timeout?: number }) {
+  let u = `/testapp/index.html?ns=${encodeURIComponent(ns)}&arena=${encodeURIComponent(arena)}`;
+  if (options?.timeout !== undefined) {
+    u += `&timeout=${options.timeout}`;
+  }
+  return u;
 }
 
 async function setupPage(page: Page) {
@@ -216,3 +220,283 @@ test("leader failover: when leader stops, another becomes leader and RPCs contin
 
   await context.close();
 });
+
+test("leader crash: abrupt tab close triggers failover and RPCs recover", async ({ browser }) => {
+  const context = await browser.newContext();
+  const [a, b] = await Promise.all([context.newPage(), context.newPage()]);
+  const ns = `ns-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const arena = `arena-${Math.random().toString(36).slice(2)}`;
+
+  [a, b].forEach(setupPage);
+  await Promise.all([a.goto(url(ns, arena)), b.goto(url(ns, arena))]);
+  await Promise.all([waitForReady(a), waitForReady(b)]);
+  await Promise.all([startCandidate(a), startCandidate(b)]);
+
+  await expect
+    .poll(async () => ((await isLeader(a)) ? 1 : 0) + ((await isLeader(b)) ? 1 : 0), { timeout: 5000 })
+    .toBe(1);
+
+  const leaderPage = (await isLeader(a)) ? a : b;
+  const followerPage = leaderPage === a ? b : a;
+
+  // Write a file before crash
+  await writeFile(leaderPage, "/pre-crash.txt", "before");
+  await expect.poll(() => readFile(followerPage, "/pre-crash.txt"), { timeout: 5000 }).toBe("before");
+
+  // Crash the leader (abrupt close, no graceful shutdown)
+  await leaderPage.close();
+
+  // Follower should become the new leader
+  await expect.poll(() => isLeader(followerPage), { timeout: 10000 }).toBe(true);
+
+  // RPCs should work on the new leader
+  await writeFile(followerPage, "/post-crash.txt", "after");
+  await expect.poll(() => readFile(followerPage, "/post-crash.txt"), { timeout: 5000 }).toBe("after");
+
+  await context.close();
+});
+
+test("follower request timeout when no leader responds", async ({ browser }) => {
+  const context = await browser.newContext();
+  const lockHolder = await context.newPage();
+  const follower = await context.newPage();
+  const ns = `ns-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const arena = `arena-${Math.random().toString(36).slice(2)}`;
+
+  setupPage(lockHolder);
+  setupPage(follower);
+
+  // Navigate lock holder to same origin so it can hold the Web Lock
+  await lockHolder.goto(url(ns, arena));
+  await waitForReady(lockHolder);
+
+  // Hold the ns-scoped Web Lock, preventing any broker from becoming leader
+  const lockName = `opfs-worker-lock-${ns}`;
+  await lockHolder.evaluate((name: string) => {
+    return new Promise<void>((resolve) => {
+      navigator.locks.request(name, () => {
+        resolve(); // signal that we have the lock
+        return new Promise(() => {}); // hold it forever
+      });
+    });
+  }, lockName);
+
+  // Start the follower with a short timeout (1s)
+  await follower.goto(url(ns, arena, { timeout: 1000 }));
+  await waitForReady(follower);
+  await startCandidate(follower);
+
+  // Follower should not be leader
+  await expect.poll(() => isLeader(follower), { timeout: 2000 }).toBe(false);
+
+  // Try to write — should fail since no leader exists to handle the request
+  const error = await follower.evaluate(async () => {
+    try {
+      await window.thumbdriveTest.writeFile("/timeout-test.txt", "should-fail");
+      return null;
+    } catch (e: any) {
+      return e.message || String(e);
+    }
+  });
+
+  expect(error).toBeTruthy();
+  expect(error).toContain("timeout");
+
+  await context.close();
+});
+
+test("restart cycle: stop and start preserves OPFS data", async ({ page }) => {
+  const ns = `ns-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const arena = `arena-${Math.random().toString(36).slice(2)}`;
+
+  setupPage(page);
+  await page.goto(url(ns, arena));
+  await waitForReady(page);
+  await startCandidate(page);
+  await expect.poll(() => isLeader(page), { timeout: 5000 }).toBe(true);
+
+  // Write a file
+  await writeFile(page, "/restart-test.txt", "before-restart");
+  await expect.poll(() => readFile(page, "/restart-test.txt"), { timeout: 5000 }).toBe("before-restart");
+
+  // Shutdown gracefully
+  await shutdownLeader(page);
+  await expect.poll(() => isLeader(page), { timeout: 5000 }).toBe(false);
+
+  // Start again
+  await startCandidate(page);
+  await expect.poll(() => isLeader(page), { timeout: 5000 }).toBe(true);
+
+  // New writes work after restart
+  await writeFile(page, "/restart-test-2.txt", "after-restart");
+  await expect.poll(() => readFile(page, "/restart-test-2.txt"), { timeout: 5000 }).toBe("after-restart");
+
+  // Can shutdown again cleanly
+  await shutdownLeader(page);
+  await expect.poll(() => isLeader(page), { timeout: 5000 }).toBe(false);
+});
+
+test("concurrent writes from multiple tabs with overlapping JSONRPC IDs", async ({ browser }) => {
+  const context = await browser.newContext();
+  const [a, b, c] = await Promise.all([context.newPage(), context.newPage(), context.newPage()]);
+  const ns = `ns-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const arena = `arena-${Math.random().toString(36).slice(2)}`;
+
+  [a, b, c].forEach(setupPage);
+  await Promise.all([a.goto(url(ns, arena)), b.goto(url(ns, arena)), c.goto(url(ns, arena))]);
+  await Promise.all([waitForReady(a), waitForReady(b), waitForReady(c)]);
+  await Promise.all([startCandidate(a), startCandidate(b), startCandidate(c)]);
+
+  await expect
+    .poll(async () => ((await isLeader(a)) ? 1 : 0) + ((await isLeader(b)) ? 1 : 0) + ((await isLeader(c)) ? 1 : 0), { timeout: 5000 })
+    .toBe(1);
+
+  // Fire concurrent writes from all three tabs simultaneously.
+  // Each tab's vscode-jsonrpc connection assigns IDs starting from 0,
+  // so the broker's ID rewriting must disambiguate them.
+  await Promise.all([
+    writeFile(a, "/c1.txt", "from-a"),
+    writeFile(b, "/c2.txt", "from-b"),
+    writeFile(c, "/c3.txt", "from-c"),
+  ]);
+
+  // All files should be readable from any tab
+  await expect.poll(() => readFile(b, "/c1.txt"), { timeout: 5000 }).toBe("from-a");
+  await expect.poll(() => readFile(c, "/c2.txt"), { timeout: 5000 }).toBe("from-b");
+  await expect.poll(() => readFile(a, "/c3.txt"), { timeout: 5000 }).toBe("from-c");
+
+  await context.close();
+});
+
+test("multiple sequential failovers across three tabs", async ({ browser }) => {
+  const context = await browser.newContext();
+  const [a, b, c] = await Promise.all([context.newPage(), context.newPage(), context.newPage()]);
+  const ns = `ns-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const arena = `arena-${Math.random().toString(36).slice(2)}`;
+
+  [a, b, c].forEach(setupPage);
+  await Promise.all([a.goto(url(ns, arena)), b.goto(url(ns, arena)), c.goto(url(ns, arena))]);
+  await Promise.all([waitForReady(a), waitForReady(b), waitForReady(c)]);
+  await Promise.all([startCandidate(a), startCandidate(b), startCandidate(c)]);
+
+  const pages = [a, b, c];
+
+  async function findLeaderIdx() {
+    const states = await Promise.all(pages.map((p) => isLeader(p).catch(() => false)));
+    return states.findIndex((x) => x);
+  }
+
+  // Wait for initial leader
+  let leaderIdx = -1;
+  await expect
+    .poll(async () => {
+      leaderIdx = await findLeaderIdx();
+      return leaderIdx >= 0;
+    }, { timeout: 5000 })
+    .toBe(true);
+
+  // Write from first leader
+  await writeFile(pages[leaderIdx], "/failover-1.txt", "leader-1");
+
+  // --- First failover: crash the leader ---
+  const firstLeaderIdx = leaderIdx;
+  await pages[firstLeaderIdx].close();
+
+  const remaining = [0, 1, 2].filter((i) => i !== firstLeaderIdx);
+
+  // Wait for a new leader among the remaining tabs
+  await expect
+    .poll(async () => {
+      const states = await Promise.all(remaining.map((i) => isLeader(pages[i]).catch(() => false)));
+      return states.some((x) => x);
+    }, { timeout: 10000 })
+    .toBe(true);
+
+  // Find new leader
+  let secondLeaderIdx = -1;
+  for (const i of remaining) {
+    if (await isLeader(pages[i]).catch(() => false)) {
+      secondLeaderIdx = i;
+      break;
+    }
+  }
+
+  // Write from second leader and verify cross-tab read works
+  const lastIdx = remaining.find((i) => i !== secondLeaderIdx)!;
+  await writeFile(pages[secondLeaderIdx], "/failover-2.txt", "leader-2");
+  await expect.poll(() => readFile(pages[lastIdx], "/failover-2.txt"), { timeout: 5000 }).toBe("leader-2");
+
+  // --- Second failover: crash the second leader ---
+  await pages[secondLeaderIdx].close();
+
+  // Last page standing should become leader
+  await expect.poll(() => isLeader(pages[lastIdx]), { timeout: 10000 }).toBe(true);
+
+  // RPCs still work after two consecutive failovers
+  await writeFile(pages[lastIdx], "/failover-3.txt", "leader-3");
+  await expect.poll(() => readFile(pages[lastIdx], "/failover-3.txt"), { timeout: 5000 }).toBe("leader-3");
+
+  await context.close();
+});
+
+test("RPCs sent during failover transition eventually resolve", async ({ browser }) => {
+  const context = await browser.newContext();
+  const [a, b, c] = await Promise.all([context.newPage(), context.newPage(), context.newPage()]);
+  const ns = `ns-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const arena = `arena-${Math.random().toString(36).slice(2)}`;
+
+  // Use a short broker timeout so failed RPCs don't block the test for 20s
+  [a, b, c].forEach(setupPage);
+  await Promise.all([
+    a.goto(url(ns, arena, { timeout: 2000 })),
+    b.goto(url(ns, arena, { timeout: 2000 })),
+    c.goto(url(ns, arena, { timeout: 2000 })),
+  ]);
+  await Promise.all([waitForReady(a), waitForReady(b), waitForReady(c)]);
+  await Promise.all([startCandidate(a), startCandidate(b), startCandidate(c)]);
+
+  const pages = [a, b, c];
+
+  async function findLeaderIdx() {
+    const states = await Promise.all(pages.map((p) => isLeader(p).catch(() => false)));
+    return states.findIndex((x) => x);
+  }
+
+  let leaderIdx = -1;
+  await expect
+    .poll(async () => {
+      leaderIdx = await findLeaderIdx();
+      return leaderIdx >= 0;
+    }, { timeout: 5000 })
+    .toBe(true);
+
+  // Identify the two survivors
+  const survivors = [0, 1, 2].filter((i) => i !== leaderIdx).map((i) => pages[i]);
+
+  // Crash the leader
+  await pages[leaderIdx].close();
+
+  // Immediately fire RPCs from both survivors — the first attempt may time out
+  // if the broadcast arrives before the new leader is ready, so we retry once.
+  async function writeWithRetry(page: Page, path: string, content: string) {
+    try {
+      await writeFile(page, path, content);
+    } catch {
+      // First attempt failed (likely timeout during transition). Retry after
+      // giving the new leader time to finish booting.
+      await page.waitForTimeout(500);
+      await writeFile(page, path, content);
+    }
+  }
+
+  await Promise.all([
+    writeWithRetry(survivors[0], "/race-1.txt", "race-1"),
+    writeWithRetry(survivors[1], "/race-2.txt", "race-2"),
+  ]);
+
+  // Both writes should be readable from either survivor
+  await expect.poll(() => readFile(survivors[0], "/race-2.txt"), { timeout: 5000 }).toBe("race-2");
+  await expect.poll(() => readFile(survivors[1], "/race-1.txt"), { timeout: 5000 }).toBe("race-1");
+
+  await context.close();
+});