@pylonsync/sync 0.20.0 → 0.22.0

package/src/live-batch-persist.test.ts

@@ -0,0 +1,180 @@
+// Live change frames are group-committed to IndexedDB.
+//
+// Each WebSocket change frame used to be its own apply step: one store
+// notify, one IndexedDB transaction for the row, and a second one for the
+// cursor, all awaited before the next frame could apply. A busy channel
+// capped each tab at a few hundred row changes per second. Frames that
+// arrive while a write is in flight now join one batch: one notify and one
+// transaction that holds the rows and the cursor.
+
+import "fake-indexeddb/auto";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { IndexedDBPersistence, SyncEngine, type ChangeEvent } from "./index";
+
+const realFetch = globalThis.fetch;
+
+beforeEach(() => {
+  globalThis.fetch = (async (input: RequestInfo | URL) => {
+    const url = String(input);
+    const body = url.includes("/api/sync/pull")
+      ? { changes: [], cursor: { last_seq: 0 }, has_more: false }
+      : url.includes("/api/auth/me")
+        ? { user_id: "u1" }
+        : {};
+    return new Response(JSON.stringify(body), { status: 200 });
+  }) as typeof fetch;
+});
+
+afterEach(() => {
+  globalThis.fetch = realFetch;
+});
+
+async function startEngine() {
+  const persistence = new IndexedDBPersistence(`live-batch-${Math.random().toString(36).slice(2)}`);
+  const engine = new SyncEngine({
+    baseUrl: "http://test.invalid",
+    persistence,
+    multiTab: false,
+    transport: "poll",
+    pollInterval: 1e9,
+    reconcileOnVisibility: false,
+  });
+  await engine.start();
+  const db = persistence.connection!;
+  const realTx = db.transaction.bind(db);
+  const counts = { writeTx: 0 };
+  (db as unknown as { transaction: typeof db.transaction }).transaction = ((
+    ...args: Parameters<typeof db.transaction>
+  ) => {
+    if (String(args[1]) === "readwrite") counts.writeTx += 1;
+    return realTx(...args);
+  }) as typeof db.transaction;
+  let notifies = 0;
+  engine.store.subscribe(() => {
+    notifies += 1;
+  });
+  const internals = engine as unknown as {
+    transportHost(): { onChangeEvent(ev: ChangeEvent): void };
+    applyQueue: Promise<void>;
+  };
+  const host = internals.transportHost();
+  return {
+    engine,
+    persistence,
+    counts,
+    notifies: () => notifies,
+    /** Deliver frames one task each, like WebSocket messages. */
+    async deliver(frames: ChangeEvent[]) {
+      const channel = new MessageChannel();
+      await new Promise<void>((resolve) => {
+        let n = 0;
+        channel.port1.onmessage = (m) => {
+          host.onChangeEvent(frames[m.data as number]!);
+          if (++n === frames.length) resolve();
+        };
+        frames.forEach((_, i) => channel.port2.postMessage(i));
+      });
+      channel.port1.close();
+      const last = frames[frames.length - 1]!.seq;
+      while (engine.getCursor().last_seq < last) {
+        await internals.applyQueue;
+        await new Promise((r) => setTimeout(r, 0));
+      }
+      await internals.applyQueue;
+    },
+  };
+}
+
+function insert(seq: number, id: string, data: Record<string, unknown>): ChangeEvent {
+  return { seq, entity: "Msg", row_id: id, kind: "insert", data: { id, ...data }, timestamp: "" };
+}
+
+describe("live frame group commit", () => {
+  test("a burst of frames shares IndexedDB transactions and store notifies", async () => {
+    const t = await startEngine();
+    const frames = Array.from({ length: 300 }, (_, i) => insert(i + 1, `m${i}`, { body: `hi ${i}` }));
+    const notifiesBefore = t.notifies();
+    const t0 = performance.now();
+    await t.deliver(frames);
+    const ms = performance.now() - t0;
+
+    const snap = await t.persistence.loadSnapshot();
+    expect(snap.entities.Msg).toHaveLength(300);
+    expect(snap.cursor?.last_seq).toBe(300);
+    expect(t.engine.store.list("Msg")).toHaveLength(300);
+    // One frame per step used to cost two write transactions (row, then
+    // cursor): 600 here. Batches cost one each.
+    expect(t.counts.writeTx).toBeLessThan(60);
+    expect(t.notifies() - notifiesBefore).toBeLessThan(60);
+    console.log(
+      `[bench] 300 frames: ${Math.round(ms)} ms, ${t.counts.writeTx} write transactions, ` +
+        `${t.notifies() - notifiesBefore} notifies (fake-indexeddb)`,
+    );
+    t.engine.stop();
+  });
+
+  test("order inside a batch holds on disk: insert, update, delete, re-insert", async () => {
+    const t = await startEngine();
+    await t.deliver([
+      insert(1, "a", { v: 1 }),
+      { seq: 2, entity: "Msg", row_id: "a", kind: "update", data: { v: 2 }, timestamp: "" },
+      insert(3, "b", { v: 1 }),
+      { seq: 4, entity: "Msg", row_id: "b", kind: "delete", timestamp: "" } as ChangeEvent,
+      insert(5, "c", { v: 1 }),
+      { seq: 6, entity: "Msg", row_id: "c", kind: "update", data: { v: 3 }, timestamp: "" },
+    ]);
+    const snap = await t.persistence.loadSnapshot();
+    const byId = Object.fromEntries((snap.entities.Msg ?? []).map((r) => [r.id, r]));
+    expect(byId.a).toMatchObject({ id: "a", v: 2 });
+    expect(byId.b).toBeUndefined();
+    expect(byId.c).toMatchObject({ id: "c", v: 3 });
+    expect(snap.cursor?.last_seq).toBe(6);
+    t.engine.stop();
+  });
+
+  test("a stale or repeated frame inside a batch is dropped, as before", async () => {
+    const t = await startEngine();
+    await t.deliver([
+      insert(1, "a", { v: 1 }),
+      { seq: 3, entity: "Msg", row_id: "a", kind: "update", data: { v: 3 }, timestamp: "" },
+      // Arrives after seq 3 in the same batch: older, must not win.
+      { seq: 2, entity: "Msg", row_id: "a", kind: "update", data: { v: 2 }, timestamp: "" },
+      { seq: 3, entity: "Msg", row_id: "a", kind: "update", data: { v: 3 }, timestamp: "" },
+    ]);
+    expect(t.engine.store.get("Msg", "a")).toMatchObject({ v: 3 });
+    const snap = await t.persistence.loadSnapshot();
+    expect(snap.entities.Msg?.[0]).toMatchObject({ v: 3 });
+    t.engine.stop();
+  });
+
+  test("an aborted batch leaves the on-disk cursor behind the rows", async () => {
+    const t = await startEngine();
+    await t.deliver([insert(1, "a", { v: 1 })]);
+    const db = t.persistence.connection!;
+    const wrapped = db.transaction.bind(db);
+    let armed = true;
+    (db as unknown as { transaction: typeof db.transaction }).transaction = ((
+      ...args: Parameters<typeof db.transaction>
+    ) => {
+      const tx = wrapped(...args);
+      if (armed && String(args[1]) === "readwrite") {
+        armed = false;
+        queueMicrotask(() => tx.abort());
+      }
+      return tx;
+    }) as typeof db.transaction;
+    const warn = console.warn;
+    console.warn = () => {};
+    try {
+      await t.deliver([insert(2, "b", { v: 1 }), insert(3, "c", { v: 1 })]);
+    } finally {
+      console.warn = warn;
+    }
+    // Memory moved on; disk kept the cursor at the last committed batch.
+    expect(t.engine.getCursor().last_seq).toBe(3);
+    const snap = await t.persistence.loadSnapshot();
+    expect(snap.cursor?.last_seq).toBe(1);
+    t.engine.stop();
+  });
+});

package/src/local-store.ts

@@ -200,6 +200,20 @@ export class LocalStore {
     }
   }
 
+  /**
+   * Apply to memory and notify once, WITHOUT persisting. Returns each
+   * change with `data` set to the full merged row (deletes unchanged),
+   * ready to write to disk. The engine uses it to write a whole batch in
+   * one transaction (`ReplicaPersistence.saveBatch`).
+   */
+  applyInMemory(changes: ChangeEvent[]): ChangeEvent[] {
+    for (const change of changes) {
+      this.applyChange(change);
+    }
+    this.notify();
+    return changes.map((c) => this.hydrateFromMemory(c));
+  }
+
   /**
    * Apply + persist, awaiting disk writes before returning. Callers
    * that are about to advance a cursor based on `changes` MUST use

package/src/multi-tab-orchestrator.test.ts

@@ -35,6 +35,9 @@ function makeRig(opts: { isLeader?: boolean } = {}) {
       onMutationsForwarded: record("mutationsForwarded"),
       onMutationsAcked: record("mutationsAcked"),
       onMutationsFailed: record("mutationsFailed"),
+      onMutationsQueued: record("mutationsQueued"),
+      onSyncedReceived: record("synced"),
+      onSyncStatusRequested: record("syncStatusRequested"),
       onBinaryReceived: record("binary"),
       onPeerLeft: record("peerLeft"),
       onReplayForwardedMutations: record("replayForwardedMutations"),

package/src/multi-tab-orchestrator.ts

@@ -83,7 +83,18 @@ export interface MultiTabOrchestratorHooks {
   /** Leader → follower: op_ids that were successfully pushed. */
   onMutationsAcked(opIds: string[]): void;
   /** Leader → follower: op_ids that failed server-side validation. */
-  onMutationsFailed(ops: { opId: string; error: string }[]): void;
+  onMutationsFailed(
+    ops: { opId: string; error: string; code?: string }[],
+  ): void;
+  /** Leader → followers: the leader completed a pull (see
+   *  `SyncEngine.isSynced`). */
+  onSyncedReceived(): void;
+  /** Follower → leader: a tab that just started asks whether the leader
+   *  has synced. */
+  onSyncStatusRequested(): void;
+  /** Leader → followers: the leader's push failed transiently and
+   *  these op ids stay queued for retry. */
+  onMutationsQueued(opIds: string[]): void;
   /** Leader → follower: a binary frame from the WS. Engine routes
    *  to its local binary handlers. */
   onBinaryReceived(bytes: Uint8Array): void;
@@ -100,6 +111,9 @@ export interface MultiTabOrchestratorHooks {
    *  `room-unsubscribe` when both the local refcount and the forwarder
    *  set are empty. */
   onRoomSubUnregister?(roomId: string, fromTabId: string): void;
+  /** Follower → leader: the follower rejoined a room after a
+   *  `NOT_IN_ROOM` error; resend the wire `room-subscribe`. */
+  onRoomSubResubscribe?(roomId: string): void;
   /** Leader → followers: a room-snapshot landed on the WS. Followers
    *  apply it to their local room registry so their subscribers fire. */
   onRoomFanoutSnapshot?(roomId: string, members: unknown): void;
@@ -286,7 +300,9 @@ export class MultiTabOrchestrator {
   }
 
   /** Leader → followers: per-op failures with error strings. */
-  broadcastMutationsFailed(ops: { opId: string; error: string }[]): void {
+  broadcastMutationsFailed(
+    ops: { opId: string; error: string; code?: string }[],
+  ): void {
     this.broadcastRaw({ type: "mutations-failed", ops });
   }
 
@@ -369,11 +385,25 @@ export class MultiTabOrchestrator {
       }
       case "mutations-failed": {
         const ops = msg.ops as
-          | { opId: string; error: string }[]
+          | { opId: string; error: string; code?: string }[]
           | undefined;
         if (Array.isArray(ops)) this.hooks.onMutationsFailed(ops);
         break;
       }
+      case "synced": {
+        this.hooks.onSyncedReceived();
+        break;
+      }
+      case "sync-status-request": {
+        if (!this._isLeader) return;
+        this.hooks.onSyncStatusRequested();
+        break;
+      }
+      case "mutations-queued": {
+        const opIds = msg.opIds as string[] | undefined;
+        if (Array.isArray(opIds)) this.hooks.onMutationsQueued(opIds);
+        break;
+      }
       case "sub-register": {
         // Follower → leader. Leader-only — no work to do on a follower
         // because it can't act on a peer's request.
@@ -437,6 +467,12 @@ export class MultiTabOrchestrator {
         }
         break;
       }
+      case "room-sub-resubscribe": {
+        if (!this._isLeader) return;
+        const room = msg.room as string | undefined;
+        if (typeof room === "string") this.hooks.onRoomSubResubscribe?.(room);
+        break;
+      }
       case "room-sub-unregister": {
         if (!this._isLeader) return;
         const room = msg.room as string | undefined;

package/src/mutation-outcome.test.ts

@@ -0,0 +1,203 @@
+// insert / update / delete report the server's verdict to the caller.
+//
+// Before: a write the server refused (policy denial, validation) was
+// rolled back locally and marked failed, but the promise the caller
+// awaited still resolved, so the UI could not say "Message not sent".
+
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { MutationRejectedError, SyncEngine } from "./index";
+import type { PendingMutation } from "./mutation-queue";
+import { createTestEnv, type TestEnv } from "./test-harness";
+
+describe("mutation outcome", () => {
+  let env: TestEnv | null = null;
+  afterEach(async () => {
+    if (env) await env.dispose();
+    env = null;
+  });
+
+  test("insert rejects with the server's error code and removes the ghost", async () => {
+    env = createTestEnv({ transport: "poll" });
+    env.signIn({ userId: "u1" });
+    await env.start();
+    env.server.denyWrites("Message", "POLICY_DENIED", "not a member of this channel");
+
+    let caught: unknown = null;
+    try {
+      await env.engine.insert("Message", { body: "hi" });
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(MutationRejectedError);
+    const err = caught as MutationRejectedError;
+    expect(err.code).toBe("POLICY_DENIED");
+    expect(err.message).toBe("not a member of this channel");
+    expect(err.entity).toBe("Message");
+    expect(err.kind).toBe("insert");
+    expect(env.engine.store.list("Message")).toHaveLength(0);
+  });
+
+  test("update and delete reject and restore the row", async () => {
+    env = createTestEnv({ transport: "poll" });
+    env.signIn({ userId: "u1" });
+    env.server.seed("Note", [{ id: "n1", title: "original" }]);
+    await env.start();
+    env.server.denyWrites("Note", "VALIDATION_FAILED", "title too long");
+
+    await expect(env.engine.update("Note", "n1", { title: "x" })).rejects.toMatchObject({
+      name: "MutationRejectedError",
+      code: "VALIDATION_FAILED",
+      kind: "update",
+    });
+    expect((env.engine.store.get("Note", "n1") as { title?: string }).title).toBe("original");
+
+    await expect(env.engine.delete("Note", "n1")).rejects.toMatchObject({
+      code: "VALIDATION_FAILED",
+      kind: "delete",
+    });
+    expect(env.engine.store.get("Note", "n1")).not.toBeNull();
+  });
+
+  test("a whole-request rejection (HTTP 403) rejects the caller", async () => {
+    env = createTestEnv({ transport: "poll" });
+    env.signIn({ userId: "u1" });
+    await env.start();
+    env.server.primeNextPushOutcome({ kind: "status", status: 403 });
+    await expect(env.engine.insert("Note", { title: "x" })).rejects.toMatchObject({
+      code: "PUSH_REJECTED",
+    });
+    expect(env.engine.store.list("Note")).toHaveLength(0);
+  });
+
+  test("an applied insert resolves with the row id", async () => {
+    env = createTestEnv({ transport: "poll" });
+    env.signIn({ userId: "u1" });
+    await env.start();
+    const id = await env.engine.insert("Note", { title: "ok" });
+    expect(env.engine.store.get("Note", id)).not.toBeNull();
+    expect(env.server.receivedPushKeys).toContain(`Note/${id}`);
+  });
+
+  test("an offline insert resolves (queued) and keeps the ghost", async () => {
+    env = createTestEnv({ transport: "poll" });
+    env.signIn({ userId: "u1" });
+    await env.start();
+    env.server.primeNextPushOutcome({ kind: "network" });
+    const id = await env.engine.insert("Note", { title: "offline" });
+    expect(env.engine.store.get("Note", id)).not.toBeNull();
+    expect(env.engine.pendingCount()).toBe(1);
+  });
+
+  test("a stopped engine does not retry a failed push", async () => {
+    env = createTestEnv({ transport: "poll" });
+    env.signIn({ userId: "u1" });
+    await env.start();
+    env.server.primeNextPushOutcome({ kind: "network" });
+    await env.engine.insert("Note", { title: "offline" });
+    env.engine.stop();
+    const before = env.transport.fetchCount();
+    // The transient failure scheduled a retry 1s out.
+    await new Promise((r) => setTimeout(r, 1300));
+    expect(env.transport.fetchCount()).toBe(before);
+  });
+
+  test("a write queued while a push is running still reaches the server", async () => {
+    env = createTestEnv({ transport: "poll" });
+    env.signIn({ userId: "u1" });
+    await env.start();
+    // The second insert starts while the first push waits on the
+    // server. Its push() call joins the running push, whose batch was
+    // taken before the second write was queued.
+    let release!: () => void;
+    env.server.pushGate = new Promise<void>((r) => (release = r));
+    const p1 = env.engine.insert("Note", { title: "one" });
+    await env.flush(10);
+    expect(env.server.pushRequestCount).toBe(1);
+    const p2 = env.engine.insert("Note", { title: "two" });
+    await env.flush(10);
+    env.server.pushGate = null;
+    release();
+    const [a, b] = await Promise.all([p1, p2]);
+    expect(env.server.receivedPushKeys).toContain(`Note/${a}`);
+    expect(env.server.receivedPushKeys).toContain(`Note/${b}`);
+    expect(env.engine.pendingCount()).toBe(0);
+  });
+
+  test("an identity-flip wipe rejects writes still waiting", async () => {
+    env = createTestEnv({ transport: "poll" });
+    env.signIn({ userId: "u1" });
+    await env.start();
+    const engine = env.engine as unknown as {
+      isMultiTabLeader: boolean;
+      broadcastToTabs: (p: unknown) => void;
+    };
+    // As a follower the write waits for the leader's verdict.
+    engine.isMultiTabLeader = false;
+    engine.broadcastToTabs = () => {};
+    const p = env.engine.insert("Note", { title: "draft" });
+    await env.flush();
+    await env.engine.resetReplica({ wipeMutations: true });
+    await expect(p).rejects.toMatchObject({ code: "DISCARDED" });
+  });
+});
+
+describe("mutation outcome in a follower tab", () => {
+  function follower() {
+    const engine = new SyncEngine({
+      baseUrl: "http://test.invalid",
+      persist: false,
+      multiTab: false,
+    });
+    const sent: unknown[] = [];
+    const internals = engine as unknown as {
+      isMultiTabLeader: boolean;
+      broadcastToTabs: (p: unknown) => void;
+      multiTabHooks: () => {
+        onMutationsAcked: (ids: string[]) => void;
+        onMutationsFailed: (ops: { opId: string; error: string; code?: string }[]) => void;
+        onMutationsQueued: (ids: string[]) => void;
+      };
+    };
+    internals.isMultiTabLeader = false;
+    internals.broadcastToTabs = (p) => sent.push(p);
+    const hooks = internals.multiTabHooks();
+    const forwardedOpId = () => {
+      const msg = sent.find(
+        (m) => (m as { type?: string }).type === "mutations",
+      ) as { ops: PendingMutation[] } | undefined;
+      return msg!.ops[0]!.id;
+    };
+    return { engine, hooks, forwardedOpId };
+  }
+
+  test("the leader's rejection rejects the follower's caller and rolls back", async () => {
+    const { engine, hooks, forwardedOpId } = follower();
+    const p = engine.insert("Message", { body: "hi" });
+    await Promise.resolve();
+    await new Promise((r) => setTimeout(r, 0));
+    expect(engine.store.list("Message")).toHaveLength(1);
+    hooks.onMutationsFailed([
+      { opId: forwardedOpId(), error: "denied", code: "POLICY_DENIED" },
+    ]);
+    await expect(p).rejects.toMatchObject({ code: "POLICY_DENIED" });
+    expect(engine.store.list("Message")).toHaveLength(0);
+  });
+
+  test("the leader's ack resolves the follower's caller", async () => {
+    const { engine, hooks, forwardedOpId } = follower();
+    const p = engine.insert("Message", { body: "hi" });
+    await new Promise((r) => setTimeout(r, 0));
+    hooks.onMutationsAcked([forwardedOpId()]);
+    expect(typeof (await p)).toBe("string");
+  });
+
+  test("the leader's queued notice resolves the follower's caller", async () => {
+    const { engine, hooks, forwardedOpId } = follower();
+    const p = engine.insert("Message", { body: "hi" });
+    await new Promise((r) => setTimeout(r, 0));
+    hooks.onMutationsQueued([forwardedOpId()]);
+    expect(typeof (await p)).toBe("string");
+    expect(engine.store.list("Message")).toHaveLength(1);
+  });
+});

package/src/mutation-owner-token.test.ts

@@ -0,0 +1,131 @@
+// Owner check edge cases found in the third review: a push between a
+// token swap and the session refresh, writes made before any identity is
+// known, a session that expired across a reload, and guest -> user.
+
+import "fake-indexeddb/auto";
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { IndexedDBPersistence, SyncEngine } from "./index";
+import { IndexedDBMutationPersistence } from "./persistence";
+import { createTestEnv, type TestEnv } from "./test-harness";
+
+describe("mutation owner and the bearer token", () => {
+  let env: TestEnv | null = null;
+  const realFetch = globalThis.fetch;
+  afterEach(async () => {
+    if (env) await env.dispose();
+    env = null;
+    globalThis.fetch = realFetch;
+  });
+
+  test("a push after a token swap and before the refresh does not send A's write with B's token", async () => {
+    env = createTestEnv({ transport: "poll" });
+    env.signIn({ userId: "uA" });
+    await env.start();
+    env.server.primeNextPushOutcome({ kind: "network" });
+    const id = await env.engine.insert("Note", { title: "A's draft" });
+    const pushAuth: string[] = [];
+    const inner = globalThis.fetch;
+    globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+      if (String(input).includes("/api/sync/push")) {
+        const h = (init?.headers ?? {}) as Record<string, string>;
+        pushAuth.push(h.Authorization ?? "");
+      }
+      return inner(input, init);
+    }) as typeof fetch;
+    // B's token is stored; nothing has refreshed the session yet.
+    const tokenB = env.signIn({ userId: "uB" });
+    await env.engine.push();
+    expect(pushAuth).not.toContain(`Bearer ${tokenB}`);
+    // Once the session says B, A's write is discarded, never sent.
+    await env.engine.notifySessionChanged();
+    await env.flush(50);
+    expect(env.server.receivedPushKeys.filter((k) => k === `Note/${id}`)).toHaveLength(1);
+    expect(env.engine.pendingCount()).toBe(0);
+  });
+
+  test("a guest's queued write is pushed after the guest signs in", async () => {
+    env = createTestEnv({ transport: "poll" });
+    env.signIn({ userId: "guest_1" });
+    await env.start();
+    env.server.primeNextPushOutcome({ kind: "network" });
+    const id = await env.engine.insert("Note", { title: "guest note" });
+    env.signIn({ userId: "u1" });
+    await env.engine.notifySessionChanged();
+    await env.flush(50);
+    expect(env.engine.pendingCount()).toBe(0);
+    expect(env.server.receivedPushKeys.filter((k) => k === `Note/${id}`)).toHaveLength(2);
+  });
+
+  test("a write made before any identity is known waits for the first session and takes its owner", async () => {
+    let meCalls = 0;
+    let pushes = 0;
+    globalThis.fetch = (async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.includes("/api/auth/me")) {
+        meCalls += 1;
+        if (meCalls <= 2) throw new TypeError("offline");
+        return new Response(JSON.stringify({ user_id: "u1" }), { status: 200 });
+      }
+      if (url.includes("/api/sync/push")) {
+        pushes += 1;
+        return new Response(JSON.stringify({ applied: 1, errors: [], results: [], cursor: { last_seq: 0 } }), { status: 200 });
+      }
+      return new Response(JSON.stringify({ changes: [], cursor: { last_seq: 0 }, has_more: false }), { status: 200 });
+    }) as typeof fetch;
+    const engine = new SyncEngine({
+      baseUrl: "http://test.invalid",
+      persist: false,
+      multiTab: false,
+      transport: "poll",
+      pollInterval: 1e9,
+    });
+    await engine.start();
+    const insert = engine.insert("Note", { title: "offline" });
+    await new Promise((r) => setTimeout(r, 0));
+    expect(engine.mutations.pending()[0]!.ownerPending).toBe(true);
+    await insert;
+    expect(pushes).toBe(0);
+    for (let i = 0; i < 40 && pushes === 0; i++) await new Promise((r) => setTimeout(r, 50));
+    expect(pushes).toBeGreaterThan(0);
+    engine.stop();
+  }, 10_000);
+
+  test("a session that expired across a reload keeps the user's queued writes", async () => {
+    globalThis.fetch = (async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.includes("/api/sync/push")) throw new Error("must not push");
+      const body = url.includes("/api/auth/me")
+        ? { user_id: null }
+        : { changes: [], cursor: { last_seq: 0 }, has_more: false };
+      return new Response(JSON.stringify(body), { status: 200 });
+    }) as typeof fetch;
+    const name = `expired-${Math.random().toString(36).slice(2)}`;
+    const disk = new IndexedDBPersistence(name);
+    await disk.open();
+    await disk.saveIdentity("u1");
+    await disk.saveCursor({ last_seq: 1 });
+    await new IndexedDBMutationPersistence(disk).saveAll([
+      {
+        id: "op-1",
+        change: { entity: "Note", row_id: "n1", kind: "insert", data: { id: "n1" }, op_id: "op-1" },
+        status: "pending",
+        owner: "u1",
+      },
+    ]);
+    disk.connection?.close();
+    const reopened = new IndexedDBPersistence(name);
+    const engine = new SyncEngine({
+      baseUrl: "http://test.invalid",
+      persistence: reopened,
+      multiTab: false,
+      transport: "poll",
+      pollInterval: 1e9,
+    });
+    await engine.start();
+    await engine.push();
+    expect(engine.pendingCount()).toBe(1);
+    engine.stop();
+    reopened.connection?.close();
+  });
+});