@syncular/react 0.2.0

package/README.md

@@ -0,0 +1,182 @@
+# @syncular/react
+
+React bindings for the syncular v2 client, with **fine-grained live
+queries** designed in from day one (TODO 3.1 / `DESIGN-eviction.md` I1–I4).
+A `useSyncQuery` re-runs **only** when a table it depends on is touched by an
+apply batch — never "re-run everything on any change".
+
+Works against **both** client cores through one interface:
+
+- `SyncClient` — the direct core (constructed on the current thread), and
+- `SyncClientHandle` — the worker-mode proxy (the whole core in an OPFS
+  worker).
+
+Their public surfaces diverge (getters vs methods, sync vs promise); the
+bindings normalize both, so a component never cares which it holds.
+
+React 18+ is a **peer dependency**. There are no other runtime dependencies.
+
+## Quick start
+
+```tsx
+import { SyncProvider, useSyncQuery, useMutation } from '@syncular/react';
+
+// `client` is a SyncClient or a SyncClientHandle you already started.
+function App({ client }) {
+  return (
+    <SyncProvider client={client}>
+      <Tasks />
+    </SyncProvider>
+  );
+}
+
+function Tasks() {
+  const { rows, isLoading, error, refresh } = useSyncQuery(
+    'SELECT id, title, done FROM tasks ORDER BY id',
+  );
+  const { mutate } = useMutation();
+
+  if (isLoading) return <p>Loading…</p>;
+  if (error) return <p>Query failed: {error.message}</p>;
+
+  return (
+    <ul>
+      {rows.map((r) => (
+        <li key={r.id}>{r.title}</li>
+      ))}
+      <button
+        onClick={() =>
+          mutate([
+            {
+              table: 'tasks',
+              op: 'upsert',
+              values: { id: crypto.randomUUID(), project_id: 'p1', title: 'new', done: false },
+            },
+          ])
+        }
+      >
+        Add
+      </button>
+    </ul>
+  );
+}
+```
+
+The mutate applies optimistically (§7.1) and fires the invalidation batch, so
+the list updates immediately — no manual refetch.
+
+## The invalidation granularity truth
+
+This is the honest granularity the wire actually provides — read it before
+relying on scope-key narrowing.
+
+The web-client emits **exactly one** `{ tables, scopeKeys }` invalidation event
+per apply batch (a pull/delta round, a local `mutate`, a purge, or a
+schema-bump reset — the ONE choke point). Never one event per row.
+
+- **`tables`** — the set of tables whose local rows changed this batch. This
+  is the **reliable floor**: it is always present and always correct.
+- **`scopeKeys`** — `prefix:value` scope keys (§3.1), present **where the
+  source carried them**:
+  - `COMMIT` frames carry per-row stored scopes (§4.5), so commit-driven
+    invalidation carries **precise** scope keys.
+  - **Segments carry no per-row scope keys** — only a table + a scope digest.
+    A segment (bootstrap / re-bootstrap) invalidation therefore carries the
+    table plus the **subscription's effective scope keys**, the coarsest
+    honest key for bulk data. It never fabricates per-row keys the wire did
+    not deliver.
+  - Purge / reset / optimistic writes are keyed by table (and by effective
+    scope keys where a scope map is in hand).
+
+**Consequence for `useSyncQuery`:** by default a query re-runs whenever a
+depended-on **table** is touched. You may narrow further with `scopeKeys`
+(below), but a **table-level** event (a segment bootstrap, a reset — one that
+carries no scope keys) **always** re-runs a matching query, because it carries
+no key to discriminate on. This is deliberate: under-running is a stale query,
+the one thing a live-query layer must never do.
+
+## `useSyncQuery(sql, params?, options?)`
+
+Runs a local SQL query and keeps it live.
+
+Returns `{ rows, isLoading, error, refresh }`.
+
+### Dependency tables — inference and the escape hatch
+
+By default the hook infers its dependency tables with a **conservative scan**
+of the SQL text (the identifiers after `FROM`/`JOIN`). This is a heuristic,
+**not** a SQL parser — it is intentionally over-inclusive at the edges (an
+extra harmless re-run) rather than under-inclusive (a stale query).
+
+When the text cannot be read (dynamic SQL, views, unusual syntax), pass the
+explicit **`tables`** option — it always wins:
+
+```tsx
+useSyncQuery(buildDynamicSql(), params, { tables: ['tasks', 'projects'] });
+```
+
+### Options
+
+| Option      | Meaning                                                                                                                             |
+| ----------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| `tables`    | Explicit dependency tables. Overrides the SQL-text inference (the escape hatch).                                                    |
+| `scopeKeys` | Narrow re-runs to specific `prefix:value` keys. A dependency-table event still re-runs if it carries **no** scope keys (see above). |
+| `enabled`   | Skip running while `false` (e.g. inputs not ready).                                                                                 |
+
+## `useTypedQuery(build, deps?, options?)` — the typed twin
+
+Behind the `@syncular/react/typed` subpath (needs the `@syncular/kysely`
++ `kysely` peers). You write a [Kysely](https://kysely.dev) builder typed by
+your generated `Database` interface; the hook compiles it, runs it live, and
+extracts the `{tables}` dependency set from the compiled query's **AST** — so
+invalidation is *exact*, never a text heuristic. It reuses `useSyncQuery`'s
+machinery verbatim.
+
+```tsx
+import { useTypedQuery } from '@syncular/react/typed';
+import type { Database, TodosRow } from './syncular.generated';
+
+function TodoList({ listId }: { listId: string }) {
+  const { rows } = useTypedQuery<Database, Pick<TodosRow, 'id' | 'title'>>(
+    (db) =>
+      db.selectFrom('todos').select(['id', 'title']).where('list_id', '=', listId),
+    [listId], // re-key the builder like a useEffect dep array
+  );
+  return <ul>{rows.map((r) => <li key={r.id}>{r.title}</li>)}</ul>;
+}
+```
+
+Read-only, like the dialect: a write builder throws — use `useMutation` for
+writes (they must go through the outbox, SPEC §7.1). Works on every host the
+other hooks do (direct, worker, follower, Tauri, RN) — it drives the same
+normalized `query` surface.
+
+## Other hooks
+
+- **`useSyncStatus()`** → `{ outbox, upgrading, leaseState, schemaFloor,
+  syncNeeded, isLoading, refresh }`. Re-reads after every apply batch.
+  (`online` is not a value the core exposes — §1.3 transport-owned — so it is
+  not reported rather than guessed.)
+- **`useConflicts()`** → `{ conflicts, rejections, refresh }` (§6.2/§6.3).
+- **`usePresence(scopeKey)`** → the ephemeral peers present on a §8.6 scope
+  key; updates on join/update/leave. Empty (and never crashes) without a
+  connected realtime socket.
+- **`useMutation()`** → `{ mutate, isPending, error }`. `mutate(mutations)`
+  resolves to the `clientCommitId`; the optimistic overlay is applied
+  immediately, and dependent `useSyncQuery`s re-run on the resulting batch.
+
+## SSR
+
+The hooks are SSR-safe: on the server they render their initial state and the
+query fires only in the client-side mount effect. `renderToString` never
+crashes.
+
+## Design note — the window registry (forward-looking)
+
+Per `DESIGN-eviction.md` I3, query bindings must be able to route a query's
+scope footprint through the window registry once windowed sync (TODO §5
+item 2) lands, so a query can report **completeness** (answerable from the
+local replica vs a window miss). Today the registry trivially contains
+"everything subscribed", so `useSyncQuery` always answers from the local
+replica. The `scopeKeys` option is the seam through which per-scope
+completeness will be surfaced without an API break.

package/dist/client.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The ONE client interface the React bindings target. Both the direct
+ * `SyncClient` (constructed on the current thread) and the worker-mode
+ * `SyncClientHandle` (a promise proxy over the OPFS worker) satisfy it —
+ * their public surfaces diverge (getters vs methods, sync vs promise), so
+ * this module normalizes both into a single async-friendly facade the hooks
+ * consume. That is the "one interface across direct and worker-handle modes"
+ * the invalidation seam (TODO 3.1) was standardized to enable.
+ *
+ * The normalizer resolves each accessor at call time (function → call it,
+ * value → read it) and wraps every result in `Promise.resolve`, so a hook
+ * never has to care which core it holds.
+ */
+import type { ConflictRecord, InvalidationListener, LeaseState, MutationInput, PresencePeer, RejectionRecord, SchemaFloor, SqlRow, SqlValue, WindowBase, WindowState } from '@syncular/client';
+/**
+ * The structural union of `SyncClient` and `SyncClientHandle`. Members that
+ * diverge are typed as "value or method, sync or promise"; {@link normalizeClient}
+ * collapses the divergence. Only what the hooks use is listed — the bindings
+ * never reach past this surface.
+ */
+export interface SyncClientLike {
+    onInvalidate(listener: InvalidationListener): () => void;
+    onPresence(listener: (scopeKey: string) => void): () => void;
+    query(sql: string, params?: readonly SqlValue[]): SqlRow[] | Promise<SqlRow[]>;
+    mutate(mutations: readonly MutationInput[]): string | Promise<string>;
+    conflicts: readonly ConflictRecord[] | (() => readonly ConflictRecord[] | Promise<readonly ConflictRecord[]>);
+    rejections: readonly RejectionRecord[] | (() => readonly RejectionRecord[] | Promise<readonly RejectionRecord[]>);
+    schemaFloor: SchemaFloor | undefined | (() => SchemaFloor | undefined | Promise<SchemaFloor | undefined>);
+    leaseState: LeaseState | undefined | (() => LeaseState | undefined | Promise<LeaseState | undefined>);
+    upgrading: boolean | (() => boolean | Promise<boolean>);
+    syncNeeded: boolean | (() => boolean | Promise<boolean>);
+    pendingCommits: () => unknown[] | Promise<unknown[]>;
+    presence(scopeKey: string): readonly PresencePeer[] | Promise<readonly PresencePeer[]>;
+    setPresence(scopeKey: string, doc: Record<string, unknown> | null): void | Promise<void>;
+    /** §4.8 windowed subscriptions: set the live units for a window base. */
+    setWindow(base: WindowBase, units: readonly string[]): void | Promise<void>;
+    /** §4.8 completeness oracle (I3): the windowed-in units for a base. */
+    windowState(base: WindowBase): WindowState | Promise<WindowState>;
+}
+/** The uniform async facade the hooks actually call. */
+export interface NormalizedClient {
+    onInvalidate(listener: InvalidationListener): () => void;
+    onPresence(listener: (scopeKey: string) => void): () => void;
+    query(sql: string, params?: readonly SqlValue[]): Promise<SqlRow[]>;
+    mutate(mutations: readonly MutationInput[]): Promise<string>;
+    conflicts(): Promise<readonly ConflictRecord[]>;
+    rejections(): Promise<readonly RejectionRecord[]>;
+    schemaFloor(): Promise<SchemaFloor | undefined>;
+    leaseState(): Promise<LeaseState | undefined>;
+    upgrading(): Promise<boolean>;
+    syncNeeded(): Promise<boolean>;
+    pendingCommits(): Promise<unknown[]>;
+    presence(scopeKey: string): Promise<readonly PresencePeer[]>;
+    setPresence(scopeKey: string, doc: Record<string, unknown> | null): Promise<void>;
+    setWindow(base: WindowBase, units: readonly string[]): Promise<void>;
+    windowState(base: WindowBase): Promise<WindowState>;
+}
+export declare function normalizeClient(client: SyncClientLike): NormalizedClient;

package/dist/client.js

@@ -0,0 +1,31 @@
+/**
+ * Read a member by key that is EITHER a value getter (SyncClient) or a
+ * method returning a value/promise (SyncClientHandle). Read from the client
+ * so a method keeps its `this` binding; if the read is a function, call it.
+ */
+function resolveMember(client, key) {
+    const member = client[key];
+    const value = typeof member === 'function'
+        ? member.call(client)
+        : member;
+    return Promise.resolve(value);
+}
+export function normalizeClient(client) {
+    return {
+        onInvalidate: (listener) => client.onInvalidate(listener),
+        onPresence: (listener) => client.onPresence(listener),
+        query: (sql, params) => Promise.resolve(client.query(sql, params)),
+        mutate: (mutations) => Promise.resolve(client.mutate(mutations)),
+        conflicts: () => resolveMember(client, 'conflicts'),
+        rejections: () => resolveMember(client, 'rejections'),
+        schemaFloor: () => resolveMember(client, 'schemaFloor'),
+        leaseState: () => resolveMember(client, 'leaseState'),
+        upgrading: () => resolveMember(client, 'upgrading'),
+        syncNeeded: () => resolveMember(client, 'syncNeeded'),
+        pendingCommits: () => resolveMember(client, 'pendingCommits'),
+        presence: (scopeKey) => Promise.resolve(client.presence(scopeKey)),
+        setPresence: (scopeKey, doc) => Promise.resolve(client.setPresence(scopeKey, doc)),
+        setWindow: (base, units) => Promise.resolve(client.setWindow(base, units)),
+        windowState: (base) => Promise.resolve(client.windowState(base)),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @syncular/react — React bindings with fine-grained live queries
+ * (TODO 3.1 / DESIGN-eviction I1–I4). Works against BOTH `SyncClient`
+ * (direct) and `SyncClientHandle` (worker) through one normalized client
+ * interface. React 18+ (react is a peer dependency); no other runtime deps.
+ *
+ * See README.md for the invalidation granularity truth and the `tables`
+ * option.
+ */
+export type { NormalizedClient, SyncClientLike, } from './client.js';
+export { normalizeClient } from './client.js';
+export { inferTables } from './infer-tables.js';
+export { SyncContext, SyncProvider, type SyncProviderProps } from './provider.js';
+export { useSyncClient } from './use-client.js';
+export { type UseConflictsResult, useConflicts } from './use-conflicts.js';
+export { type UseMutationResult, useMutation } from './use-mutation.js';
+export { type NamedQueryDescriptor, useNamedQuery, } from './use-named-query.js';
+export { usePresence } from './use-presence.js';
+export { type UseSyncQueryOptions, type UseSyncQueryResult, useSyncQuery, } from './use-sync-query.js';
+export { type SyncStatus, useSyncStatus } from './use-sync-status.js';
+export { type UseWindowResult, useWindow } from './use-window.js';

package/dist/index.js

@@ -0,0 +1,18 @@
+// `normalizeClient` is the runtime facade the hooks consume; exported so
+// alternate hosts (e.g. `@syncular/tauri`) can assert shape-parity against
+// the exact normalizer the bindings use.
+export { normalizeClient } from './client.js';
+export { inferTables } from './infer-tables.js';
+export { SyncContext, SyncProvider } from './provider.js';
+export { useSyncClient } from './use-client.js';
+export { useConflicts } from './use-conflicts.js';
+export { useMutation } from './use-mutation.js';
+export { useNamedQuery, } from './use-named-query.js';
+export { usePresence } from './use-presence.js';
+export { useSyncQuery, } from './use-sync-query.js';
+export { useSyncStatus } from './use-sync-status.js';
+export { useWindow } from './use-window.js';
+// NOTE: `useTypedQuery` is intentionally NOT re-exported here — it needs the
+// `@syncular/kysely` + `kysely` peers. It lives behind the `./typed`
+// subpath so apps using only `useSyncQuery` never pull Kysely into their
+// bundle. Import it as `@syncular/react/typed`.

package/dist/infer-tables.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Conservative table inference for `useSyncQuery` (TODO 3.1: "infer
+ * conservatively from the SQL text's table names … documented as a
+ * heuristic with the explicit option as the escape hatch").
+ *
+ * This is a SIMPLE identifier scan, NOT a SQL parser. It collects the
+ * identifiers that follow `FROM` and `JOIN` — the tables a SELECT reads.
+ * It is deliberately over-inclusive at the edges (a table aliased in a CTE,
+ * a function-table, an odd quoting style) because the failure mode of
+ * over-inclusion is a harmless extra re-run, whereas under-inclusion is a
+ * stale query — the one thing live queries must never do. When a query's
+ * real dependencies cannot be read off its text (dynamic SQL, views,
+ * unusual syntax), pass the explicit `tables` option; that always wins.
+ */
+/**
+ * Extract the table names a SELECT reads. Returns a de-duplicated,
+ * lower-nothing set (identifiers are compared to invalidation table names
+ * as-is — SQLite table names are case-sensitive for our generated schema).
+ */
+export declare function inferTables(sql: string): Set<string>;

package/dist/infer-tables.js

@@ -0,0 +1,33 @@
+/**
+ * Conservative table inference for `useSyncQuery` (TODO 3.1: "infer
+ * conservatively from the SQL text's table names … documented as a
+ * heuristic with the explicit option as the escape hatch").
+ *
+ * This is a SIMPLE identifier scan, NOT a SQL parser. It collects the
+ * identifiers that follow `FROM` and `JOIN` — the tables a SELECT reads.
+ * It is deliberately over-inclusive at the edges (a table aliased in a CTE,
+ * a function-table, an odd quoting style) because the failure mode of
+ * over-inclusion is a harmless extra re-run, whereas under-inclusion is a
+ * stale query — the one thing live queries must never do. When a query's
+ * real dependencies cannot be read off its text (dynamic SQL, views,
+ * unusual syntax), pass the explicit `tables` option; that always wins.
+ */
+const FROM_JOIN_RE = /\b(?:from|join)\s+(?:"([^"]+)"|`([^`]+)`|\[([^\]]+)\]|([a-zA-Z_][a-zA-Z0-9_$]*))/gi;
+/**
+ * Extract the table names a SELECT reads. Returns a de-duplicated,
+ * lower-nothing set (identifiers are compared to invalidation table names
+ * as-is — SQLite table names are case-sensitive for our generated schema).
+ */
+export function inferTables(sql) {
+    const tables = new Set();
+    // Strip a leading schema qualifier (`main.tasks` → `tasks`) so the name
+    // matches the invalidation event's bare table name.
+    for (const match of sql.matchAll(FROM_JOIN_RE)) {
+        const raw = match[1] ?? match[2] ?? match[3] ?? match[4];
+        if (raw === undefined)
+            continue;
+        const dot = raw.lastIndexOf('.');
+        tables.add(dot === -1 ? raw : raw.slice(dot + 1));
+    }
+    return tables;
+}

package/dist/provider.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `SyncProvider` — supplies a `SyncClient` or `SyncClientHandle` to the
+ * hook tree through React context. One provider per client; the hooks read
+ * the normalized facade. Written with `createElement` (no JSX) so the whole
+ * package typechecks under the repo's `.ts`-only root tsconfig with no jsx
+ * setting — the bindings are plain function components either way.
+ */
+import { type ReactNode } from 'react';
+import { type NormalizedClient, type SyncClientLike } from './client.js';
+export declare const SyncContext: import("react").Context<NormalizedClient | undefined>;
+export interface SyncProviderProps {
+    /** A `SyncClient` (direct) or `SyncClientHandle` (worker) — both satisfy it. */
+    readonly client: SyncClientLike;
+    readonly children?: ReactNode;
+}
+export declare function SyncProvider(props: SyncProviderProps): ReactNode;

package/dist/provider.js

@@ -0,0 +1,15 @@
+/**
+ * `SyncProvider` — supplies a `SyncClient` or `SyncClientHandle` to the
+ * hook tree through React context. One provider per client; the hooks read
+ * the normalized facade. Written with `createElement` (no JSX) so the whole
+ * package typechecks under the repo's `.ts`-only root tsconfig with no jsx
+ * setting — the bindings are plain function components either way.
+ */
+import { createContext, createElement, useMemo } from 'react';
+import { normalizeClient, } from './client.js';
+export const SyncContext = createContext(undefined);
+export function SyncProvider(props) {
+    // Re-normalize only when the client identity changes.
+    const normalized = useMemo(() => normalizeClient(props.client), [props.client]);
+    return createElement(SyncContext.Provider, { value: normalized }, props.children);
+}

package/dist/query-churn.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Live-query churn hardening — the three cheap levers the query hooks share
+ * (block 4 "live-query churn" item). Under constant sync churn a naive live
+ * query re-renders and re-queries once per invalidation event; these levers
+ * cap both without reaching for IVM:
+ *
+ * 1. {@link reconcileRows} — result stability. After a re-run, compare the new
+ *    result to the previous one. Whole-result equal → the caller skips
+ *    `setRows` entirely (zero re-render). Otherwise build the new array but
+ *    REUSE the previous row object for every row whose content is unchanged,
+ *    so `React.memo`'d row components keyed by row identity skip re-render.
+ * 2. {@link FrameScheduler} — frame-coalesced re-query scheduling. Many
+ *    invalidation events between paints collapse to ONE re-run per query.
+ * 3. scope-key filtering lives in {@link ../use-sync-query} `eventMatches`
+ *    (it needs the event + the hook's options), documented there.
+ *
+ * Row identity mechanism (the honest key): the hook knows no primary key —
+ * rows are plain JSON-able objects out of SQLite — so per-row content equality
+ * IS the identity. We hash each row once with a stable JSON serialization
+ * (sorted keys, so column order can't spuriously differ) and match by index:
+ * a live query's ORDER BY makes index the stable position, and an unchanged
+ * row at position i keeps its object so memoized components skip. This is O(n)
+ * in the row count with one string hash per row — bounded and measured (~0.2ms
+ * for 1k narrow rows in bun; see query-churn.test.ts).
+ */
+/**
+ * A stable content hash for one row: JSON with keys sorted, so two rows with
+ * the same columns in a different order hash equal (SQLite projection order is
+ * stable per query, but sorting removes any dependence on it and is cheap for
+ * the narrow rows a row-component renders). Uint8Array values (rare in a
+ * projection) serialize by byte view so a fresh copy of equal bytes hashes
+ * equal rather than to `{}`.
+ */
+export declare function hashRow(row: unknown): string;
+/** The precomputed hash carrier for the previous result, so we hash once. */
+export interface HashedRows<Row> {
+    readonly rows: readonly Row[];
+    readonly hashes: readonly string[];
+}
+export declare function hashRows<Row>(rows: readonly Row[]): HashedRows<Row>;
+export interface ReconcileResult<Row> {
+    /**
+     * `undefined` → the whole result is unchanged; the caller MUST NOT call
+     * setRows (zero re-render, lever 1a). Otherwise the reconciled array to set,
+     * with previous row objects reused wherever a row's content was unchanged
+     * (lever 1b).
+     */
+    readonly next: HashedRows<Row> | undefined;
+}
+/**
+ * Reconcile a freshly-queried result against the previous hashed result.
+ * Returns `next: undefined` when nothing changed at all; otherwise a new
+ * hashed result whose row objects are the PREVIOUS objects wherever content is
+ * unchanged (matched by index), so identity-keyed memo components skip.
+ */
+export declare function reconcileRows<Row>(prev: HashedRows<Row> | undefined, fresh: readonly Row[]): ReconcileResult<Row>;
+/**
+ * A per-query re-run scheduler that coalesces bursts of invalidation events
+ * into ONE run per paint. Multiple `schedule()` calls before the next flush
+ * run the callback once. A `schedule()` that arrives WHILE the callback is
+ * running (re-entrant, or an event during an async re-query) marks dirty and
+ * runs the callback exactly once more after — never lost, never concurrent.
+ *
+ * Timing source: `requestAnimationFrame` when the host has it (a real browser
+ * paints one frame; the coalescing window is a frame), else a microtask via a
+ * resolved promise (bun tests have no rAF — this keeps them deterministic and
+ * timer-free, honoring the no-timers doctrine: it's a readiness turn, not a
+ * wall-clock sleep). {@link flush} runs any pending callback synchronously for
+ * tests, so no arbitrary sleeps are needed to observe coalescing.
+ */
+export declare class FrameScheduler {
+    #private;
+    constructor(callback: () => void | Promise<void>);
+    /** Request a run. Coalesces until the next frame/microtask boundary. */
+    schedule(): void;
+    /**
+     * Synchronously run any pending scheduled callback NOW (test determinism).
+     * Returns whatever the callback returned (a Promise for the async host path)
+     * so a test can await the re-query settling without a sleep. A no-op when
+     * nothing is pending.
+     */
+    flush(): void | Promise<void>;
+    /** Drop the callback so a torn-down hook's pending frame is a no-op. */
+    dispose(): void;
+}
+/**
+ * TEST-ONLY: synchronously flush every live scheduler's pending frame, so a
+ * test can observe the coalesced re-query without a wall-clock sleep (the
+ * no-timers doctrine — a readiness flush, injected, not a timer). Returns a
+ * Promise that settles when every flushed async re-query has settled.
+ */
+export declare function flushQuerySchedulers(): Promise<void>;