@syncular/client 0.15.44 → 0.15.46

package/README.md

@@ -3,9 +3,20 @@
 The TypeScript client protocol core (SPEC.md §§3–8, client side) plus its
 browser platform bindings.
 
+The normal `SyncClient` also runs in a CLI or background service.
+Use `openBunDatabase(path)` or `openNodeDatabase(path)` for a persistent local
+replica. See the [server-side sync client guide](https://syncular.dev/guide-server-clients/).
+
+`SyncRemoteClient` is the database-less server client. It sends ordinary
+push-only commits through `/sync` and can call registered typed queries,
+server-authoritative commands, and live query watches through the remote
+operation transport. See [remote server operations](https://syncular.dev/guide-remote-operations/).
+Its schema and sync transport are optional for query-only or command-only
+processes.
+
 ## Client-local FTS5 projections
 
-Generated schemas may attach `ftsIndexes` to a synced table (RFC 0005). The
+Generated schemas may attach `ftsIndexes` to a synced table. The
 client materializes each as a contentful local FTS5 table with a private stable
 source identity and insert/update/delete triggers. Existing visible rows are
 bulk-indexed on first creation; schema reset recreates the projection. The FTS
@@ -16,8 +27,7 @@ strings.
 
 ## Browser modes — there are exactly two
 
-**Persistent worker mode is THE mode** (REVISE Direction decision 2,
-2026-07-03). The whole client core — `SyncClient`, the fetch/WebSocket
+**Persistent worker mode is THE mode.** The whole client core — `SyncClient`, the fetch/WebSocket
 transports, and SQLite on the `opfs-sahpool` VFS — runs inside a Web
 Worker. The UI thread talks to it through a thin postMessage RPC:
 
@@ -34,7 +44,7 @@ import { createSyncClientHandle } from '@syncular/client';
 const handle = await createSyncClientHandle({
   worker: () => new Worker(new URL('./worker.ts', import.meta.url), { type: 'module' }),
   schema,
-  database: { mode: 'persistent', name: 'app' }, // OPFS, survives reloads
+  database: { mode: 'persistent', name: 'app' }, // OPFS, survives reloads while the origin remains stored
   endpoints: {
     syncUrl: '/sync',
     segmentsUrl: '/segments',
@@ -58,6 +68,25 @@ SPEC §8.4); the supported page-level realtime supervisor owns reconnect and
 resume policy. The main thread gets `onSyncNeeded` / `onConflict` / `onSynced`
 events for rendering.
 
+OPFS is best effort until the browser grants origin persistence. The page owns
+that decision because `StorageManager.persist()` is a Window API and should be
+requested from a user action:
+
+```ts
+import {
+  checkBrowserStoragePersistence,
+  requestBrowserStoragePersistence,
+} from '@syncular/client';
+
+const current = await checkBrowserStoragePersistence();
+const requested = await requestBrowserStoragePersistence(); // user action
+```
+
+Each call returns `persistent` or a structured `best-effort` reason. Keep the
+client usable after denial, display the state, and warn whenever best-effort
+storage contains pending outbox commits. Origin eviction removes OPFS and its
+outbox together; persistence does not prevent a user from clearing site data.
+
 **Ephemeral in-memory mode is EXPLICIT.** `openWasmDatabase()` returns an
 in-memory sqlite-wasm database for tests, demos and SSR. Nothing
 persists, on purpose, and that is the only main-thread mode.
@@ -103,7 +132,7 @@ HTTP rounds still work with no socket, but do not imply continuous convergence:
 a host trigger must actually run them. See the complete
 [realtime lifecycle guide](https://syncular.dev/concepts-realtime/).
 
-## Multi-tab followers (TODO 3.2, REVISE B3)
+## Multi-tab followers
 
 By default, every tab of the same origin shares ONE core:
 one sync loop, one WebSocket, one OPFS database, N tabs.
@@ -393,6 +422,9 @@ successful history may be dismissed. See SPEC §7.2.1.
   `FileSystemSyncAccessHandle`, unlike the Atomics-based `opfs` VFS).
 - Browsers without OPFS (~pre-2023) are **unsupported**:
   `openPersistentWasmDatabase` fails loud instead of degrading.
+- OPFS is reload-persistent but begins as best-effort origin storage. The root
+  package exports `checkBrowserStoragePersistence()` and
+  `requestBrowserStoragePersistence()` for the page-level persistence policy.
 - **Never IndexedDB.** There is no wa-sqlite/absurd-sql style fallback
   and none is planned.
 - `openPersistentWasmDatabase` refuses to run on the main thread — not a

package/dist/browser-storage-persistence.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Browser storage durability for the origin that owns Syncular's OPFS
+ * database. Persistence is requested by the page because `persist()` is a
+ * Window-only API and browsers may evaluate the request against user
+ * engagement.
+ */
+export type BrowserStoragePersistence = {
+    readonly state: 'persistent';
+} | {
+    readonly state: 'best-effort';
+    readonly reason: 'not-granted' | 'unavailable' | 'check-failed' | 'request-failed';
+};
+/** Check whether the current origin is protected from automatic eviction. */
+export declare function checkBrowserStoragePersistence(): Promise<BrowserStoragePersistence>;
+/**
+ * Request eviction-resistant storage for the current origin. Call this from a
+ * user action near the first important offline write. A best-effort result is
+ * an explicit durability state; the OPFS database remains usable.
+ */
+export declare function requestBrowserStoragePersistence(): Promise<BrowserStoragePersistence>;

package/dist/browser-storage-persistence.js

@@ -0,0 +1,34 @@
+/** Check whether the current origin is protected from automatic eviction. */
+export async function checkBrowserStoragePersistence() {
+    const storage = typeof navigator === 'undefined' ? undefined : navigator.storage;
+    if (storage === undefined || typeof storage.persisted !== 'function') {
+        return { state: 'best-effort', reason: 'unavailable' };
+    }
+    try {
+        return (await storage.persisted())
+            ? { state: 'persistent' }
+            : { state: 'best-effort', reason: 'not-granted' };
+    }
+    catch {
+        return { state: 'best-effort', reason: 'check-failed' };
+    }
+}
+/**
+ * Request eviction-resistant storage for the current origin. Call this from a
+ * user action near the first important offline write. A best-effort result is
+ * an explicit durability state; the OPFS database remains usable.
+ */
+export async function requestBrowserStoragePersistence() {
+    const storage = typeof navigator === 'undefined' ? undefined : navigator.storage;
+    if (storage === undefined || typeof storage.persist !== 'function') {
+        return { state: 'best-effort', reason: 'unavailable' };
+    }
+    try {
+        return (await storage.persist())
+            ? { state: 'persistent' }
+            : { state: 'best-effort', reason: 'not-granted' };
+    }
+    catch {
+        return { state: 'best-effort', reason: 'request-failed' };
+    }
+}

package/dist/bun-database.d.ts

@@ -1,5 +1,5 @@
 /**
- * `ClientDatabase` on bun:sqlite — the test backend (REVISE B3: the core
+ * `ClientDatabase` on bun:sqlite is the test backend. The core
  * must run without a browser). Not exported from the package root so the
  * browser entry never touches `bun:sqlite`.
  */

package/dist/bun-database.js

@@ -1,5 +1,5 @@
 /**
- * `ClientDatabase` on bun:sqlite — the test backend (REVISE B3: the core
+ * `ClientDatabase` on bun:sqlite is the test backend. The core
  * must run without a browser). Not exported from the package root so the
  * browser entry never touches `bun:sqlite`.
  */

package/dist/client.d.ts

@@ -1,8 +1,8 @@
 /**
- * SyncClient — the B3 client protocol core (SPEC.md §§3–8 client side).
+ * SyncClient implements the client side of SPEC.md §§3–8.
  *
  * A plain library running on whatever thread it is constructed on
- * (worker-OPTIONAL, REVISE B3): storage behind `ClientDatabase`, network
+ * Storage is behind `ClientDatabase`, network
  * behind `SyncTransport`/`SegmentDownloader`/`RealtimeConnector`, multi-tab
  * ownership behind `LeaderLock`. One combined push+pull request per
  * `sync()` round (§7.2); local reads go straight to the database.
@@ -252,7 +252,7 @@ export declare class SyncClient {
      */
     activateSecurity(options?: SecurityActivation): Promise<void>;
     get clientId(): string;
-    /** The underlying database — raw SQL is the local query API (B3). */
+    /** The underlying database: raw SQL is the local query API. */
     get database(): ClientDatabase;
     /**
      * The raw-SQL read tier. Guarded (query-guard.ts): a single read-only

package/dist/client.js

@@ -1,8 +1,8 @@
 /**
- * SyncClient — the B3 client protocol core (SPEC.md §§3–8 client side).
+ * SyncClient implements the client side of SPEC.md §§3–8.
  *
  * A plain library running on whatever thread it is constructed on
- * (worker-OPTIONAL, REVISE B3): storage behind `ClientDatabase`, network
+ * Storage is behind `ClientDatabase`, network
  * behind `SyncTransport`/`SegmentDownloader`/`RealtimeConnector`, multi-tab
  * ownership behind `LeaderLock`. One combined push+pull request per
  * `sync()` round (§7.2); local reads go straight to the database.
@@ -236,7 +236,7 @@ export class SyncClient {
             this.#config.onSyncNeeded?.('startup');
             this.#config.onSyncIntent?.({ kind: 'interactive' });
         }
-        // RFC 0002 §3.2: console introspection — a no-op outside a dev page.
+        // Console introspection is a no-op outside a dev page.
         this.#devtoolsUnregister = registerDevtools({
             kind: 'client',
             ref: this,
@@ -391,7 +391,7 @@ export class SyncClient {
     get clientId() {
         return this.#clientId;
     }
-    /** The underlying database — raw SQL is the local query API (B3). */
+    /** The underlying database: raw SQL is the local query API. */
     get database() {
         this.#requireActive();
         return this.#db;
@@ -460,7 +460,7 @@ export class SyncClient {
             };
         });
     }
-    // -- live-query invalidation (TODO 3.1 / DESIGN-eviction I1–I4) -----------
+    // -- live-query invalidation ----------------------------------------------
     /**
      * Subscribe to fine-grained invalidation. The callback fires ONCE per
      * apply batch (never per row, I1) with the `{tables, scopeKeys}` touched
@@ -1920,7 +1920,7 @@ export class SyncClient {
     }
     /**
      * One request/response round trip (§8.7): over the socket whenever it
-     * is connected (Direction decision 1 — the socket IS the sync-round
+     * is connected (the socket IS the sync-round
      * transport, not a fallback pair), otherwise through the configured
      * `SyncTransport` seam (loopback/conformance hosts, HTTP-only
      * producers).

package/dist/database.d.ts

@@ -1,5 +1,5 @@
 /**
- * Storage abstraction (REVISE B3): the client core runs on any SQLite that
+ * Storage abstraction: the client core runs on any SQLite that
  * implements this minimal synchronous surface. Tests use bun:sqlite
  * (`./bun-database`); browsers use sqlite-wasm + OPFS (`./wasm-database`).
  * Methods are synchronous because both backends execute synchronously once

package/dist/devtools.d.ts

@@ -1,5 +1,5 @@
 /**
- * The client-side introspection registry (RFC 0002 §3.2): every live
+ * The client-side introspection registry: every live
  * `SyncClient` / `SyncClientHandle` on a page registers itself on
  * `globalThis.__SYNCULAR__`, so a first integration debugs from the console
  * instead of hand-exposing the client:

package/dist/http.d.ts

@@ -2,16 +2,20 @@
  * Browser transport bindings (§1.1, §5.4/§5.5, §8.1): fetch-based sync
  * transport, segment download with signed-URL preference and direct-serve
  * fallback, and a WebSocket realtime connector. Core tests never use these
- * (the loopback doctrine); B6 exercises them in a real browser.
+ * (the loopback doctrine); the browser fixture exercises them in a real browser.
  */
 import type { BlobTransport } from './blob.js';
-import type { RealtimeConnector, SegmentDownloader, SyncTransport } from './transport.js';
+import type { RealtimeConnector, RemoteOperationTransport, RemoteOperationRealtimeConnector, SegmentDownloader, SyncTransport } from './transport.js';
 export interface HttpTransportOptions {
     readonly headers?: Readonly<Record<string, string>>;
     readonly fetch?: typeof fetch;
 }
 /** POST `<mount>/sync` with SSP2 bodies (§1.1). */
 export declare function httpSyncTransport(syncUrl: string, options?: HttpTransportOptions): SyncTransport;
+/** POST one registered authoritative operation to `<mount>/operations`. */
+export declare function httpRemoteOperationTransport(operationsUrl: string, options?: HttpTransportOptions): RemoteOperationTransport;
+/** WebSocket connector for registered query snapshots. */
+export declare function webSocketRemoteOperationConnector(realtimeUrl: string): RemoteOperationRealtimeConnector;
 /**
  * §5.5 direct endpoint with the `X-Syncular-Scopes` re-authorization
  * header, plus the §5.4 `fetchUrl` capability (advertises accept bit 3).

package/dist/http.js

@@ -35,6 +35,60 @@ export function httpSyncTransport(syncUrl, options) {
         return new Uint8Array(await response.arrayBuffer());
     };
 }
+/** POST one registered authoritative operation to `<mount>/operations`. */
+export function httpRemoteOperationTransport(operationsUrl, options) {
+    const doFetch = options?.fetch ?? fetch;
+    return async (request) => {
+        const response = await doFetch(operationsUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/vnd.syncular.operations.v1+json',
+                ...options?.headers,
+            },
+            body: request.slice().buffer,
+        });
+        if (!response.ok)
+            await throwHttpError(response);
+        return new Uint8Array(await response.arrayBuffer());
+    };
+}
+/** WebSocket connector for registered query snapshots. */
+export function webSocketRemoteOperationConnector(realtimeUrl) {
+    return (handlers) => new Promise((resolve, reject) => {
+        const socket = new WebSocket(realtimeUrl);
+        let opened = false;
+        socket.binaryType = 'arraybuffer';
+        socket.onopen = () => {
+            opened = true;
+            resolve({
+                send: (bytes) => socket.send(bytes.slice().buffer),
+                close: () => socket.close(),
+            });
+        };
+        socket.onmessage = (event) => {
+            if (event.data instanceof ArrayBuffer) {
+                handlers.onMessage(new Uint8Array(event.data));
+            }
+        };
+        socket.onerror = () => {
+            if (!opened) {
+                reject(new ClientSyncError('sync.transport_failed', 'remote operation realtime socket failed to connect', true));
+            }
+            try {
+                socket.close();
+            }
+            catch {
+                handlers.onClose?.();
+            }
+        };
+        socket.onclose = () => {
+            if (!opened) {
+                reject(new ClientSyncError('sync.transport_failed', 'remote operation realtime socket closed while connecting', true));
+            }
+            handlers.onClose?.();
+        };
+    });
+}
 /**
  * §5.5 direct endpoint with the `X-Syncular-Scopes` re-authorization
  * header, plus the §5.4 `fetchUrl` capability (advertises accept bit 3).
@@ -170,8 +224,10 @@ export function httpBlobTransport(blobsBaseUrl, options) {
 export function webSocketRealtimeConnector(realtimeUrl) {
     return (handlers) => new Promise((resolve, reject) => {
         const socket = new WebSocket(realtimeUrl);
+        let opened = false;
         socket.binaryType = 'arraybuffer';
         socket.onopen = () => {
+            opened = true;
             resolve({
                 send: (text) => socket.send(text),
                 sendBytes: (bytes) => {
@@ -187,9 +243,20 @@ export function webSocketRealtimeConnector(realtimeUrl) {
                 handlers.onBinary(new Uint8Array(event.data));
         };
         socket.onerror = () => {
-            reject(new ClientSyncError('sync.transport_failed', 'realtime socket failed to connect', true));
+            if (!opened) {
+                reject(new ClientSyncError('sync.transport_failed', 'realtime socket failed to connect', true));
+            }
+            try {
+                socket.close();
+            }
+            catch {
+                handlers.onClose?.();
+            }
         };
         socket.onclose = () => {
+            if (!opened) {
+                reject(new ClientSyncError('sync.transport_failed', 'realtime socket closed while connecting', true));
+            }
             handlers.onClose?.();
         };
     });

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 /**
- * @syncular/client — the B3 TypeScript client protocol core
- * (SPEC.md is normative; REVISE.md B3 is the architectural mandate).
+ * @syncular/client is the TypeScript client protocol core.
+ * SPEC.md is normative.
  *
  * Browser-safe root: database backends live behind subpath exports
  * (`./bun` for bun:sqlite tests, `./wasm` for sqlite-wasm + OPFS); the
@@ -11,6 +11,7 @@
 export * from './apply.js';
 export * from './availability.js';
 export * from './blob.js';
+export * from './browser-storage-persistence.js';
 export * from './client.js';
 export * from './content-type.js';
 export * from './database.js';
@@ -29,6 +30,7 @@ export * from './outbox.js';
 export * from './outcomes.js';
 export * from './query-guard.js';
 export * from './reactive-store.js';
+export * from './remote.js';
 export * from './realtime-supervisor.js';
 export * from './schema.js';
 export * from './sql-tag.js';

package/dist/index.js

@@ -1,6 +1,6 @@
 /**
- * @syncular/client — the B3 TypeScript client protocol core
- * (SPEC.md is normative; REVISE.md B3 is the architectural mandate).
+ * @syncular/client is the TypeScript client protocol core.
+ * SPEC.md is normative.
  *
  * Browser-safe root: database backends live behind subpath exports
  * (`./bun` for bun:sqlite tests, `./wasm` for sqlite-wasm + OPFS); the
@@ -11,6 +11,7 @@
 export * from './apply.js';
 export * from './availability.js';
 export * from './blob.js';
+export * from './browser-storage-persistence.js';
 export * from './client.js';
 export * from './content-type.js';
 export * from './database.js';
@@ -29,6 +30,7 @@ export * from './outbox.js';
 export * from './outcomes.js';
 export * from './query-guard.js';
 export * from './reactive-store.js';
+export * from './remote.js';
 export * from './realtime-supervisor.js';
 export * from './schema.js';
 export * from './sql-tag.js';

package/dist/invalidation.d.ts

@@ -1,5 +1,5 @@
 /**
- * Revisioned client-local observation events (SPEC §7.5 / RFC 0003).
+ * Revisioned client-local observation events (SPEC §7.5).
  *
  * The core records observer domains while it owns the SQLite transaction,
  * increments the persisted local revision in that same transaction, and emits

package/dist/leader-lock.d.ts

@@ -1,5 +1,5 @@
 /**
- * Multi-tab ownership seam (REVISE B3): exactly one core instance owns the
+ * Multi-tab ownership seam: exactly one core instance owns the
  * local database. The interface is the whole B3 deliverable — cross-tab
  * follower fanout is post-gate. Browsers use Web Locks; tests use the
  * no-op single-owner lock.
@@ -14,7 +14,7 @@ export interface LeaderLock {
      * Resolves immediately: the lease when leadership was free, `undefined`
      * when another owner holds it. The worker handle uses this so a second
      * tab gets a clear not-leader state instead of blocking forever
-     * (followers are post-gate, TODO 3.2).
+     * (followers are post-gate).
      */
     tryAcquire?(name: string): Promise<LeaderLease | undefined>;
 }

package/dist/multi-tab.js

@@ -1,5 +1,5 @@
 /**
- * Multi-tab followers (TODO 3.2, REVISE B3): one core per origin, N tabs.
+ * Multi-tab followers: one core per origin, N tabs.
  *
  * The leader tab holds the Web Locks lease and runs the worker core (the
  * existing worker-host path, unchanged). Every OTHER tab is a FOLLOWER: it

package/dist/naming.d.ts

@@ -1,5 +1,5 @@
 /**
- * The pinned snake→camel naming map (DESIGN-queries.md §5, §12) — the
+ * The pinned snake→camel naming map. The
  * client-side copy of the typegen algorithm (kept in lockstep by shared
  * test vectors; the Rust core carries the same function). Used by `mutate`
  * to accept BOTH casings for value keys: the canonical camelCase the

package/dist/naming.js

@@ -1,5 +1,5 @@
 /**
- * The pinned snake→camel naming map (DESIGN-queries.md §5, §12) — the
+ * The pinned snake→camel naming map. The
  * client-side copy of the typegen algorithm (kept in lockstep by shared
  * test vectors; the Rust core carries the same function). Used by `mutate`
  * to accept BOTH casings for value keys: the canonical camelCase the

package/dist/node-database.js

@@ -1,6 +1,6 @@
 /**
  * `ClientDatabase` on better-sqlite3 — the Electron-main / plain-Node
- * backend (TODO 2: Node ClientDatabase). Semantics mirror `./bun-database`
+ * backend. Semantics mirror `./bun-database`
  * exactly (synchronous exec/query/transaction with the shared savepoint
  * helper, and the same §5.3 sqlite-image ATTACH path), so the core behaves
  * identically whether it runs on bun:sqlite (tests), sqlite-wasm (browser)

package/dist/query-guard.d.ts

@@ -1,5 +1,5 @@
 /**
- * The raw-query guard (DESIGN-queries.md I3). `client.query()` / the React
+ * The raw-query guard. `client.query()` and the React
  * `useRawSql` hook are the untrusted raw-SQL tier: an app hands us a SQL
  * string and we run it against the local database. Two rules make that safe
  * to expose, enforced HERE in the core (previously they lived in the

package/dist/query-guard.js

@@ -1,5 +1,5 @@
 /**
- * The raw-query guard (DESIGN-queries.md I3). `client.query()` / the React
+ * The raw-query guard. `client.query()` and the React
  * `useRawSql` hook are the untrusted raw-SQL tier: an app hands us a SQL
  * string and we run it against the local database. Two rules make that safe
  * to expose, enforced HERE in the core (previously they lived in the

package/dist/remote.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Database-less SSP2 producer (§6.10). It prepares and sends ordinary commits
+ * through the existing push path without creating a local replica or outbox.
+ */
+import { type PushOperationResult, type PushResultFrame } from '@syncular/core';
+import type { MutationInput } from './client.js';
+import type { EncryptionConfig } from './encryption.js';
+import { ClientSyncError } from './errors.js';
+import { type ClientSchema } from './schema.js';
+import type { SyncTransport } from './transport.js';
+import type { RemoteOperationRealtimeConnector, RemoteOperationTransport } from './transport.js';
+export interface SyncRemoteClientConfig {
+    /** Required only for ordinary row commits. */
+    readonly schema?: ClientSchema;
+    readonly clientId: string;
+    /** Required only for ordinary row commits. */
+    readonly transport?: SyncTransport;
+    readonly operations?: RemoteOperationTransport;
+    readonly operationRealtime?: RemoteOperationRealtimeConnector;
+    readonly encryption?: EncryptionConfig;
+}
+export interface RemoteCommitInput {
+    /** Stable caller-owned idempotency identity for this logical commit. */
+    readonly requestId: string;
+    readonly mutations: readonly MutationInput[];
+}
+/**
+ * Prepared bytes are the retry unit. Persist them when a process must retry
+ * across restart, especially when encryption uses randomized nonces.
+ */
+export interface PreparedRemoteCommit {
+    readonly requestId: string;
+    readonly bytes: Uint8Array;
+}
+export interface RemoteCommitResult {
+    readonly requestId: string;
+    readonly status: PushResultFrame['status'];
+    readonly commitSeq?: number;
+    readonly results: readonly PushOperationResult[];
+}
+export interface RemoteQueryDescriptor<Row, Params = undefined> {
+    readonly id: string;
+    readonly mapRow: (row: Readonly<Record<string, unknown>>) => Row;
+    readonly __row?: Row;
+    readonly __params?: Params;
+}
+export interface RemoteQueryResult<Row> {
+    readonly rows: readonly Row[];
+    readonly maxCommitSeq: number;
+}
+export interface RemoteQueryWatchHandlers<Row> {
+    onSnapshot(result: RemoteQueryResult<Row>): void;
+    onError?(error: ClientSyncError): void;
+}
+export interface RemoteCommandDescriptor<Input = undefined> {
+    readonly id: string;
+    readonly __input?: Input;
+}
+export declare function remoteCommand<Input = undefined>(id: string): RemoteCommandDescriptor<Input>;
+export interface RemoteCommandResult {
+    readonly requestId: string;
+    readonly status: 'applied' | 'cached' | 'rejected';
+    readonly commitSeq?: number;
+    readonly results: readonly unknown[];
+}
+export declare class SyncRemoteClient {
+    #private;
+    constructor(config: SyncRemoteClientConfig);
+    prepareCommit(input: RemoteCommitInput): Promise<PreparedRemoteCommit>;
+    sendCommit(prepared: PreparedRemoteCommit): Promise<RemoteCommitResult>;
+    commit(input: RemoteCommitInput): Promise<RemoteCommitResult>;
+    query<Row, Params = undefined>(descriptor: RemoteQueryDescriptor<Row, Params>, params?: Params): Promise<RemoteQueryResult<Row>>;
+    command<Input = undefined>(descriptor: RemoteCommandDescriptor<Input>, requestId: string, input?: Input): Promise<RemoteCommandResult>;
+    watch<Row, Params = undefined>(descriptor: RemoteQueryDescriptor<Row, Params>, params: Params, handlers: RemoteQueryWatchHandlers<Row>): Promise<() => void>;
+    close(): void;
+}