@spooky-sync/core 0.0.1-canary.240 → 0.0.1-canary.241

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

@@ -1,237 +0,0 @@
-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,286 +0,0 @@
-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,
-    private downQueue: DownQueue,
-    private onProcessUp: (event: UpEvent) => Promise<void>,
-    private onProcessDown: (event: DownEvent) => Promise<void>,
-    private logger: Logger,
-    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(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,
-      this.syncDown.bind(this)
-    );
-  }
-
-  /**
-   * Add mutations to the upload queue
-   */
-  enqueueMutation(mutations: UpEvent[]) {
-    for (const mutation of mutations) {
-      this.upQueue.push(mutation);
-    }
-  }
-
-  /**
-   * Add query events to the download queue
-   */
-  enqueueDownEvent(event: DownEvent) {
-    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 || this.paused) return;
-    this.isSyncingUp = true;
-    let processedAny = false;
-    try {
-      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();
-    }
-  }
-
-  /**
-   * Process download queue
-   */
-  async syncDown() {
-    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 {
-      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();
-    }
-  }
-
-  get isSyncing() {
-    return this.isSyncingUp || this.isSyncingDown;
-  }
-}

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

@@ -1,116 +0,0 @@
-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();
-  });
-});