cry-synced-db-client 0.1.179 → 0.1.181

package/CHANGELOG.md

@@ -1,5 +1,125 @@
 # Versions
 
+## 0.1.181 (2026-05-14)
+
+### `measureEndToEndRtt` now rides `callWorker` over the WebSocket
+
+The old HTTP echo path was a workaround for the missing WS
+request/response correlation in ebus-proxy 1.x. Now that
+`callWorker` (0.1.180) provides it, `measureEndToEndRtt` becomes a
+5-line wrapper:
+
+```ts
+async measureEndToEndRtt(timeoutMs = 5000): Promise<number> {
+  const sentAt = Date.now();
+  const t0 = performance.now();
+  const echoed = await this.callWorker<number>("echo", sentAt, { timeoutMs });
+  if (echoed !== sentAt) throw payload-mismatch error;
+  return performance.now() - t0;
+}
+```
+
+Dropped HTTP-specific code: base URL derivation (`ws://`→`http://`),
+base64 encoding (Buffer + btoa fallback), URL query-string assembly,
+`AbortSignal.timeout` shim, `fetch` + `arrayBuffer` + `unpack` pipeline,
+HTTP status error branch. Bundle: 356.9 KB → 356.0 KB.
+
+**Semantic shift**: now measures the WebSocket round-trip rather than
+the HTTP round-trip. For this codebase that's more representative —
+real notifications arrive on the WS, not via HTTP. The old HTTP path
+was characterizing a transport the app barely uses (sync uploads go to
+cry-db directly, not through ebus-proxy).
+
+Public signature is unchanged; existing callers keep working. The
+diagnostic interpretation table in CLAUDE.md still applies — the
+labels just refer to the WS chain instead of the HTTP chain.
+
+Tests: 736 bun + 18 vitest, all green.
+
+## 0.1.180 (2026-05-14)
+
+### `SyncedDb.callWorker` — invoke ebus2 worker services over the WS
+
+New API for calling any registered cry-ebus2 worker directly from the
+client, riding the same WebSocket connection the notifier already uses
+for pub/sub. Built on ebus-proxy 2.0's WS `request` / `response`
+correlation frames, so there's no extra TCP/TLS handshake and no HTTP
+overhead — the worker reply arrives on the open socket.
+
+```typescript
+// echo round-trip (any msgpack-serializable value)
+const echoed = await syncedDb.callWorker<string>("echo", "hello");
+
+// pass an object payload, type the reply
+const result = await syncedDb.callWorker<{ ok: boolean; jobId: string }>(
+  "billing",
+  { customerId, amount: 1990 },
+);
+
+// per-call timeout (default 5000 ms) + caller AbortSignal
+const ctrl = new AbortController();
+setTimeout(() => ctrl.abort(), 200);
+const fast = await syncedDb.callWorker("priority-queue", null, {
+  timeoutMs: 200,
+  signal: ctrl.signal,
+});
+```
+
+API contract:
+
+| Argument | Type | Notes |
+|---|---|---|
+| `service` | `string` | Worker service name registered on the broker. |
+| `payload` | `unknown?` | Anything `msgpack+structuredClone` can serialize. BSON `ObjectId` / `Timestamp` preprocessed automatically. Omit (or pass `undefined`) to call without a payload. |
+| `options.timeoutMs` | `number?` | Per-call timeout; also forwarded to the proxy. Default `5000`. |
+| `options.signal` | `AbortSignal?` | External cancellation. |
+| Returns | `Promise<T>` | Worker's reply, typed as caller-asserted `T`. |
+
+Error semantics:
+
+- WebSocket not OPEN → synchronous reject (no implicit reconnect).
+- Worker error / proxy error → rejects with the proxy's error message.
+- Per-call `timeoutMs` elapses → rejects with timeout error and frees
+  the pending entry (the proxy may still complete the call server-side;
+  client-side state is freed regardless).
+- WebSocket closes mid-flight → all in-flight calls reject with
+  "WebSocket closed before reply".
+- Caller's `signal` aborts → rejects with "aborted"; pending entry is
+  freed and the abort listener is removed.
+
+Multiple concurrent calls are safe — each request uses a unique
+correlation id and the response/error dispatch keys off it. The
+existing pub/sub channel and keepalive ping/pong are unaffected.
+
+Implementation:
+
+- `I_ServerUpdateNotifier.callWorker?` — optional interface method, so
+  REST-only / polling notifier alternatives can omit it.
+- `Ebus2ProxyServerUpdateNotifier.callWorker` — sends `{type:"request",
+  service, payload, timeout, id}` and registers the resolver in a
+  `_pendingRequests` Map keyed by id (same pattern as `_pendingRttPings`
+  for `measureWsRtt`).
+- `handleMessage` adds `case "response"` to dispatch replies and routes
+  correlated `case "error"` to the matching pending promise instead of
+  module-level `console.error`.
+- `handleClose` rejects every in-flight call with a clear "WebSocket
+  closed before reply" message — the socket they were sent over is
+  gone; the client can't observe replies on a different connection.
+- `dispose` is a defensive backstop (`handleClose` normally drains
+  first) and rejects any stragglers with "notifier disposed".
+- AbortSignal listeners are cleaned up on every exit path (resolve,
+  reject, timeout, dispose) so callers don't leak listeners.
+
+Peer-dep bump: `cry-ebus-proxy` now `^2.0.0` (needed for
+`WsRequestMessage` / `WsResponseMessage` types and the proxy-side
+request/response handling).
+
+Tests: 8 new mock-based cases in `test/callWorker.test.ts` covering
+delegation, generic return, payload+options forwarding, undefined
+payload preservation, error propagation, missing-notifier guard,
+concurrent independence. 736 bun + 18 vitest pass (was 728 + 18 — 8 new
+bun cases).
+
 ## 0.1.179 (2026-05-13)
 
 ### Non-error `console.*` calls now pass numbers as separate arguments

package/dist/index.js

@@ -4682,6 +4682,24 @@ var _SyncedDb = class _SyncedDb {
     }
     return fn.call(this.serverUpdateNotifier, timeoutMs);
   }
+  /**
+   * Call an arbitrary worker service via the configured server-update
+   * notifier (typically over its WebSocket). Delegates to
+   * `serverUpdateNotifier.callWorker`. Throws if no notifier is
+   * configured or the notifier doesn't support worker invocation.
+   *
+   * @see I_ServerUpdateNotifier.callWorker
+   */
+  async callWorker(service, payload, options) {
+    var _a;
+    const fn = (_a = this.serverUpdateNotifier) == null ? void 0 : _a.callWorker;
+    if (!fn) {
+      throw new Error(
+        "[SyncedDb] callWorker: no serverUpdateNotifier or notifier does not support callWorker"
+      );
+    }
+    return fn.call(this.serverUpdateNotifier, service, payload, options);
+  }
   /**
    * Register a collection for sync at runtime. See `I_SyncedDb.addCollectionToSync`.
    */
@@ -9713,6 +9731,13 @@ var Ebus2ProxyServerUpdateNotifier = class {
      * after if any are still pending).
      */
     this._pendingRttPings = /* @__PURE__ */ new Map();
+    /**
+     * Pending `callWorker` promises keyed by request id. The matching
+     * `response` (or correlated `error`) frame resolves/rejects them.
+     * Cleared on disconnect — pending callers are rejected with a
+     * "WebSocket closed" error and the per-call timeout is freed.
+     */
+    this._pendingRequests = /* @__PURE__ */ new Map();
     var _a, _b, _c, _d, _e;
     this.endpoint = config.wsUrl;
     this.wsUrl = config.wsUrl;
@@ -9769,6 +9794,18 @@ var Ebus2ProxyServerUpdateNotifier = class {
     this.onWsDisconnectCallbacks.length = 0;
     this.onWsReconnectCallbacks.length = 0;
     this._pendingRttPings.clear();
+    for (const [, pending] of this._pendingRequests) {
+      clearTimeout(pending.timer);
+      if (pending.abortListener && pending.signal) {
+        pending.signal.removeEventListener("abort", pending.abortListener);
+      }
+      pending.reject(
+        new Error(
+          `[Ebus2ProxyNotifier] callWorker(${pending.service}): notifier disposed`
+        )
+      );
+    }
+    this._pendingRequests.clear();
   }
   isConnected() {
     return this.connected && !this.forcedOffline;
@@ -9808,41 +9845,22 @@ var Ebus2ProxyServerUpdateNotifier = class {
   }
   /**
    * End-to-end RTT (client → proxy → broker → echo worker → broker →
-   * proxy → client). Sends an HTTP request to ebus-proxy's `echo`
-   * service with `Date.now()` as the msgpack payload; the worker
-   * returns the payload unchanged, and we verify byte-equality before
-   * reporting RTT.
+   * proxy → client). Invokes the `echo` worker via `callWorker` with
+   * `Date.now()` as the payload; the worker returns it unchanged and
+   * we verify byte-equality before reporting RTT.
    *
-   * The HTTP base URL is derived from `wsUrl` (`ws://` → `http://`,
-   * `wss://` → `https://`). Throws on HTTP error, payload mismatch,
-   * or timeout.
+   * Rides the existing WebSocket — same transport real notifications
+   * arrive on, so this is the more representative diagnostic of actual
+   * app-traffic latency. Throws on payload mismatch, timeout, or any
+   * `callWorker` failure path (WS not OPEN, proxy error, etc).
    *
-   * @param timeoutMs Max wait for HTTP response (default: 5000)
+   * @param timeoutMs Max wait for echo reply (default: 5000)
    * @returns RTT in milliseconds (full round-trip)
    */
   async measureEndToEndRtt(timeoutMs = 5e3) {
-    const httpBase = this.wsUrl.replace(/^ws:\/\//, "http://").replace(/^wss:\/\//, "https://").replace(/\/+$/, "");
     const sentAt = Date.now();
-    const packed = packr2.pack(sentAt);
-    let payloadB64;
-    const bufCtor = globalThis.Buffer;
-    if (bufCtor) {
-      payloadB64 = bufCtor.from(packed).toString("base64");
-    } else {
-      let bin = "";
-      for (let i = 0; i < packed.length; i++) bin += String.fromCharCode(packed[i]);
-      payloadB64 = btoa(bin);
-    }
-    const keyParam = this.ebusProxyApiKey ? `&apikey=${encodeURIComponent(this.ebusProxyApiKey)}` : "";
-    const url = `${httpBase}/?service=echo&payload=${encodeURIComponent(payloadB64)}${keyParam}&timeout=${timeoutMs}`;
     const t0 = performance.now();
-    const signal = typeof AbortSignal !== "undefined" && AbortSignal.timeout ? AbortSignal.timeout(timeoutMs) : void 0;
-    const res = await fetch(url, signal ? { signal } : void 0);
-    if (!res.ok) {
-      throw new Error(`[Ebus2ProxyNotifier] measureEndToEndRtt: HTTP ${res.status}`);
-    }
-    const buf = new Uint8Array(await res.arrayBuffer());
-    const echoed = unpackr2.unpack(buf);
+    const echoed = await this.callWorker("echo", sentAt, { timeoutMs });
     if (echoed !== sentAt) {
       throw new Error(
         `[Ebus2ProxyNotifier] measureEndToEndRtt: payload mismatch (sent ${sentAt}, got ${JSON.stringify(echoed)})`
@@ -9850,6 +9868,111 @@ var Ebus2ProxyServerUpdateNotifier = class {
     }
     return performance.now() - t0;
   }
+  /**
+   * Call an arbitrary ebus2 worker service over the existing
+   * WebSocket and return its msgpack-decoded reply.
+   *
+   * Uses the WS `request` / `response` correlation introduced in
+   * ebus-proxy 2.0 — the whole frame is msgpack, so the payload is
+   * sent as a raw value (no base64, no JSON envelope). Lower latency
+   * than HTTP (no TCP/TLS handshake, no per-call connection setup)
+   * and reuses the same auth + connection that the pub/sub channel
+   * is already using.
+   *
+   * Errors:
+   * - WebSocket not OPEN → throws synchronously (rejects).
+   * - Worker error / proxy error → rejects with the proxy's `error`
+   *   frame message.
+   * - Per-call `timeoutMs` elapses → rejects with timeout error and
+   *   removes the pending entry. The proxy may still process the
+   *   call server-side; client-side state is freed regardless.
+   * - WebSocket closes mid-flight → rejects with "WebSocket closed
+   *   before reply".
+   * - Caller `options.signal` aborts → rejects with "aborted".
+   *
+   * Multiple concurrent calls are safe — each request uses a unique
+   * correlation id and the `response`/`error` dispatch keys off it.
+   *
+   * @param service Worker service name registered on cry-ebus2.
+   * @param payload Anything msgpack+structuredClone can serialize.
+   *   BSON ObjectId/Timestamp are preprocessed like all other WS
+   *   frames. Pass `undefined` to call without a payload.
+   * @param options.timeoutMs Per-call timeout (default 5000). Also
+   *   forwarded as the proxy-side `timeout` field.
+   * @param options.signal External AbortSignal for cancellation.
+   * @returns Worker's reply, msgpack-decoded as T.
+   */
+  async callWorker(service, payload, options) {
+    var _a;
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error(
+        `[Ebus2ProxyNotifier] callWorker(${service}): WebSocket not OPEN`
+      );
+    }
+    const timeoutMs = (_a = options == null ? void 0 : options.timeoutMs) != null ? _a : 5e3;
+    const id = `req-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    return new Promise((resolve, reject) => {
+      var _a2;
+      if ((_a2 = options == null ? void 0 : options.signal) == null ? void 0 : _a2.aborted) {
+        reject(new Error(`[Ebus2ProxyNotifier] callWorker(${service}): aborted`));
+        return;
+      }
+      const timer = setTimeout(() => {
+        const pending = this._pendingRequests.get(id);
+        if (!pending) return;
+        this._pendingRequests.delete(id);
+        if (pending.abortListener && pending.signal) {
+          pending.signal.removeEventListener("abort", pending.abortListener);
+        }
+        reject(
+          new Error(
+            `[Ebus2ProxyNotifier] callWorker(${service}): timeout after ${timeoutMs}ms`
+          )
+        );
+      }, timeoutMs);
+      const abortListener = (options == null ? void 0 : options.signal) ? () => {
+        const pending = this._pendingRequests.get(id);
+        if (!pending) return;
+        clearTimeout(pending.timer);
+        this._pendingRequests.delete(id);
+        reject(
+          new Error(`[Ebus2ProxyNotifier] callWorker(${service}): aborted`)
+        );
+      } : void 0;
+      if (abortListener && options.signal) {
+        options.signal.addEventListener("abort", abortListener, { once: true });
+      }
+      this._pendingRequests.set(id, {
+        resolve,
+        reject,
+        timer,
+        service,
+        abortListener,
+        signal: options == null ? void 0 : options.signal
+      });
+      const req = {
+        type: "request",
+        service,
+        payload: payload !== void 0 ? preprocessForPack2(payload) : void 0,
+        timeout: timeoutMs,
+        id
+      };
+      try {
+        this.ws.send(packr2.pack(req));
+      } catch (err) {
+        clearTimeout(timer);
+        this._pendingRequests.delete(id);
+        if (abortListener && options.signal) {
+          options.signal.removeEventListener("abort", abortListener);
+        }
+        reject(
+          new Error(
+            `[Ebus2ProxyNotifier] callWorker(${service}): send failed: ${err}`
+          )
+        );
+      }
+    });
+  }
   /**
    * Set connection lifecycle callbacks.
    * These are merged with any callbacks provided in the constructor config.
@@ -9961,6 +10084,20 @@ var Ebus2ProxyServerUpdateNotifier = class {
     this.connected = false;
     this.subscribedChannels.clear();
     this.clearTimers();
+    if (this._pendingRequests.size > 0) {
+      for (const [, pending] of this._pendingRequests) {
+        clearTimeout(pending.timer);
+        if (pending.abortListener && pending.signal) {
+          pending.signal.removeEventListener("abort", pending.abortListener);
+        }
+        pending.reject(
+          new Error(
+            `[Ebus2ProxyNotifier] callWorker(${pending.service}): WebSocket closed before reply`
+          )
+        );
+      }
+      this._pendingRequests.clear();
+    }
     const reason = event.reason || `Code: ${event.code}`;
     if (wasConnected) {
       for (const callback of this.onWsDisconnectCallbacks) {
@@ -10004,7 +10141,37 @@ var Ebus2ProxyServerUpdateNotifier = class {
             }
           }
           break;
+        case "response": {
+          if (message.id !== void 0) {
+            const pending = this._pendingRequests.get(message.id);
+            if (pending) {
+              clearTimeout(pending.timer);
+              this._pendingRequests.delete(message.id);
+              if (pending.abortListener && pending.signal) {
+                pending.signal.removeEventListener("abort", pending.abortListener);
+              }
+              pending.resolve(message.data);
+            }
+          }
+          break;
+        }
         case "error":
+          if (message.id !== void 0) {
+            const pending = this._pendingRequests.get(message.id);
+            if (pending) {
+              clearTimeout(pending.timer);
+              this._pendingRequests.delete(message.id);
+              if (pending.abortListener && pending.signal) {
+                pending.signal.removeEventListener("abort", pending.abortListener);
+              }
+              pending.reject(
+                new Error(
+                  `[Ebus2ProxyNotifier] callWorker(${pending.service}): ${message.error}`
+                )
+              );
+              break;
+            }
+          }
           console.error(`[Ebus2ProxyNotifier] WebSocket server error: ${message.error}`, message.error);
           break;
       }

package/dist/src/db/Ebus2ProxyServerUpdateNotifier.d.ts

@@ -69,6 +69,13 @@ export declare class Ebus2ProxyServerUpdateNotifier implements I_ServerUpdateNot
      * after if any are still pending).
      */
     private _pendingRttPings;
+    /**
+     * Pending `callWorker` promises keyed by request id. The matching
+     * `response` (or correlated `error`) frame resolves/rejects them.
+     * Cleared on disconnect — pending callers are rejected with a
+     * "WebSocket closed" error and the per-call timeout is freed.
+     */
+    private _pendingRequests;
     constructor(config: Ebus2ProxyServerUpdateNotifierConfig);
     subscribe(callback: ServerUpdateCallback): () => void;
     connect(): Promise<void>;
@@ -97,19 +104,57 @@ export declare class Ebus2ProxyServerUpdateNotifier implements I_ServerUpdateNot
     measureWsRtt(timeoutMs?: number): Promise<number>;
     /**
      * End-to-end RTT (client → proxy → broker → echo worker → broker →
-     * proxy → client). Sends an HTTP request to ebus-proxy's `echo`
-     * service with `Date.now()` as the msgpack payload; the worker
-     * returns the payload unchanged, and we verify byte-equality before
-     * reporting RTT.
+     * proxy → client). Invokes the `echo` worker via `callWorker` with
+     * `Date.now()` as the payload; the worker returns it unchanged and
+     * we verify byte-equality before reporting RTT.
      *
-     * The HTTP base URL is derived from `wsUrl` (`ws://` → `http://`,
-     * `wss://` → `https://`). Throws on HTTP error, payload mismatch,
-     * or timeout.
+     * Rides the existing WebSocket — same transport real notifications
+     * arrive on, so this is the more representative diagnostic of actual
+     * app-traffic latency. Throws on payload mismatch, timeout, or any
+     * `callWorker` failure path (WS not OPEN, proxy error, etc).
      *
-     * @param timeoutMs Max wait for HTTP response (default: 5000)
+     * @param timeoutMs Max wait for echo reply (default: 5000)
      * @returns RTT in milliseconds (full round-trip)
      */
     measureEndToEndRtt(timeoutMs?: number): Promise<number>;
+    /**
+     * Call an arbitrary ebus2 worker service over the existing
+     * WebSocket and return its msgpack-decoded reply.
+     *
+     * Uses the WS `request` / `response` correlation introduced in
+     * ebus-proxy 2.0 — the whole frame is msgpack, so the payload is
+     * sent as a raw value (no base64, no JSON envelope). Lower latency
+     * than HTTP (no TCP/TLS handshake, no per-call connection setup)
+     * and reuses the same auth + connection that the pub/sub channel
+     * is already using.
+     *
+     * Errors:
+     * - WebSocket not OPEN → throws synchronously (rejects).
+     * - Worker error / proxy error → rejects with the proxy's `error`
+     *   frame message.
+     * - Per-call `timeoutMs` elapses → rejects with timeout error and
+     *   removes the pending entry. The proxy may still process the
+     *   call server-side; client-side state is freed regardless.
+     * - WebSocket closes mid-flight → rejects with "WebSocket closed
+     *   before reply".
+     * - Caller `options.signal` aborts → rejects with "aborted".
+     *
+     * Multiple concurrent calls are safe — each request uses a unique
+     * correlation id and the `response`/`error` dispatch keys off it.
+     *
+     * @param service Worker service name registered on cry-ebus2.
+     * @param payload Anything msgpack+structuredClone can serialize.
+     *   BSON ObjectId/Timestamp are preprocessed like all other WS
+     *   frames. Pass `undefined` to call without a payload.
+     * @param options.timeoutMs Per-call timeout (default 5000). Also
+     *   forwarded as the proxy-side `timeout` field.
+     * @param options.signal External AbortSignal for cancellation.
+     * @returns Worker's reply, msgpack-decoded as T.
+     */
+    callWorker<T = unknown>(service: string, payload?: unknown, options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<T>;
     /**
      * Set connection lifecycle callbacks.
      * These are merged with any callbacks provided in the constructor config.

package/dist/src/db/SyncedDb.d.ts

@@ -78,6 +78,18 @@ export declare class SyncedDb implements I_SyncedDb {
      * notifier is configured or the notifier doesn't support it.
      */
     measureEndToEndRtt(timeoutMs?: number): Promise<number>;
+    /**
+     * Call an arbitrary worker service via the configured server-update
+     * notifier (typically over its WebSocket). Delegates to
+     * `serverUpdateNotifier.callWorker`. Throws if no notifier is
+     * configured or the notifier doesn't support worker invocation.
+     *
+     * @see I_ServerUpdateNotifier.callWorker
+     */
+    callWorker<T = unknown>(service: string, payload?: unknown, options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<T>;
     /**
      * Register a collection for sync at runtime. See `I_SyncedDb.addCollectionToSync`.
      */

package/dist/src/types/I_ServerUpdateNotifier.d.ts

@@ -83,4 +83,29 @@ export interface I_ServerUpdateNotifier {
      * @param timeoutMs Max wait for response (default: 5000)
      */
     measureEndToEndRtt?(timeoutMs?: number): Promise<number>;
+    /**
+     * Call an arbitrary worker service via the notifier's transport and
+     * return its decoded reply.
+     *
+     * For WS-capable notifiers, this typically rides the same WebSocket
+     * connection as pub/sub (lower latency than spinning up an HTTP
+     * fetch) and uses transport-native correlation (`request` /
+     * `response` frames). Implementations may fall back to HTTP if the
+     * transport doesn't support inline RPC.
+     *
+     * Optional. Throws if transport is not connected, the worker errors,
+     * or the per-call timeout elapses. Implementations that don't
+     * support worker invocation may omit this method.
+     *
+     * @param service Worker service name (e.g. `"echo"`, `"print"`).
+     * @param payload Service-specific payload — must be serializable by
+     *   the transport's codec (msgpack with `structuredClone: true` for
+     *   the WS implementation).
+     * @param options.timeoutMs Per-call timeout in milliseconds.
+     * @param options.signal External AbortSignal for cancellation.
+     */
+    callWorker?<T = unknown>(service: string, payload?: unknown, options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<T>;
 }

package/dist/src/types/I_SyncedDb.d.ts

@@ -1118,6 +1118,26 @@ export interface I_SyncedDb {
      * @returns RTT in milliseconds (full round-trip)
      */
     measureEndToEndRtt(timeoutMs?: number): Promise<number>;
+    /**
+     * Call an arbitrary ebus2 worker service via the configured server-
+     * update notifier and return the worker's decoded reply. Routes
+     * through the existing WebSocket on the
+     * `Ebus2ProxyServerUpdateNotifier` implementation (ebus-proxy ≥ 2.0
+     * `request` / `response` frames). Throws if no notifier is
+     * configured, the transport is not connected, the worker errors, or
+     * the per-call timeout elapses.
+     *
+     * @param service Worker service name (e.g. "echo", "print").
+     * @param payload Anything msgpack+structuredClone can serialize.
+     *   BSON ObjectId/Timestamp preprocessed automatically.
+     * @param options.timeoutMs Per-call timeout (default 5000).
+     * @param options.signal External AbortSignal for cancellation.
+     * @returns Worker's reply typed as T (caller-asserted).
+     */
+    callWorker<T = unknown>(service: string, payload?: unknown, options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<T>;
     /**
      * Get metadata for a single object.
      * @param collection Collection name

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cry-synced-db-client",
-  "version": "0.1.179",
+  "version": "0.1.181",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -29,12 +29,12 @@
   "devDependencies": {
     "@types/bun": "latest",
     "bson": "^7.2.0",
-    "cry-ebus-proxy": "^1.0.3",
+    "cry-ebus-proxy": "^2.0.0",
     "dexie": "^4.4.2",
     "esbuild": "^0.28.0",
     "fake-indexeddb": "^6.2.5",
     "typescript": "^6",
-    "vitest": "^4.1.5"
+    "vitest": "^4.1.6"
   },
   "dependencies": {
     "cry-helpers": "^2.1.194",