cry-synced-db-client 0.1.180 → 0.1.181

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # 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

package/dist/index.js

@@ -9845,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)})`

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

@@ -104,16 +104,16 @@ 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>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cry-synced-db-client",
-  "version": "0.1.180",
+  "version": "0.1.181",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",