@spooky-sync/core 0.0.1-canary.160 → 0.0.1-canary.162

package/src/services/database/connection-supervisor.test.ts

@@ -0,0 +1,255 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { ConnectionSupervisor } from './connection-supervisor';
+import type { ReconnectConfig } from '../../types';
+
+// The supervisor covers the two failure modes the SDK's own reconnect cannot:
+//   - it stopped trying (attempts exhausted, or its post-reconnect handshake
+//     threw and it terminated the engine) — nothing else would ever reconnect
+//   - the socket never closed at all (half-open: peer gone, readyState OPEN,
+//     no `close` event, so no reconnect is ever triggered)
+
+const CONFIG: Required<ReconnectConfig> = {
+  attempts: -1,
+  retryDelayMax: 8_000,
+  heartbeatIntervalMs: 1_000,
+  heartbeatTimeoutMs: 500,
+  superviseRetryDelayMaxMs: 4_000,
+};
+
+function makeRemote() {
+  const handlers = new Map<string, Array<(...a: any[]) => void>>();
+  const state = { status: 'connected' as string };
+  const remote: any = {
+    getStatus: () => state.status,
+    getReconnectConfig: () => CONFIG,
+    subscribeConnection: (event: string, cb: (...a: any[]) => void) => {
+      const arr = handlers.get(event) ?? [];
+      arr.push(cb);
+      handlers.set(event, arr);
+      return () => {
+        handlers.set(
+          event,
+          (handlers.get(event) ?? []).filter((h) => h !== cb)
+        );
+      };
+    },
+    connect: vi.fn().mockImplementation(async () => {
+      state.status = 'connected';
+    }),
+    forceClose: vi.fn().mockImplementation(async () => {
+      state.status = 'disconnected';
+      emit('disconnected');
+    }),
+    query: vi.fn().mockResolvedValue([true]),
+  };
+  function emit(event: string, ...args: any[]) {
+    for (const cb of Array.from(handlers.get(event) ?? [])) cb(...args);
+  }
+  return { remote, emit, state, handlerCount: () => handlers.size };
+}
+
+const silentLogger: any = (() => {
+  const l: any = {
+    child: () => l,
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    trace: () => {},
+  };
+  return l;
+})();
+
+function makeSupervisor(remote: any) {
+  return new ConnectionSupervisor(remote, silentLogger, CONFIG);
+}
+
+describe('ConnectionSupervisor', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.clearAllMocks();
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  it('reconnects after the SDK gives up, retrying on backoff until it succeeds', async () => {
+    const { remote, emit, state } = makeRemote();
+    // Two failures, then success — proves the loop keeps going rather than
+    // giving up like the SDK does.
+    remote.connect
+      .mockRejectedValueOnce(new Error('refused'))
+      .mockRejectedValueOnce(new Error('refused'))
+      .mockImplementationOnce(async () => {
+        state.status = 'connected';
+        emit('connected');
+      });
+
+    const sup = makeSupervisor(remote);
+    sup.start();
+
+    state.status = 'disconnected';
+    emit('disconnected');
+    expect(sup.connection).toBe('disconnected');
+
+    // 1s, then 2s, then 4s (capped at superviseRetryDelayMaxMs).
+    await vi.advanceTimersByTimeAsync(1_000);
+    expect(remote.connect).toHaveBeenCalledTimes(1);
+    expect(sup.connection).toBe('reconnecting');
+
+    await vi.advanceTimersByTimeAsync(2_000);
+    expect(remote.connect).toHaveBeenCalledTimes(2);
+
+    await vi.advanceTimersByTimeAsync(4_000);
+    expect(remote.connect).toHaveBeenCalledTimes(3);
+    expect(sup.connection).toBe('connected');
+
+    // Recovered: no further attempts.
+    await vi.advanceTimersByTimeAsync(30_000);
+    expect(remote.connect).toHaveBeenCalledTimes(3);
+
+    sup.dispose();
+  });
+
+  it('does not reconnect while the SDK is still retrying', async () => {
+    const { remote, emit, state } = makeRemote();
+    const sup = makeSupervisor(remote);
+    sup.start();
+
+    state.status = 'reconnecting';
+    emit('reconnecting');
+    expect(sup.connection).toBe('reconnecting');
+
+    await vi.advanceTimersByTimeAsync(30_000);
+    // The SDK owns the socket during its own retry loop; racing it would open
+    // a second connection.
+    expect(remote.connect).not.toHaveBeenCalled();
+
+    sup.dispose();
+  });
+
+  it('forces a teardown when a heartbeat never answers (half-open socket)', async () => {
+    const { remote, emit } = makeRemote();
+    // The defining symptom: the RPC never settles and no `close` ever fires.
+    remote.query.mockImplementation(() => new Promise(() => {}));
+
+    const sup = makeSupervisor(remote);
+    emit('connected');
+    sup.start();
+
+    await vi.advanceTimersByTimeAsync(CONFIG.heartbeatIntervalMs);
+    expect(remote.query).toHaveBeenCalledWith('RETURN true');
+    expect(remote.forceClose).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(CONFIG.heartbeatTimeoutMs);
+    expect(remote.forceClose).toHaveBeenCalledTimes(1);
+
+    // The forced close published `disconnected`, so the revive loop takes over.
+    await vi.advanceTimersByTimeAsync(1_000);
+    expect(remote.connect).toHaveBeenCalled();
+
+    sup.dispose();
+  });
+
+  it('keeps heartbeating while the connection is healthy', async () => {
+    const { remote, emit } = makeRemote();
+    const sup = makeSupervisor(remote);
+    emit('connected');
+    sup.start();
+
+    await vi.advanceTimersByTimeAsync(CONFIG.heartbeatIntervalMs * 3 + 10);
+    expect(remote.query.mock.calls.length).toBeGreaterThanOrEqual(3);
+    expect(remote.forceClose).not.toHaveBeenCalled();
+    expect(sup.connection).toBe('connected');
+
+    sup.dispose();
+  });
+
+  it('parks reconnects while the browser reports offline, and resumes on online', async () => {
+    const listeners = new Map<string, Array<() => void>>();
+    vi.stubGlobal('window', {
+      addEventListener: (e: string, cb: () => void) => {
+        listeners.set(e, [...(listeners.get(e) ?? []), cb]);
+      },
+      removeEventListener: () => {},
+    });
+    const { remote, emit, state } = makeRemote();
+    const sup = makeSupervisor(remote);
+    sup.start();
+
+    state.status = 'disconnected';
+    emit('disconnected');
+    listeners.get('offline')?.forEach((cb) => cb());
+
+    // Retrying a socket against a down interface only burns backoff.
+    await vi.advanceTimersByTimeAsync(30_000);
+    expect(remote.connect).not.toHaveBeenCalled();
+
+    // `online` is the strongest available hint a reconnect will now work, so it
+    // probes immediately rather than waiting out a backoff.
+    listeners.get('online')?.forEach((cb) => cb());
+    await vi.advanceTimersByTimeAsync(0);
+    expect(remote.connect).toHaveBeenCalledTimes(1);
+
+    sup.dispose();
+  });
+
+  it('probes immediately when a hidden tab becomes visible', async () => {
+    const listeners = new Map<string, Array<() => void>>();
+    vi.stubGlobal('document', {
+      visibilityState: 'visible',
+      addEventListener: (e: string, cb: () => void) => {
+        listeners.set(e, [...(listeners.get(e) ?? []), cb]);
+      },
+      removeEventListener: () => {},
+    });
+    const { remote, emit } = makeRemote();
+    const sup = makeSupervisor(remote);
+    emit('connected');
+    sup.start();
+
+    listeners.get('visibilitychange')?.forEach((cb) => cb());
+    await vi.advanceTimersByTimeAsync(0);
+    // Connected-looking socket: probe it rather than reconnect. A sleep/wake
+    // cycle is exactly how you get a socket that looks fine and isn't.
+    expect(remote.query).toHaveBeenCalledWith('RETURN true');
+
+    sup.dispose();
+  });
+
+  it('dispose stops every timer and unsubscribes', async () => {
+    const { remote, emit, state } = makeRemote();
+    const sup = makeSupervisor(remote);
+    emit('connected');
+    sup.start();
+
+    sup.dispose();
+    state.status = 'disconnected';
+    emit('disconnected');
+
+    await vi.advanceTimersByTimeAsync(60_000);
+    expect(remote.connect).not.toHaveBeenCalled();
+    expect(remote.query).not.toHaveBeenCalled();
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it('reports state changes to subscribers', () => {
+    const { remote, emit, state } = makeRemote();
+    const sup = makeSupervisor(remote);
+    sup.start();
+
+    const seen: string[] = [];
+    sup.subscribe((s) => seen.push(s));
+    // Fires immediately with the current value.
+    expect(seen).toEqual(['connected']);
+
+    state.status = 'reconnecting';
+    emit('reconnecting');
+    state.status = 'connected';
+    emit('connected');
+    expect(seen).toEqual(['connected', 'reconnecting', 'connected']);
+
+    sup.dispose();
+  });
+});

package/src/services/database/connection-supervisor.ts

@@ -0,0 +1,351 @@
+import type { ConnectionState, ReconnectConfig } from '../../types';
+import { withTimeout } from '../../utils/index';
+import type { Logger } from '../logger/index';
+import type { RemoteDatabaseService } from './remote';
+
+/**
+ * Keeps the remote WebSocket alive for the whole life of the page.
+ *
+ * The SurrealDB SDK reconnects on its own after a socket `close`, but that
+ * covers only one of three ways the connection dies:
+ *
+ * 1. **Socket closes, SDK recovers.** Handled entirely by the SDK. This
+ *    supervisor only observes it (to report `reconnecting` upward).
+ * 2. **Socket closes, SDK gives up.** With `attempts: -1` this shouldn't happen
+ *    from exhaustion — but the SDK also terminates the engine permanently when
+ *    its post-reconnect handshake throws (it re-runs `version()`, `use()`,
+ *    `authenticate()` on every reconnect and closes the engine on any error).
+ *    One transient hiccup there would otherwise kill the page's connection for
+ *    good. The revive loop re-opens from scratch.
+ * 3. **Socket never closes at all.** A half-open connection: the peer is gone
+ *    (NAT timeout, wifi switch, laptop sleep) but no FIN ever arrives, so
+ *    `readyState` stays OPEN and the SDK's own 30s ping — fire-and-forget, no
+ *    response deadline — never notices. Nothing ever fires a `close` event, so
+ *    nothing ever triggers a reconnect. The heartbeat detects this and forces
+ *    the teardown that case 2's loop then repairs.
+ *
+ * Plus wake triggers: coming back `online` or un-hiding the tab probes
+ * immediately rather than waiting out a backoff that was scheduled while the
+ * network was known-down.
+ */
+export class ConnectionSupervisor {
+  private readonly logger: Logger;
+  private readonly config: Required<ReconnectConfig>;
+
+  private state: ConnectionState = 'disconnected';
+  private subscribers = new Set<(state: ConnectionState) => void>();
+
+  private started = false;
+  private disposed = false;
+
+  private heartbeatTimer: ReturnType<typeof setTimeout> | null = null;
+  private heartbeatInFlight = false;
+
+  private reviveTimer: ReturnType<typeof setTimeout> | null = null;
+  private reviveAttempts = 0;
+  private reviving = false;
+  /**
+   * Set while the browser reports itself offline. Retrying a socket against a
+   * down interface only burns backoff, so the loop parks until `online` fires.
+   */
+  private suspended = false;
+
+  private teardown: Array<() => void> = [];
+
+  private static readonly REVIVE_BASE_MS = 1_000;
+
+  constructor(
+    private readonly remote: RemoteDatabaseService,
+    logger: Logger,
+    config?: Required<ReconnectConfig>
+  ) {
+    this.logger = logger.child({ service: 'ConnectionSupervisor' });
+    this.config = config ?? remote.getReconnectConfig();
+  }
+
+  /** Latest observed transport state. */
+  get connection(): ConnectionState {
+    return this.state;
+  }
+
+  /**
+   * Observe transport state. Fires immediately with the current value and again
+   * on every change. Returns an unsubscribe.
+   */
+  subscribe(cb: (state: ConnectionState) => void): () => void {
+    cb(this.state);
+    this.subscribers.add(cb);
+    return () => {
+      this.subscribers.delete(cb);
+    };
+  }
+
+  /**
+   * Begin supervising. Call once, after the initial {@link
+   * RemoteDatabaseService.connect}. Idempotent.
+   */
+  start(): void {
+    if (this.started || this.disposed) return;
+    this.started = true;
+
+    this.setState(this.remote.getStatus());
+
+    this.teardown.push(
+      this.remote.subscribeConnection('connecting', () => this.setState('connecting')),
+      this.remote.subscribeConnection('reconnecting', () => {
+        this.setState('reconnecting');
+        // The SDK owns the retry from here; ours would fight it for the socket.
+        this.stopHeartbeat();
+      }),
+      this.remote.subscribeConnection('connected', () => {
+        this.reviveAttempts = 0;
+        this.clearReviveTimer();
+        this.setState('connected');
+        this.startHeartbeat();
+      }),
+      this.remote.subscribeConnection('disconnected', () => {
+        this.setState('disconnected');
+        this.stopHeartbeat();
+        // The SDK has stopped trying (exhausted, terminated, or handshake
+        // failure). From here on, reconnecting is entirely our job.
+        this.scheduleRevive();
+      }),
+      this.remote.subscribeConnection('error', (err) => {
+        this.logger.debug(
+          { err, Category: 'sp00ky-client::ConnectionSupervisor::error' },
+          'Transport error'
+        );
+      })
+    );
+
+    this.installWakeTriggers();
+
+    if (this.state === 'connected') this.startHeartbeat();
+    else this.scheduleRevive();
+  }
+
+  /** Stop all timers and listeners. Safe to call more than once. */
+  dispose(): void {
+    this.disposed = true;
+    this.started = false;
+    this.stopHeartbeat();
+    this.clearReviveTimer();
+    for (const off of this.teardown) {
+      try {
+        off();
+      } catch {
+        /* ignore */
+      }
+    }
+    this.teardown = [];
+    this.subscribers.clear();
+  }
+
+  private setState(next: ConnectionState): void {
+    if (this.state === next) return;
+    this.state = next;
+    this.logger.info(
+      { state: next, Category: 'sp00ky-client::ConnectionSupervisor::state' },
+      'Connection state changed'
+    );
+    for (const cb of this.subscribers) {
+      try {
+        cb(next);
+      } catch (err) {
+        this.logger.debug(
+          { err, Category: 'sp00ky-client::ConnectionSupervisor::state' },
+          'Connection subscriber threw'
+        );
+      }
+    }
+  }
+
+  // ---- Revive loop -------------------------------------------------------
+
+  private clearReviveTimer(): void {
+    if (this.reviveTimer !== null) {
+      clearTimeout(this.reviveTimer);
+      this.reviveTimer = null;
+    }
+  }
+
+  /**
+   * Queue the next `connect()` attempt on exponential backoff, capped at
+   * `superviseRetryDelayMaxMs`. Never gives up — the page is expected to
+   * outlive any outage.
+   */
+  private scheduleRevive(): void {
+    if (this.disposed || this.suspended) return;
+    if (this.reviveTimer !== null || this.reviving) return;
+    const delay = Math.min(
+      this.config.superviseRetryDelayMaxMs,
+      ConnectionSupervisor.REVIVE_BASE_MS * 2 ** this.reviveAttempts
+    );
+    this.reviveTimer = setTimeout(() => {
+      this.reviveTimer = null;
+      void this.revive();
+    }, delay);
+  }
+
+  private async revive(): Promise<void> {
+    if (this.disposed || this.suspended || this.reviving) return;
+    // The SDK may have recovered on its own between scheduling and firing.
+    if (this.remote.getStatus() === 'connected') {
+      this.reviveAttempts = 0;
+      return;
+    }
+    this.reviving = true;
+    this.reviveAttempts++;
+    this.setState('reconnecting');
+    this.logger.info(
+      {
+        attempt: this.reviveAttempts,
+        Category: 'sp00ky-client::ConnectionSupervisor::revive',
+      },
+      'Re-opening the remote connection'
+    );
+    try {
+      await this.remote.connect();
+      // Don't reset `reviveAttempts` or start the heartbeat here — the
+      // `connected` handler does both, and it's the only signal that the
+      // handshake (version/use/authenticate) actually completed.
+    } catch (err) {
+      this.logger.warn(
+        {
+          err,
+          attempt: this.reviveAttempts,
+          Category: 'sp00ky-client::ConnectionSupervisor::revive',
+        },
+        'Reconnect attempt failed; will retry'
+      );
+    } finally {
+      this.reviving = false;
+    }
+    if (this.remote.getStatus() !== 'connected') this.scheduleRevive();
+  }
+
+  // ---- Heartbeat watchdog ------------------------------------------------
+
+  private stopHeartbeat(): void {
+    if (this.heartbeatTimer !== null) {
+      clearTimeout(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+
+  private startHeartbeat(): void {
+    this.stopHeartbeat();
+    if (this.disposed || this.suspended) return;
+    if (!(this.config.heartbeatIntervalMs > 0)) return;
+    this.heartbeatTimer = setTimeout(
+      () => void this.beat(),
+      this.config.heartbeatIntervalMs
+    );
+  }
+
+  /**
+   * Probe the server end-to-end. Deliberately goes through
+   * `remote.query` — the same serialized queue every other remote call uses —
+   * so a queue wedged behind a stuck RPC also fails the heartbeat instead of
+   * being invisible to it.
+   */
+  private async beat(): Promise<void> {
+    this.heartbeatTimer = null;
+    if (this.disposed || this.suspended) return;
+    if (this.remote.getStatus() !== 'connected') return;
+    if (this.heartbeatInFlight) {
+      this.startHeartbeat();
+      return;
+    }
+    this.heartbeatInFlight = true;
+    try {
+      await withTimeout(
+        this.remote.query('RETURN true'),
+        this.config.heartbeatTimeoutMs,
+        `Heartbeat timed out after ${this.config.heartbeatTimeoutMs}ms`
+      );
+      this.startHeartbeat();
+    } catch (err) {
+      this.logger.warn(
+        { err, Category: 'sp00ky-client::ConnectionSupervisor::heartbeat' },
+        'Heartbeat failed; tearing the socket down to force a reconnect'
+      );
+      // Force the `close` the transport never delivered. The resulting
+      // `disconnected` event drives the revive loop.
+      await this.remote.forceClose();
+      if (this.remote.getStatus() !== 'connected') this.scheduleRevive();
+    } finally {
+      this.heartbeatInFlight = false;
+    }
+  }
+
+  // ---- Wake triggers -----------------------------------------------------
+
+  /**
+   * A restored network or an un-hidden tab is the strongest available hint that
+   * a reconnect will now succeed, so probe immediately instead of waiting out a
+   * backoff scheduled under worse conditions.
+   */
+  private installWakeTriggers(): void {
+    if (typeof window !== 'undefined' && typeof window.addEventListener === 'function') {
+      const onOnline = () => {
+        this.suspended = false;
+        this.wake('online');
+      };
+      const onOffline = () => {
+        this.logger.info(
+          { Category: 'sp00ky-client::ConnectionSupervisor::offline' },
+          'Browser reports offline; parking reconnects until online'
+        );
+        this.suspended = true;
+        this.stopHeartbeat();
+        this.clearReviveTimer();
+        this.setState('disconnected');
+      };
+      window.addEventListener('online', onOnline);
+      window.addEventListener('offline', onOffline);
+      this.teardown.push(
+        () => window.removeEventListener('online', onOnline),
+        () => window.removeEventListener('offline', onOffline)
+      );
+      // A tab restored from bfcache keeps its dead socket; `pageshow` is the
+      // only event that fires in that path.
+      const onPageShow = () => this.wake('pageshow');
+      window.addEventListener('pageshow', onPageShow);
+      this.teardown.push(() => window.removeEventListener('pageshow', onPageShow));
+    }
+
+    if (typeof document !== 'undefined' && typeof document.addEventListener === 'function') {
+      const onVisibility = () => {
+        if (document.visibilityState !== 'visible') return;
+        this.wake('visibilitychange');
+      };
+      document.addEventListener('visibilitychange', onVisibility);
+      this.teardown.push(() => document.removeEventListener('visibilitychange', onVisibility));
+    }
+  }
+
+  /**
+   * Reset the backoff and act on whichever problem is present: reconnect if the
+   * socket is gone, otherwise probe it (it may be half-open — which is exactly
+   * what a sleep/wake cycle produces).
+   */
+  private wake(reason: string): void {
+    if (this.disposed || this.suspended) return;
+    this.logger.debug(
+      { reason, state: this.state, Category: 'sp00ky-client::ConnectionSupervisor::wake' },
+      'Wake trigger; probing the connection'
+    );
+    this.reviveAttempts = 0;
+    if (this.remote.getStatus() === 'connected') {
+      this.stopHeartbeat();
+      void this.beat();
+      return;
+    }
+    // 'reconnecting' means the SDK's own loop owns the socket; don't race it.
+    if (this.remote.getStatus() === 'disconnected') {
+      this.clearReviveTimer();
+      void this.revive();
+    }
+  }
+}

package/src/services/database/database.query-timeout.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { AbstractDatabaseService } from './database';
+import { DatabaseEventTypes, createDatabaseEventSystem } from './events/index';
+import { classifySyncError } from '../../utils/index';
+
+// Every remote query is serialized through one promise chain (to keep the WASM
+// engine's transactions safe), so a call that never settles doesn't just fail —
+// it blocks every later query behind it, including the sync poll's own health
+// probe. That's how a half-open socket wedges the client while health still
+// reports `healthy`: nothing ever throws, so nothing ever degrades.
+
+const silentLogger: any = (() => {
+  const l: any = {
+    child: () => l,
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    trace: () => {},
+  };
+  return l;
+})();
+
+class TestService extends AbstractDatabaseService {
+  protected eventType = DatabaseEventTypes.RemoteQuery;
+  constructor(client: any, timeoutMs: number) {
+    super(client, silentLogger, createDatabaseEventSystem());
+    this.queryTimeoutMs = timeoutMs;
+  }
+  async connect(): Promise<void> {}
+}
+
+describe('AbstractDatabaseService query timeout', () => {
+  beforeEach(() => vi.useFakeTimers());
+  afterEach(() => vi.useRealTimers());
+
+  it('rejects a never-settling query and classifies it as a network failure', async () => {
+    const client = { query: vi.fn().mockImplementation(() => new Promise(() => {})) };
+    const svc = new TestService(client, 1_000);
+
+    const pending = svc.query('SELECT * FROM thread');
+    const assertion = expect(pending).rejects.toThrow(/timed out/);
+    await vi.advanceTimersByTimeAsync(1_000);
+    await assertion;
+
+    // "timed out" in the message is load-bearing: it routes the failure to
+    // `network`, which makes the sync queues retry instead of rolling the
+    // mutation back as a permanent application error.
+    const err = await pending.catch((e) => e);
+    expect(classifySyncError(err)).toBe('network');
+  });
+
+  it('unblocks the serialized queue so later queries still run', async () => {
+    let calls = 0;
+    const client = {
+      query: vi.fn().mockImplementation(() => {
+        calls++;
+        // First call hangs forever; the second would never be reached at all if
+        // the timeout didn't settle the chain link.
+        if (calls === 1) return new Promise(() => {});
+        return Promise.resolve([['ok']]);
+      }),
+    };
+    const svc = new TestService(client, 1_000);
+
+    const stuck = svc.query('SELECT 1');
+    const next = svc.query('SELECT 2');
+    const stuckAssertion = expect(stuck).rejects.toThrow(/timed out/);
+
+    await vi.advanceTimersByTimeAsync(1_000);
+    await stuckAssertion;
+    await expect(next).resolves.toEqual([['ok']]);
+  });
+
+  it('leaves queries unbounded when the timeout is disabled', async () => {
+    const client = { query: vi.fn().mockResolvedValue([['ok']]) };
+    const svc = new TestService(client, 0);
+
+    await expect(svc.query('SELECT 1')).resolves.toEqual([['ok']]);
+    // No timer was armed, so a slow-but-alive query is never cut off.
+    expect(vi.getTimerCount()).toBe(0);
+  });
+});