@pylonsync/sync 0.20.0 → 0.22.0

package/src/mutation-owner.test.ts

@@ -0,0 +1,217 @@
+// Every queued write carries the user it was made as, and push only sends
+// it as that user. Found in the second review of the identity-reset fix:
+// a follower tab could forward user A's write for the leader to push as
+// user B, a token change whose /api/auth/me failed held every write
+// forever, and a reload while signed out pushed the held writes as the
+// anonymous caller.
+
+import "fake-indexeddb/auto";
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { IndexedDBPersistence, SyncEngine, type ChangeEvent } from "./index";
+import type { PendingMutation } from "./mutation-queue";
+import { createTestEnv, type TestEnv } from "./test-harness";
+
+const session = (userId: string | null) => ({
+  userId,
+  tenantId: null,
+  isAdmin: false,
+  roles: [],
+  avatarUrl: null,
+});
+
+describe("mutation owner", () => {
+  let env: TestEnv | null = null;
+  const realFetch = globalThis.fetch;
+  afterEach(async () => {
+    if (env) await env.dispose();
+    env = null;
+    globalThis.fetch = realFetch;
+  });
+
+  test("a write is tagged with the user who made it", async () => {
+    env = createTestEnv({ transport: "poll" });
+    env.signIn({ userId: "u1" });
+    await env.start();
+    env.server.primeNextPushOutcome({ kind: "network" });
+    await env.engine.insert("Note", { title: "x" });
+    expect(env.engine.mutations.pending()[0]!.owner).toBe("u1");
+  });
+
+  test("the leader discards a forwarded write of another user; the follower drops it", async () => {
+    // Leader, signed in as B.
+    env = createTestEnv({ transport: "poll" });
+    env.signIn({ userId: "uB" });
+    await env.start();
+    const leaderSent: unknown[] = [];
+    (env.engine as unknown as { broadcastToTabs: (p: unknown) => void }).broadcastToTabs = (p) =>
+      leaderSent.push(p);
+    const forwarded: PendingMutation = {
+      id: "op-a",
+      change: { entity: "Note", row_id: "n-a", kind: "insert", data: { id: "n-a" }, op_id: "op-a" },
+      status: "pending",
+      owner: "uA",
+    };
+    (env.engine as unknown as {
+      multiTabHooks: () => { onMutationsForwarded: (ops: PendingMutation[]) => void };
+    })
+      .multiTabHooks()
+      .onMutationsForwarded([forwarded]);
+    await env.flush(20);
+    expect(env.server.receivedPushKeys).not.toContain("Note/n-a");
+    expect(env.engine.pendingCount()).toBe(0);
+    expect(leaderSent).toContainEqual({
+      type: "mutations-failed",
+      ops: [{ opId: "op-a", error: "discarded: another user is signed in", code: "DISCARDED" }],
+    });
+
+    // Follower that made the write: it drops the op without restoring rows.
+    const follower = new SyncEngine({ baseUrl: "http://test.invalid", persist: false, multiTab: false });
+    const f = follower as unknown as {
+      isMultiTabLeader: boolean;
+      broadcastToTabs: (p: unknown) => void;
+      multiTabHooks: () => {
+        onMutationsFailed: (ops: { opId: string; error: string; code?: string }[]) => void;
+      };
+    };
+    f.isMultiTabLeader = false;
+    f.broadcastToTabs = () => {};
+    follower.store.applyChange({ seq: 1, entity: "Note", row_id: "n0", kind: "insert", data: { id: "n0", title: "A's row" }, timestamp: "" });
+    const p = follower.update("Note", "n0", { title: "A edit" });
+    await new Promise((r) => setTimeout(r, 0));
+    // The leader's reset for B already wiped this tab's rows.
+    follower.store.clearAll();
+    const opId = follower.mutations.pending()[0]!.id;
+    f.multiTabHooks().onMutationsFailed([{ opId, error: "discarded", code: "DISCARDED" }]);
+    await expect(p).rejects.toMatchObject({ code: "DISCARDED" });
+    expect(follower.pendingCount()).toBe(0);
+    expect(follower.store.get("Note", "n0")).toBeNull();
+  });
+
+  test("a token change whose session refresh fails retries until the writes push", async () => {
+    env = createTestEnv({ transport: "poll" });
+    env.signIn({ userId: "u1" });
+    await env.start();
+    const inner = globalThis.fetch;
+    let failMe = true;
+    globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+      if (failMe && String(input).includes("/api/auth/me")) throw new TypeError("network down");
+      return inner(input, init);
+    }) as typeof fetch;
+    env.signIn({ userId: "u1" }); // token rotation
+    await env.engine.pull();
+    await env.flush(20);
+    const id = await env.engine.insert("Note", { title: "after rotation" });
+    expect(env.engine.pendingCount()).toBe(1);
+    failMe = false;
+    for (let i = 0; i < 60 && env.engine.pendingCount() > 0; i++) {
+      await new Promise((r) => setTimeout(r, 50));
+    }
+    expect(env.engine.pendingCount()).toBe(0);
+    expect(env.server.receivedPushKeys).toContain(`Note/${id}`);
+  }, 10_000);
+
+  test("after a reload while signed out, the previous user's queued writes are not pushed", 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/sync/pull")
+        ? { changes: [], cursor: { last_seq: 0 }, has_more: false }
+        : url.includes("/api/auth/me")
+          ? { user_id: null }
+          : {};
+      return new Response(JSON.stringify(body), { status: 200 });
+    }) as typeof fetch;
+    const name = `owner-${Math.random().toString(36).slice(2)}`;
+    // What the previous run left on disk: the replica tagged anonymous
+    // (u1's session expired) and u1's queued write.
+    const disk = new IndexedDBPersistence(name);
+    await disk.open();
+    await disk.saveIdentity(null);
+    await disk.saveCursor({ last_seq: 1 });
+    const { IndexedDBMutationPersistence } = await import("./persistence");
+    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);
+    expect(engine.mutations.pending()[0]!.owner).toBe("u1");
+    engine.stop();
+    reopened.connection?.close();
+  });
+
+  test("a follower applies the leader's rows that arrive while its own reset runs", async () => {
+    const persistence = new IndexedDBPersistence(`fence-${Math.random().toString(36).slice(2)}`);
+    await persistence.open();
+    const engine = new SyncEngine({ baseUrl: "http://test.invalid", persistence, multiTab: false });
+    const internals = engine as unknown as {
+      persistence: IndexedDBPersistence;
+      isMultiTabLeader: boolean;
+      broadcastToTabs: (p: unknown) => void;
+      multiTabHooks: () => {
+        onResetReceived: (wipe: boolean) => void;
+        onAppliedReceived: (c: ChangeEvent[], t?: { last_seq: number }) => void;
+      };
+    };
+    internals.persistence = persistence;
+    internals.isMultiTabLeader = false;
+    internals.broadcastToTabs = () => {};
+    const hooks = internals.multiTabHooks();
+    let release!: () => void;
+    const gate = new Promise<void>((r) => (release = r));
+    let started = false;
+    const realClear = persistence.clear.bind(persistence);
+    persistence.clear = async () => {
+      started = true;
+      await gate;
+      return realClear();
+    };
+    hooks.onResetReceived(false);
+    while (!started) await new Promise((r) => setTimeout(r, 1));
+    hooks.onAppliedReceived(
+      [{ seq: 3, entity: "Deal", row_id: "d1", kind: "insert", data: { id: "d1" }, timestamp: "" }],
+      { last_seq: 3 },
+    );
+    release();
+    await new Promise((r) => setTimeout(r, 50));
+    expect(engine.store.list("Deal")).toHaveLength(1);
+    expect(engine.getCursor().last_seq).toBe(3);
+    engine.stop();
+    persistence.connection?.close();
+  });
+
+  test("an update from a follower tab keeps its session owner when forwarded", async () => {
+    const engine = new SyncEngine({ baseUrl: "http://test.invalid", persist: false, multiTab: false });
+    const internals = engine as unknown as {
+      isMultiTabLeader: boolean;
+      broadcastToTabs: (p: unknown) => void;
+      multiTabHooks: () => { onSessionReceived: (s: unknown) => void };
+      sessionChain: Promise<void>;
+    };
+    internals.isMultiTabLeader = false;
+    const sent: { type?: string; ops?: PendingMutation[] }[] = [];
+    internals.broadcastToTabs = (p) => sent.push(p as { type?: string });
+    internals.multiTabHooks().onSessionReceived(session("uA"));
+    await internals.sessionChain;
+    void engine.insert("Note", { title: "draft" });
+    await new Promise((r) => setTimeout(r, 0));
+    const fwd = sent.find((m) => m.type === "mutations");
+    expect(fwd?.ops?.[0]?.owner).toBe("uA");
+  });
+});

package/src/mutation-queue.ts

@@ -12,11 +12,57 @@
 
 import type { ClientChange, Row } from "./types";
 
+/**
+ * Thrown by `SyncEngine.insert` / `update` / `delete` when the server
+ * rejects the write (policy denial, validation, conflict). The optimistic
+ * change is rolled back before the promise rejects.
+ *
+ * `code` is the server's error code when it sent one (`POLICY_DENIED`,
+ * `VALIDATION_FAILED`, ...). `DISCARDED` means the write never reached the
+ * server: an identity change dropped it from the queue.
+ */
+export class MutationRejectedError extends Error {
+  readonly code: string;
+  readonly opId: string;
+  readonly entity: string;
+  readonly rowId: string;
+  readonly kind: "insert" | "update" | "delete";
+
+  constructor(
+    message: string,
+    opts: {
+      code?: string;
+      opId: string;
+      entity: string;
+      rowId: string;
+      kind: "insert" | "update" | "delete";
+    },
+  ) {
+    super(message);
+    this.name = "MutationRejectedError";
+    this.code = opts.code ?? "REJECTED";
+    this.opId = opts.opId;
+    this.entity = opts.entity;
+    this.rowId = opts.rowId;
+    this.kind = opts.kind;
+  }
+}
+
 export interface PendingMutation {
   id: string;
   change: ClientChange;
   status: "pending" | "applied" | "failed";
   error?: string;
+  /** Server error code for a failed mutation, when the server sent one. */
+  errorCode?: string;
+  /** User id the write was made as (`null` = anonymous). Persisted with
+   *  the queue so a write is only ever pushed as the user who made it.
+   *  `undefined` = unknown (queued by an older client). */
+  owner?: string | null;
+  /** The write was made before this run knew who is signed in (no
+   *  resolved session and no saved identity). It is held until the first
+   *  session resolves, which stamps `owner`. */
+  ownerPending?: boolean;
   /** Pre-mutation snapshot of the affected row, captured at optimistic-
    *  apply time for `update`/`delete`. On a server rejection,
    *  `failPushedMutation` restores this so the local replica reverts to
@@ -35,9 +81,17 @@ export interface MutationQueuePersistence {
   loadAll(): Promise<PendingMutation[]>;
 }
 
+interface OutcomeWaiter {
+  resolve: () => void;
+  reject: (err: MutationRejectedError) => void;
+}
+
 export class MutationQueue {
   private queue: PendingMutation[] = [];
   private persistence?: MutationQueuePersistence;
+  /** Callers waiting for a mutation's outcome, by op id. Memory-only:
+   *  a promise cannot outlive the page that created it. */
+  private waiters = new Map<string, OutcomeWaiter[]>();
 
   constructor(persistence?: MutationQueuePersistence) {
     this.persistence = persistence;
@@ -86,14 +140,22 @@ export class MutationQueue {
    *  entry with the same op_id is already queued — a follower
    *  retrying its forward of the same op shouldn't double-queue on
    *  the leader. */
-  add(change: ClientChange, prevRow?: Row | null): string {
+  add(
+    change: ClientChange,
+    prevRow?: Row | null,
+    owner?: string | null,
+    ownerPending?: boolean,
+  ): string {
     const id =
       typeof change.op_id === "string" && change.op_id.length > 0
         ? change.op_id
         : `mut_${Date.now()}_${Math.random().toString(36).slice(2)}`;
     if (this.queue.some((m) => m.id === id)) return id;
     const changeWithOp: ClientChange = { ...change, op_id: id };
-    this.queue.push({ id, change: changeWithOp, status: "pending", prevRow });
+    const entry: PendingMutation = { id, change: changeWithOp, status: "pending", prevRow };
+    if (owner !== undefined) entry.owner = owner;
+    if (ownerPending) entry.ownerPending = true;
+    this.queue.push(entry);
     this.flush();
     return id;
   }
@@ -132,19 +194,65 @@ export class MutationQueue {
     return out;
   }
 
+  /**
+   * Resolve once the server applies the mutation or the mutation is
+   * queued behind a transient failure (`settleQueued`); reject with a
+   * `MutationRejectedError` once the server rejects it. Settles at once
+   * when the mutation already reached a terminal state.
+   */
+  waitForOutcome(id: string): Promise<void> {
+    const m = this.get(id);
+    if (m?.status === "applied") return Promise.resolve();
+    if (m?.status === "failed") return Promise.reject(rejectionFor(m));
+    return new Promise<void>((resolve, reject) => {
+      const list = this.waiters.get(id) ?? [];
+      list.push({ resolve, reject });
+      this.waiters.set(id, list);
+    });
+  }
+
+  /** Resolve the waiters of a mutation that stays queued after a
+   *  transient push failure (offline, 5xx). The mutation stays pending
+   *  and is retried; a later rejection shows up as `status: "failed"`. */
+  settleQueued(id: string): void {
+    this.resolveWaiters(id);
+  }
+
   markApplied(id: string): void {
     const m = this.queue.find((m) => m.id === id);
     if (m) m.status = "applied";
     this.flush();
+    this.resolveWaiters(id);
   }
 
-  markFailed(id: string, error: string): void {
+  markFailed(id: string, error: string, errorCode?: string): void {
     const m = this.queue.find((m) => m.id === id);
     if (m) {
       m.status = "failed";
       m.error = error;
+      if (errorCode) m.errorCode = errorCode;
     }
     this.flush();
+    const waiters = this.waiters.get(id);
+    if (!waiters) return;
+    this.waiters.delete(id);
+    const err = m
+      ? rejectionFor(m)
+      : new MutationRejectedError(error, {
+          code: errorCode,
+          opId: id,
+          entity: "",
+          rowId: "",
+          kind: "insert",
+        });
+    for (const w of waiters) w.reject(err);
+  }
+
+  private resolveWaiters(id: string): void {
+    const waiters = this.waiters.get(id);
+    if (!waiters) return;
+    this.waiters.delete(id);
+    for (const w of waiters) w.resolve();
   }
 
   /**
@@ -158,6 +266,43 @@ export class MutationQueue {
     this.flush();
   }
 
+  /** Stamp every write whose owner was pending with the user the first
+   *  resolved session names. */
+  stampPendingOwner(owner: string | null): void {
+    let changed = false;
+    for (const m of this.queue) {
+      if (m.ownerPending) {
+        m.owner = owner;
+        delete m.ownerPending;
+        changed = true;
+      }
+    }
+    if (changed) this.flush();
+  }
+
+  /** Drop one mutation that must never be pushed (it belongs to another
+   *  identity) and reject its waiters with code `DISCARDED`. Does not
+   *  touch the local store. */
+  discard(id: string): void {
+    const m = this.get(id);
+    this.queue = this.queue.filter((q) => q.id !== id);
+    this.flush();
+    const waiters = this.waiters.get(id);
+    if (!waiters) return;
+    this.waiters.delete(id);
+    const err = new MutationRejectedError(
+      "The write was discarded because the signed-in identity changed.",
+      {
+        code: "DISCARDED",
+        opId: id,
+        entity: m?.change.entity ?? "",
+        rowId: m?.change.row_id ?? "",
+        kind: m?.change.kind ?? "insert",
+      },
+    );
+    for (const w of waiters) w.reject(err);
+  }
+
   /** Remove a specific mutation by id. Used by the UI after user
    *  ack of failures. */
   remove(id: string): void {
@@ -177,8 +322,27 @@ export class MutationQueue {
    * offline writes survive a snapshot refresh.
    */
   clearAll(): void {
+    const dropped = this.queue;
     this.queue = [];
     this.flush();
+    // Nobody will push these writes any more. Reject their waiters so a
+    // caller awaiting the outcome does not hang.
+    for (const m of dropped) {
+      const waiters = this.waiters.get(m.id);
+      if (!waiters) continue;
+      this.waiters.delete(m.id);
+      const err = new MutationRejectedError(
+        "The write was discarded because the signed-in identity changed.",
+        {
+          code: "DISCARDED",
+          opId: m.id,
+          entity: m.change.entity,
+          rowId: m.change.row_id,
+          kind: m.change.kind,
+        },
+      );
+      for (const w of waiters) w.reject(err);
+    }
   }
 
   /** Fire-and-forget persistence write. */
@@ -190,3 +354,13 @@ export class MutationQueue {
     });
   }
 }
+
+function rejectionFor(m: PendingMutation): MutationRejectedError {
+  return new MutationRejectedError(m.error ?? "The server rejected the write.", {
+    code: m.errorCode,
+    opId: m.id,
+    entity: m.change.entity,
+    rowId: m.change.row_id,
+    kind: m.change.kind,
+  });
+}

package/src/persistence.ts

@@ -31,6 +31,14 @@ export interface ReplicaPersistence {
   saveRow(entity: string, id: string, data: Row): Promise<boolean>;
   deleteRow(entity: string, id: string): Promise<boolean>;
   clear(): Promise<boolean>;
+  /**
+   * Optional: write a batch of row changes, in order, and (when given) the
+   * cursor in ONE atomic transaction. Resolves `true` when the whole batch
+   * committed, `false` when it did not (nothing, cursor included, may be
+   * assumed on disk). The engine uses it to commit many live change frames
+   * at once; without it the engine writes row by row, then the cursor.
+   */
+  saveBatch?(changes: ChangeEvent[], cursor: SyncCursor | null): Promise<boolean>;
 }
 
 // ---------------------------------------------------------------------------
@@ -156,6 +164,29 @@ export class IndexedDBPersistence implements ReplicaPersistence {
     return this.commit(tx, "saveRow");
   }
 
+  /** Write row puts/deletes in order plus the cursor in ONE readwrite
+   *  transaction. Rows and cursor commit or abort together, so the
+   *  on-disk cursor can never get ahead of the on-disk rows. */
+  async saveBatch(changes: ChangeEvent[], cursor: SyncCursor | null): Promise<boolean> {
+    if (!this.db) return false;
+    const tx = this.db.transaction([STORE_NAME, CURSOR_STORE], "readwrite");
+    const rows = tx.objectStore(STORE_NAME);
+    for (const change of changes) {
+      if (change.kind === "delete") {
+        rows.delete(`${change.entity}:${change.row_id}`);
+      } else if (change.data) {
+        rows.put({
+          _key: `${change.entity}:${change.row_id}`,
+          entity: change.entity,
+          id: change.row_id,
+          data: change.data,
+        });
+      }
+    }
+    if (cursor) tx.objectStore(CURSOR_STORE).put({ key: "cursor", ...cursor });
+    return this.commit(tx, "saveBatch");
+  }
+
   /** Fetch a row from IndexedDB by key. Used by `persistChange` on update
    *  events to merge the patch against what's already on disk. */
   async getRow(entity: string, id: string): Promise<Row | null> {

package/src/reconcile.test.ts

@@ -499,10 +499,13 @@ describe("SyncEngine replica identity guard", () => {
     expect(engine.store.list("Note").length).toBe(1);
   });
 
-  test("guest→user preserves pending writes (merge); user→user discards them", async () => {
+  // The guard wipes rows but keeps queued writes: each write carries its
+  // owner, and push sends a guest's writes after the guest signs in and
+  // discards another user's (mutation-owner.test.ts).
+  test("an identity change across a reload keeps queued writes for the owner check", async () => {
     const cases: ReadonlyArray<readonly [string, string, boolean]> = [
-      ["guest_123", "user_B", false], // anonymous-merge login: keep writes
-      ["user_A", "user_B", true], // account switch: drop A's writes
+      ["guest_123", "user_B", false],
+      ["user_A", "user_B", false],
     ];
     for (const [prev, now, expectWipeMutations] of cases) {
       const engine = makeEngine();

package/src/room-subscriptions.test.ts

@@ -267,3 +267,35 @@ describe("RoomSubscriptions: replay on reconnect", () => {
     expect(h.sent).toEqual([{ type: "room-subscribe", room: "channel:b" }]);
   });
 });
+
+describe("RoomSubscriptions: resubscribe after a rejoin", () => {
+  test("resubscribe() clears the error and resends room-subscribe", () => {
+    const h = makeHarness();
+    h.rooms.register("channel:a", () => {});
+    h.rooms.applyError("channel:a", { code: "NOT_IN_ROOM" });
+    h.sent.length = 0;
+    h.rooms.resubscribe("channel:a");
+    expect(h.rooms.error("channel:a")).toBeNull();
+    expect(h.sent).toEqual([{ type: "room-subscribe", room: "channel:a" }]);
+  });
+
+  test("resubscribe() is a no-op for a room with no subscriber", () => {
+    const h = makeHarness();
+    h.rooms.resubscribe("channel:none");
+    expect(h.sent).toEqual([]);
+  });
+
+  test("a follower engine asks the leader to resubscribe", async () => {
+    const { SyncEngine } = await import("./index");
+    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;
+    };
+    internals.isMultiTabLeader = false;
+    internals.broadcastToTabs = (p) => sent.push(p);
+    engine.resubscribeRoom("channel:a");
+    expect(sent).toEqual([{ type: "room-sub-resubscribe", room: "channel:a" }]);
+  });
+});

package/src/room-subscriptions.ts

@@ -344,6 +344,17 @@ export class RoomSubscriptions {
     return Array.from(this.rooms.keys());
   }
 
+  /** Clear a room's error and resend its `room-subscribe`. Used after
+   *  the caller rejoined the room over HTTP following a `NOT_IN_ROOM`
+   *  reply: the server answers the new subscribe with a snapshot. No-op
+   *  for a room with no local subscriber. */
+  resubscribe(roomId: string): void {
+    const entry = this.rooms.get(roomId);
+    if (!entry) return;
+    entry.error = null;
+    this.sendWs({ type: "room-subscribe", room: roomId });
+  }
+
   /** Resend `room-subscribe` for every active room. Called by the
    *  engine's `onConnected` hook after the WS reopens — the server
    *  forgets per-client subs across disconnects, so without this

package/src/scenarios.test.ts

@@ -760,7 +760,9 @@ describe("sync scenarios", () => {
     await env.flush();
 
     env.server.primeNextPushOutcome({ kind: "status", status: 403 });
-    await env.engine.update("Note", "n1", { title: "edited" });
+    await expect(
+      env.engine.update("Note", "n1", { title: "edited" }),
+    ).rejects.toMatchObject({ name: "MutationRejectedError" });
     await env.flush();
 
     const row = env.engine.store.get("Note", "n1") as { title?: string } | null;
@@ -780,7 +782,9 @@ describe("sync scenarios", () => {
     await env.flush();
 
     env.server.primeNextPushOutcome({ kind: "status", status: 403 });
-    await env.engine.delete("Note", "n1");
+    await expect(env.engine.delete("Note", "n1")).rejects.toMatchObject({
+      name: "MutationRejectedError",
+    });
     await env.flush();
     expect(env.engine.store.get("Note", "n1")).not.toBeNull();
 
@@ -969,7 +973,9 @@ describe("sync scenarios", () => {
   // the previous "<= 2" bound, which would have passed even if
   // coalescing was broken. Pins the inFlightReconcile dedupe.
   test("back-to-back reconcile calls coalesce to a single fetch", async () => {
-    env = createTestEnv();
+    // Poll transport: the WebSocket's on-connect full reconcile is a
+    // separate op and could land inside the measured window.
+    env = createTestEnv({ transport: "poll" });
     env.signIn({ userId: "u1" });
     env.server.seed("Note", [{ id: "n1" }]);
     await env.start();