@spooky-sync/core 0.0.1-canary.21 → 0.0.1-canary.211

package/src/modules/sync/scheduler.retry.test.ts

@@ -0,0 +1,237 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { SyncScheduler } from './scheduler';
+import type { UpQueue, DownQueue, DownEvent, UpEvent } from './queue/index';
+
+// A queue whose drain throws re-queues the failing item at the HEAD and stops
+// the pass (see DownQueue.next). Nothing used to re-arm it: the queues only
+// moved on a fresh enqueue, so one transient failure — canonically the SSP
+// answering 503 NOT_READY for the whole of its bootstrap window — parked every
+// pending `register` forever, and the `useQuery` waiting on it never left its
+// loading state. These cover the backoff that makes that self-heal.
+
+const silentLogger = {
+  child: () => silentLogger,
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+} as any;
+
+/** A queue that mirrors the real ones: a throwing handler re-heads the item. */
+function makeQueue<E>(items: E[]) {
+  return {
+    queue: [...items],
+    get size() {
+      return this.queue.length;
+    },
+    events: { subscribe: () => {} },
+    loadFromDatabase: async () => {},
+    clear() {
+      this.queue = [];
+    },
+    async next(fn: (event: E) => Promise<void>) {
+      const event = this.queue.shift();
+      if (!event) return;
+      const err = await this.run(event, fn);
+      if (err !== undefined) throw err;
+    },
+    // The concurrent down drain takes events itself and runs them, so the fake
+    // has to mirror that half of the real DownQueue too: skip events whose hash
+    // is already in flight, and hand the error back rather than throwing.
+    takeNext(busy: ReadonlySet<string>) {
+      for (let i = 0; i < this.queue.length; i++) {
+        const event = this.queue[i] as unknown as { payload?: { hash?: string } };
+        const hash = event?.payload?.hash;
+        if (hash !== undefined && busy.has(hash)) continue;
+        return this.queue.splice(i, 1)[0];
+      }
+      return undefined;
+    },
+    async run(event: E, fn: (event: E) => Promise<void>) {
+      try {
+        await fn(event);
+        return undefined;
+      } catch (err) {
+        this.queue.unshift(event);
+        return err;
+      }
+    },
+  };
+}
+
+const downEvent = (hash: string) => ({ type: 'register', payload: { hash } }) as DownEvent;
+const upEvent = (n: number) => ({ type: 'delete', mutation_id: n, record_id: n }) as unknown as UpEvent;
+
+describe('SyncScheduler retry', () => {
+  beforeEach(() => vi.useFakeTimers());
+  afterEach(() => vi.useRealTimers());
+
+  it('re-drains a failed down event instead of parking it forever', async () => {
+    const downQueue = makeQueue([downEvent('q1')]);
+    const upQueue = makeQueue<UpEvent>([]);
+    let attempts = 0;
+    const scheduler = new SyncScheduler(
+      upQueue as unknown as UpQueue,
+      downQueue as unknown as DownQueue,
+      async () => {},
+      async () => {
+        attempts++;
+        // Fail the way a bootstrapping SSP does, then succeed.
+        if (attempts < 3) throw new Error('503 NOT_READY');
+      },
+      silentLogger
+    );
+
+    await scheduler.syncDown();
+    expect(attempts).toBe(1);
+    expect(downQueue.size).toBe(1); // re-headed, not dropped
+
+    // Backoff: 500ms, then 1000ms.
+    await vi.advanceTimersByTimeAsync(500);
+    expect(attempts).toBe(2);
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(attempts).toBe(3);
+
+    expect(downQueue.size).toBe(0);
+  });
+
+  it('stops retrying once the queue drains', async () => {
+    const downQueue = makeQueue([downEvent('q1')]);
+    const upQueue = makeQueue<UpEvent>([]);
+    let attempts = 0;
+    const scheduler = new SyncScheduler(
+      upQueue as unknown as UpQueue,
+      downQueue as unknown as DownQueue,
+      async () => {},
+      async () => {
+        attempts++;
+        throw new Error('boom');
+      },
+      silentLogger
+    );
+
+    await scheduler.syncDown();
+    await vi.advanceTimersByTimeAsync(500);
+    expect(attempts).toBe(2);
+
+    // Drain it out from under the scheduler; the next retry finds nothing and
+    // schedules no further work.
+    downQueue.clear();
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(attempts).toBe(2);
+    await vi.advanceTimersByTimeAsync(60_000);
+    expect(attempts).toBe(2);
+  });
+
+  it('comes back for the down queue while the up queue holds the floor', async () => {
+    const downQueue = makeQueue([downEvent('q1')]);
+    const upQueue = makeQueue<UpEvent>([upEvent(1)]);
+    let downAttempts = 0;
+    const scheduler = new SyncScheduler(
+      upQueue as unknown as UpQueue,
+      downQueue as unknown as DownQueue,
+      async () => {},
+      async () => {
+        downAttempts++;
+      },
+      silentLogger
+    );
+
+    // Yields to the non-empty up queue.
+    await scheduler.syncDown();
+    expect(downAttempts).toBe(0);
+
+    // Once the up queue empties, the re-armed pass picks the down event up
+    // without needing a fresh enqueue.
+    upQueue.clear();
+    await vi.advanceTimersByTimeAsync(500);
+    expect(downAttempts).toBe(1);
+  });
+
+  it('pause cancels pending retries', async () => {
+    const downQueue = makeQueue([downEvent('q1')]);
+    const upQueue = makeQueue<UpEvent>([]);
+    let attempts = 0;
+    const scheduler = new SyncScheduler(
+      upQueue as unknown as UpQueue,
+      downQueue as unknown as DownQueue,
+      async () => {},
+      async () => {
+        attempts++;
+        throw new Error('boom');
+      },
+      silentLogger
+    );
+
+    await scheduler.syncDown();
+    expect(attempts).toBe(1);
+
+    await scheduler.pause();
+    await vi.advanceTimersByTimeAsync(60_000);
+    expect(attempts).toBe(1);
+  });
+});
+
+describe('SyncScheduler down concurrency', () => {
+  beforeEach(() => vi.useFakeTimers());
+  afterEach(() => vi.useRealTimers());
+
+  /** Scheduler over a down queue of `hashes`, whose handler blocks until the
+   *  returned `release` is called for that hash. Lets a test observe exactly
+   *  which events are in flight at the same moment. */
+  function makeConcurrent(hashes: string[]) {
+    const downQueue = makeQueue(hashes.map(downEvent));
+    const upQueue = makeQueue<UpEvent>([]);
+    const started: string[] = [];
+    const gates = new Map<string, () => void>();
+    const scheduler = new SyncScheduler(
+      upQueue as unknown as UpQueue,
+      downQueue as unknown as DownQueue,
+      async () => {},
+      async (event) => {
+        const hash = (event as { payload: { hash: string } }).payload.hash;
+        started.push(hash);
+        await new Promise<void>((resolve) => gates.set(hash, resolve));
+      },
+      silentLogger
+    );
+    return { scheduler, started, release: (h: string) => gates.get(h)?.() };
+  }
+
+  it('runs several independent hashes at once instead of one at a time', async () => {
+    // The bug this whole change exists for: strictly serial draining meant one
+    // registration RPC at a time for the entire client.
+    const { scheduler, started, release } = makeConcurrent(['a', 'b', 'c', 'd', 'e']);
+    const pass = scheduler.syncDown();
+    await vi.advanceTimersByTimeAsync(0);
+
+    // Bounded by MAX_CONCURRENT_DOWN (4), not 1.
+    expect(started).toEqual(['a', 'b', 'c', 'd']);
+
+    // Freeing one slot immediately admits the next event.
+    release('a');
+    await vi.advanceTimersByTimeAsync(0);
+    expect(started).toEqual(['a', 'b', 'c', 'd', 'e']);
+
+    for (const h of ['b', 'c', 'd', 'e']) release(h);
+    await pass;
+  });
+
+  it('never overlaps two events for the SAME hash', async () => {
+    // Per-hash ordering is the one invariant the serial queue was providing.
+    const { scheduler, started, release } = makeConcurrent(['a', 'a', 'b']);
+    const pass = scheduler.syncDown();
+    await vi.advanceTimersByTimeAsync(0);
+
+    // The second 'a' is skipped while the first is in flight; 'b' goes ahead.
+    expect(started).toEqual(['a', 'b']);
+
+    release('a');
+    await vi.advanceTimersByTimeAsync(0);
+    expect(started).toEqual(['a', 'b', 'a']);
+
+    release('b');
+    release('a');
+    await pass;
+  });
+});

package/src/modules/sync/scheduler.ts

@@ -1,14 +1,41 @@
-import { Logger } from '../../services/logger/index';
-import { UpQueue, DownQueue, DownEvent, UpEvent, RollbackCallback } from './queue/index';
+import type { Logger } from '../../services/logger/index';
+import type { UpQueue, DownQueue, DownEvent, UpEvent, RollbackCallback } from './queue/index';
 import { SyncQueueEventTypes } from './events/index';
 
 /**
  * SyncScheduler manages when to sync: queue management and orchestration.
  * Decides the order and timing of sync operations.
  */
+/** Backoff for re-draining a queue that halted on an error. */
+const RETRY_BASE_MS = 500;
+/**
+ * How many down events may be in flight at once.
+ *
+ * The down queue was strictly serial: one `register`/`sync`/`cleanup` RPC at a
+ * time for the WHOLE client. Measured in production that drained at roughly one
+ * event per 8.8s, so a list that registers a query per scrolled-to window took
+ * minutes to fill — the rows were already cached, only the registration lagged.
+ * Ordering is a per-hash requirement, not a global one (see `takeNext`), so
+ * independent hashes can go in parallel. Bounded to stay polite to the SSP.
+ */
+const MAX_CONCURRENT_DOWN = 4;
+const RETRY_MAX_MS = 15_000;
+
 export class SyncScheduler {
   private isSyncingUp: boolean = false;
   private isSyncingDown: boolean = false;
+  private paused: boolean = false;
+  private pauseWaiters: Array<() => void> = [];
+  // A failed drain re-queues its item at the HEAD (see DownQueue.next) and
+  // stops the pass. Without a timer nothing ever drains it again: the queues
+  // only move on a fresh enqueue, so a transient failure — canonically the
+  // SSP answering 503 NOT_READY for the whole of its bootstrap window — left
+  // every pending `register` parked forever and its `useQuery` loading forever.
+  // Retry on a backoff so that heals itself instead of needing a reload.
+  private upRetryTimer?: ReturnType<typeof setTimeout>;
+  private downRetryTimer?: ReturnType<typeof setTimeout>;
+  private upRetryAttempt = 0;
+  private downRetryAttempt = 0;
 
   constructor(
     private upQueue: UpQueue,
@@ -16,11 +43,21 @@ export class SyncScheduler {
     private onProcessUp: (event: UpEvent) => Promise<void>,
     private onProcessDown: (event: DownEvent) => Promise<void>,
     private logger: Logger,
-    private onRollback?: RollbackCallback
+    private onRollback?: RollbackCallback,
+    // Reports the outcome of each drained sync round (one syncUp/syncDown pass
+    // that actually processed ≥1 item): `ok=true` on a clean drain, `ok=false`
+    // with the error when the round halted on a failure. Drives the consumer's
+    // sync-health tracking; empty/no-op rounds report nothing.
+    private onSyncOutcome?: (ok: boolean, error?: unknown) => void,
+    // Reports each mutation the server accepted, once its outbox row is gone.
+    // Lets the consumer keep the row rendered until its membership arrives.
+    private onSettled?: (event: UpEvent) => void
   ) {}
 
-  async init() {
-    await this.upQueue.loadFromDatabase();
+  async init(opts: { loadOutbox?: boolean } = {}) {
+    // Shared-tabs followers skip the outbox load: the shared store's
+    // `_00_pending_mutations` is drained by exactly one tab (the leader).
+    if (opts.loadOutbox !== false) await this.upQueue.loadFromDatabase();
     this.upQueue.events.subscribe(SyncQueueEventTypes.MutationEnqueued, this.syncUp.bind(this));
     this.downQueue.events.subscribe(
       SyncQueueEventTypes.QueryItemEnqueued,
@@ -44,18 +81,112 @@ export class SyncScheduler {
     this.downQueue.push(event);
   }
 
+  /**
+   * Suspend syncing for a local-bucket switch. Refuses new rounds and resolves
+   * once any in-flight round has finished — the pause point is BETWEEN queue
+   * items, never between an item's remote push and its outbox-row delete, so a
+   * processed mutation's `DELETE _00_pending_mutations` always lands in the
+   * store it was read from.
+   */
+  pause(): Promise<void> {
+    this.paused = true;
+    this.clearRetryTimers();
+    if (!this.isSyncingUp && !this.isSyncingDown) return Promise.resolve();
+    return new Promise<void>((resolve) => this.pauseWaiters.push(resolve));
+  }
+
+  resume(): void {
+    this.paused = false;
+    // A resume is a fresh start, not a continuation of the failing streak.
+    this.upRetryAttempt = 0;
+    this.downRetryAttempt = 0;
+    void this.syncUp();
+    void this.syncDown();
+  }
+
+  private maybeResolvePause() {
+    if (!this.paused || this.isSyncingUp || this.isSyncingDown) return;
+    const waiters = this.pauseWaiters;
+    this.pauseWaiters = [];
+    for (const resolve of waiters) resolve();
+  }
+
+  /** Exponential backoff, capped. Attempt 0 is the first retry. */
+  private retryDelay(attempt: number): number {
+    return Math.min(RETRY_BASE_MS * 2 ** attempt, RETRY_MAX_MS);
+  }
+
+  private scheduleUpRetry() {
+    if (this.paused || this.upRetryTimer || this.upQueue.size === 0) return;
+    const delay = this.retryDelay(this.upRetryAttempt++);
+    this.upRetryTimer = setTimeout(() => {
+      this.upRetryTimer = undefined;
+      void this.syncUp();
+    }, delay);
+  }
+
+  /**
+   * Re-arm the down pass. With no argument this is failure backoff and the
+   * streak grows; with an explicit delay it is a yield (the up-queue holds the
+   * floor), which is not a failure and must not push the backoff out.
+   */
+  private scheduleDownRetry(delayMs?: number) {
+    if (this.paused || this.downRetryTimer || this.downQueue.size === 0) return;
+    const delay = delayMs ?? this.retryDelay(this.downRetryAttempt++);
+    this.downRetryTimer = setTimeout(() => {
+      this.downRetryTimer = undefined;
+      void this.syncDown();
+    }, delay);
+  }
+
+  private clearRetryTimers() {
+    if (this.upRetryTimer) {
+      clearTimeout(this.upRetryTimer);
+      this.upRetryTimer = undefined;
+    }
+    if (this.downRetryTimer) {
+      clearTimeout(this.downRetryTimer);
+      this.downRetryTimer = undefined;
+    }
+  }
+
+  /** Stop all pending retries. Call when tearing the client down. */
+  dispose(): void {
+    this.paused = true;
+    this.clearRetryTimers();
+  }
+
   /**
    * Process upload queue
    */
   async syncUp() {
-    if (this.isSyncingUp) return;
+    if (this.isSyncingUp || this.paused) return;
     this.isSyncingUp = true;
+    let processedAny = false;
     try {
-      while (this.upQueue.size > 0) {
-        await this.upQueue.next(this.onProcessUp, this.onRollback);
+      while (this.upQueue.size > 0 && !this.paused) {
+        await this.upQueue.next(this.onProcessUp, this.onRollback, this.onSettled);
+        processedAny = true;
       }
+      if (processedAny) this.onSyncOutcome?.(true);
+      this.upRetryAttempt = 0;
+    } catch (error) {
+      this.onSyncOutcome?.(false, error);
+      this.scheduleUpRetry();
+      // syncUp runs fire-and-forget — it's wired to the MutationEnqueued event
+      // (broadcast synchronously, return value dropped) and is also kicked off
+      // via `void this.syncDown()` below. A rejection escaping here therefore
+      // surfaces as an *unhandled promise rejection* in the console rather than
+      // anything a caller can catch. UpQueue.next already logs the failing item
+      // (and re-queues it for retry on the next trigger), so swallow here to
+      // keep the failure contained instead of leaking it globally.
+      this.logger.debug(
+        { error, Category: 'sp00ky-client::SyncScheduler::syncUp' },
+        'syncUp halted on a queue error; item re-queued, will retry on next trigger'
+      );
     } finally {
       this.isSyncingUp = false;
+      this.maybeResolvePause();
       void this.syncDown();
     }
   }
@@ -64,17 +195,88 @@ export class SyncScheduler {
    * Process download queue
    */
   async syncDown() {
-    if (this.isSyncingDown) return;
-    if (this.upQueue.size > 0) return;
+    if (this.isSyncingDown || this.paused) return;
+    // Down-sync yields to a non-empty up-queue so a register never races ahead
+    // of the mutation it should observe. That yield used to be permanent: if
+    // the up-queue never drained, nothing re-armed the down pass. Come back on
+    // the backoff instead, so a wedged push delays reads rather than killing
+    // them.
+    if (this.upQueue.size > 0) {
+      this.scheduleDownRetry(RETRY_BASE_MS);
+      return;
+    }
 
     this.isSyncingDown = true;
+    let processedAny = false;
+    // Hashes currently in flight. `takeNext` skips their events, so per-hash
+    // ordering holds while independent hashes run concurrently.
+    const busy = new Set<string>();
+    const inFlight = new Set<Promise<void>>();
+    // First failure of this pass. Once set we stop TAKING work (mirroring the
+    // old "halt the pass and retry on a backoff") but still let what is already
+    // in flight finish, rather than abandoning RPCs mid-round.
+    let failure: unknown | undefined;
     try {
-      while (this.downQueue.size > 0) {
-        if (this.upQueue.size > 0) break;
-        await this.downQueue.next(this.onProcessDown);
+      for (;;) {
+        if (this.paused) break;
+        // Yield to the up queue: stop taking new down work so a pending
+        // mutation gets its turn. The old code `break`-ed out and came back
+        // only on a backoff, so a steady trickle of local writes could starve
+        // registration indefinitely; draining what is in flight and re-arming
+        // immediately interleaves the two instead.
+        const yieldToUp = this.upQueue.size > 0;
+        while (
+          failure === undefined &&
+          !yieldToUp &&
+          inFlight.size < MAX_CONCURRENT_DOWN
+        ) {
+          const event = this.downQueue.takeNext(busy);
+          if (!event) break;
+          const hash = event.payload.hash;
+          busy.add(hash);
+          processedAny = true;
+          // `run` never rejects — it hands the error back — so one failing
+          // event cannot reject the `Promise.race` below and lose the rest.
+          const task: Promise<void> = this.downQueue
+            .run(event, this.onProcessDown)
+            .then((error) => {
+              if (error !== undefined && failure === undefined) failure = error;
+            })
+            .finally(() => {
+              busy.delete(hash);
+              inFlight.delete(task);
+            });
+          inFlight.add(task);
+        }
+        if (inFlight.size === 0) break;
+        // Wake as soon as ANY slot frees, so the pool refills continuously
+        // instead of in barriers.
+        await Promise.race(inFlight);
+        if (yieldToUp && inFlight.size === 0) break;
       }
+      if (failure !== undefined) throw failure;
+      if (processedAny) this.onSyncOutcome?.(true);
+      this.downRetryAttempt = 0;
+      // Re-arm if we stopped early for the up queue (or hit the pool cap with
+      // work still queued) — otherwise that work waits for a fresh enqueue.
+      if (this.downQueue.size > 0) this.scheduleDownRetry(RETRY_BASE_MS);
+    } catch (error) {
+      this.onSyncOutcome?.(false, error);
+      this.scheduleDownRetry();
+      // Same fire-and-forget story as syncUp: this is the QueryItemEnqueued
+      // subscriber (and is also called via `void this.syncDown()`), so a thrown
+      // error here becomes an unhandled rejection. The canonical case is a
+      // transient remote 500 on `fn::query::register` — DownQueue.next logs it
+      // and re-queues the event at the head; we just stop draining this pass and
+      // let the next enqueue retry, without spamming the console with an
+      // "Uncaught (in promise) ... 500 Internal Server Error".
+      this.logger.debug(
+        { error, Category: 'sp00ky-client::SyncScheduler::syncDown' },
+        'syncDown halted on a queue error; item re-queued, will retry on next trigger'
+      );
     } finally {
       this.isSyncingDown = false;
+      this.maybeResolvePause();
     }
   }
 

package/src/modules/sync/sync.cleanup.test.ts

@@ -0,0 +1,116 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { RecordId } from 'surrealdb';
+import { Sp00kySync } from './sync';
+
+// Guards the teardown half of shared views. A `_00_query` row can be shared by
+// several sessions of the same user, so releasing it MUST go through
+// `fn::query::unsubscribe` — which drops only this session from `subscribers`
+// and deletes the row when it was the last one. A bare `DELETE $id` here would
+// destroy the view and every `_00_list_ref` edge hanging off it for every other
+// live tab, which reads to the user as a list that silently goes blank.
+//
+// This was previously unenforceable: `_00_query` granted no delete permission,
+// so the old `DELETE $id` affected zero rows and did nothing at all. Now that
+// the table grants delete, a regression here is destructive rather than inert.
+
+function makeSync(opts: { hasSubscribers?: boolean[] } = {}) {
+  const logger: any = {
+    child: () => logger,
+    debug: () => {}, info: () => {}, warn: () => {}, error: () => {}, trace: () => {},
+  };
+  const remote: any = { query: vi.fn().mockResolvedValue([{ released: true, remaining: 0 }]) };
+  const queryId = new RecordId('_00_query', 'h1');
+  const queryState: any = { config: { id: queryId } };
+
+  // Successive hasSubscribers() answers: [before the release, after it].
+  const answers = opts.hasSubscribers ?? [false, false];
+  let call = 0;
+  const hasSubscribers = vi.fn(() => answers[Math.min(call++, answers.length - 1)]);
+
+  const finalizeDeregister = vi.fn();
+  const dataModule: any = {
+    getQueryByHash: vi.fn().mockReturnValue(queryState),
+    hasSubscribers,
+    finalizeDeregister,
+  };
+
+  const sync = new Sp00kySync(
+    {} as any, remote, {} as any, dataModule, {} as any, logger,
+  );
+  const enqueueDownEvent = vi.fn();
+  (sync as any).enqueueDownEvent = enqueueDownEvent;
+
+  const run = (hash: string) => (sync as any).cleanupQuery(hash) as Promise<void>;
+  return { remote, dataModule, queryId, finalizeDeregister, enqueueDownEvent, run };
+}
+
+describe('cleanupQuery — releasing a possibly-shared view', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('does not touch the remote view at all; the TTL sweep reclaims it', async () => {
+    // Eager release is deliberately disabled. It was inert for months (the
+    // table granted no delete permission), and making it real turned every
+    // best-effort guard misfire into a live delete of the row and all its
+    // edges. TTL remains the only reclamation that has actually run.
+    const { remote, run } = makeSync();
+
+    await run('h1');
+
+    expect(remote.query).not.toHaveBeenCalled();
+  });
+
+  it('never issues a bare DELETE', async () => {
+    // Belt and braces: if the eager path is ever re-enabled, it must go through
+    // the refcounted `fn::query::unsubscribe`, never a raw DELETE, which would
+    // tear the view out from under other sessions sharing the row.
+    const { remote, run } = makeSync();
+
+    await run('h1');
+
+    const sql = remote.query.mock.calls.map((c: any[]) => c[0]).join('\n');
+    expect(sql).not.toMatch(/\bDELETE\b/i);
+  });
+
+  it('frees local state once released', async () => {
+    const { finalizeDeregister, enqueueDownEvent, run } = makeSync();
+
+    await run('h1');
+
+    expect(finalizeDeregister).toHaveBeenCalledWith('h1');
+    expect(enqueueDownEvent).not.toHaveBeenCalled();
+  });
+
+  it('does not touch the remote row if a subscriber reappeared before the release', async () => {
+    const { remote, finalizeDeregister, run } = makeSync({
+      hasSubscribers: [true],
+    });
+
+    await run('h1');
+
+    expect(remote.query).not.toHaveBeenCalled();
+    expect(finalizeDeregister).not.toHaveBeenCalled();
+  });
+
+  it('still frees local state when a subscriber reappears mid-cleanup', async () => {
+    // With no remote round trip there is no window to lose a re-subscribe in,
+    // so this collapses to the ordinary local free. The remote view survives
+    // regardless (TTL owns it), which is precisely why the reappearing
+    // subscriber is safe: a re-register finds the row still there.
+    const { remote, finalizeDeregister, run } = makeSync({
+      hasSubscribers: [false, true],
+    });
+
+    await run('h1');
+
+    expect(remote.query).not.toHaveBeenCalled();
+    expect(finalizeDeregister).toHaveBeenCalledWith('h1');
+  });
+
+  it('is tolerant of an already torn-down query', async () => {
+    const { remote, dataModule, run } = makeSync();
+    dataModule.getQueryByHash.mockReturnValue(undefined);
+
+    await expect(run('gone')).resolves.toBeUndefined();
+    expect(remote.query).not.toHaveBeenCalled();
+  });
+});