cry-synced-db-client 0.1.175 → 0.1.177

package/CHANGELOG.md

@@ -1,6 +1,166 @@
 # Versions
 
-## Unreleased
+## 0.1.177 (2026-05-13)
+
+Hot-path micro-optimizations from a ts-coding skill audit. Five small wins,
+each verified independently against the actual control flow before applying.
+
+### `$regex` operand cached per pattern
+
+`matchesOperator` for `$regex` used to call `new RegExp(operand)` on every
+record × operator invocation. For in-mem `find` over a large collection
+this recompiled the same pattern thousands of times. Now a module-level
+`Map<string, RegExp>` caches compiled regexes by operand string with a
+bounded FIFO eviction (128 entries) so dynamic patterns don't leak.
+Implementation in `src/utils/localQuery.ts:compileRegex`.
+
+### `SyncedDb.close()` is idempotent
+
+Added a `this.closed` guard that early-returns on the second call. Most
+disposal calls inside `close()` were already idempotent (timer clears,
+listener removes), but `crossTabSync.dispose()`, `wakeSync.dispose()`,
+`networkStatus.dispose()`, and `serverUpdateNotifier.dispose?.()` are not
+internally guarded — calling them twice could throw. Now safe.
+
+### Orphan dirty reconstruction batches into `saveMany`
+
+`SyncEngine.uploadDirtyItems` reconstructs missing main rows when a dirty
+change exists but the main entry was lost (e.g. debounced write didn't
+flush before reload). Previously called `await dexieDb.save(...)` per
+orphan inside the per-item loop. Now collects reconstructed entities and
+issues one `saveMany` at the end. Rare path — minor improvement, no
+behavior change.
+
+### `sentIds` warning path drops intermediate spreads
+
+`SyncEngine.uploadDirtyItems` builds a `sentIds` Set for the
+"unacknowledged items" warning. Previously used
+`new Set([...batches.flat().filter(...).flatMap(...)])` (multiple array
+allocations) and `[...sentIds].filter(...)` (one more spread). Now a
+single for-of pass into a Set, plus a direct iteration to build `unacked`.
+
+### `ServerUpdateHandler` batch case now concurrent
+
+WebSocket batch server-update notifications previously processed each
+insert / update / delete with sequential `await` calls. Each per-item
+handler operates on an independent `_id`; Dexie reads/writes on different
+keys don't conflict, so replaced the loops with `Promise.all` over the
+per-item handlers. On a batch of N items this turns N sequential IDB
+round-trips into N concurrent ones — the dominant latency win for any
+tab subscribed to a busy collection.
+
+The deeper "single `getByIds` + `saveMany` per batch" refactor was
+deferred: the per-item update handler has 5+ semantically distinct
+branches (self-echo A/B/C, pending change merge, dirty merge, clean
+meta-only) and duplicating that logic for the batch path carries
+re-implementation risk that isn't justified by the additional latency
+savings over `Promise.all`.
+
+## 0.1.176 (2026-05-13)
+
+### Passive transport metrics on `findNewerManyStream` round-trip (rdb2)
+
+`FindNewerManyResultInfo` (delivered to `onFindNewerManyResult`) now
+carries three optional metrics captured passively during the sync
+round-trip — no extra round-trip needed, no overhead when callbacks
+are absent:
+
+- `requestBytes` — msgpack-encoded request body size (upload payload).
+- `responseBytes` — sum of wire bytes received across all streaming
+  chunks (download payload). Renamed from the short-lived
+  `bytesStreamed`.
+- `ttfbMs` — time-to-first-byte: elapsed from request send until
+  response headers arrive. Conflates `upload travel + server work +
+  first-byte travel` (would need a server-timing header to split
+  further).
+
+Combined with the existing `durationMs`, callers can derive download
+throughput and a server-vs-network breakdown without instrumenting the
+transport themselves:
+
+```typescript
+new SyncedDb({
+  onFindNewerManyResult: (info) => {
+    if (!info.success || info.responseBytes == null) return;
+    const downloadMs = info.durationMs - (info.ttfbMs ?? 0);
+    const kBps = downloadMs > 0 ? (info.responseBytes / downloadMs) : 0;
+    metrics.record({
+      req: info.requestBytes,
+      resp: info.responseBytes,
+      ttfb: info.ttfbMs,
+      total: info.durationMs,
+      kBps,
+    });
+  },
+});
+```
+
+Wired through the transport layer:
+
+- `I_RestInterface.findNewerManyStream` options gain three optional
+  byte/timing callbacks: `onRequestBytes(bytes)`,
+  `onTtfbMs(ms)`, `onResponseChunkBytes(bytes)`. All fire even on
+  failure paths where applicable. Old two-arg `onChunk` callbacks keep
+  working unchanged.
+- `RestProxy` fires `onRequestBytes` just before `fetch`, `onTtfbMs`
+  immediately after `await fetch(...)` resolves (separate `fetchStart`
+  marker, independent of `timeRequests`), and `onResponseChunkBytes`
+  per `reader.read()` chunk in `parseStreamingResponse`.
+- `SyncEngine.syncCore` accumulates bytes / captures TTFB and forwards
+  them into `callOnFindNewerManyResult` on both success and error
+  paths. Mocks and alternative transports that don't fire the
+  callbacks leave the fields `undefined` — graceful degradation.
+
+### RTT measurement: `measureWsRtt` + `measureEndToEndRtt` (ebus-proxy)
+
+Two diagnostic methods on `SyncedDb` (and `I_ServerUpdateNotifier`) to
+measure connection latency. Together they isolate where latency comes
+from:
+
+- **`measureWsRtt(timeoutMs?)`** — client → notifier server → client.
+  Sends a tagged WS ping (`{type: "ping", id: <unique>}`) and resolves
+  with `performance.now()` delta when the matching pong arrives. Pure
+  proxy responsiveness + network. Sub-ms on localhost.
+- **`measureEndToEndRtt(timeoutMs?)`** — client → proxy → broker →
+  `echo` worker → broker → proxy → client. HTTP GET to ebus-proxy's
+  `/?service=echo` endpoint with `Date.now()` msgpack payload; worker
+  returns it unchanged. ~3-15 ms on localhost.
+
+Both return RTT in milliseconds, both Promise-based (don't block thread).
+Multiple concurrent `measureWsRtt()` calls work — each uses a unique
+correlation id.
+
+Diagnostic interpretation:
+
+| WS RTT | E2E RTT | Likely cause |
+|---|---|---|
+| low | low | All good |
+| low | high | Broker / echo worker overloaded |
+| high | high (similar Δ) | Network or proxy slow |
+| spikes | stable | WS frame issue (tab throttle, frozen socket) |
+
+```typescript
+const wsRtt = await syncedDb.measureWsRtt();
+const e2eRtt = await syncedDb.measureEndToEndRtt();
+console.log(`network/proxy=${wsRtt.toFixed(1)}ms, full chain=${e2eRtt.toFixed(1)}ms`);
+```
+
+The notifier-interface methods are **optional** (`measureWsRtt?` /
+`measureEndToEndRtt?`) so custom `I_ServerUpdateNotifier`
+implementations don't need to implement them. `SyncedDb` pass-throughs
+throw a descriptive error if missing.
+
+Implementation in `Ebus2ProxyServerUpdateNotifier`: tagged ping reuses
+the existing WS handler (extends pong dispatch in `handleMessage`
+with a `_pendingRttPings` Map). HTTP echo derives the base URL from
+`wsUrl` (`ws://` → `http://`, `wss://` → `https://`), msgpack-encodes
+the payload, hits `/?service=echo`, validates byte-equal echo.
+
+Live test (localhost, warm, 20 samples): WS p50 0.30 ms, E2E p50
+4.11 ms. Mock-only unit tests in `test/measureRtt.test.ts` (7 cases —
+delegation, propagated rejection, no-notifier error, shape sanity).
+
+## 0.1.175 (2026-05-13)
 
 ### `save(coll, id, {field: {}})` clears existing nested children
 
@@ -74,6 +234,37 @@ await syncedDb.replaceSyncCollection({
 });
 ```
 
+## 0.1.174 (2026-05-12)
+
+### Fix: overlay `_dirty_changes` onto in-mem on init
+
+After Ctrl+R while a debounced Dexie main write was pending, the in-mem
+cache showed stale Dexie main state instead of the merged dirty diff —
+UI readers saw old field values until the next sync round-trip.
+Production incident, klikvet 2026-05-12 with the server offline.
+
+Root cause: `loadCollectionToInMem` (called from `init()`) read only the
+Dexie main table; it never overlaid `_dirty_changes`.
+`recoverPendingWrites` recovers from `localStorage`, but `localStorage`
+may have been cleared by an earlier partial-debounce success — the
+Dexie-only `_dirty_changes` table is the durable source for those
+writes.
+
+Fix: after loading Dexie main, walk `_dirty_changes` and apply each diff
+to the matching main row via `applyDiffLocally`. Orphan dirty (no
+matching main row) is included in in-mem with a `console.warn`. Dirty
+entries marking `_deleted` / `_archived` remove the record from in-mem.
+
+Scope: in-mem cache only. `findById` uses the in-mem fast path, so its
+results now reflect dirty. `find()` reads Dexie main directly — that's
+a separate Dexie-overlay gap, not addressed here.
+
+Regression test: `test/dirtyOverlayOnInit.test.ts` (5 cases — production
+scenario, orphan, soft-delete via dirty, no-dirty fast path, multiple
+records). 708 pass / 0 fail.
+
+## 0.1.173 (2026-05-12)
+
 ### `preprocessDirtyItem` callback — per-item filter / transform before upload
 
 New optional config callback fired for **every** dirty item just before it
@@ -110,6 +301,8 @@ new SyncedDb({
 Useful for: per-tenant data sanitization, conditional upload gating,
 audit-trail injection.
 
+## 0.1.172 (2026-05-12)
+
 ### Nested-bracket terminal layering in `mergeDirtyPath` Case 2
 
 When a new terminal-bracket whole-element write arrives AFTER pending
@@ -148,6 +341,8 @@ alongside actual upload errors in observability pipelines.
 `SUPRESS_DB_WARNINGS` constant in `SyncEngine.ts` silences them when
 needed (e.g. during noisy migrations).
 
+## 0.1.171 (2026-05-11)
+
 ### Runtime collection registration (`addCollectionToSync`, `replaceSyncCollection`)
 
 Two methods to install / replace collection configs at runtime; both load the
@@ -244,6 +439,8 @@ const sinceMs = isLeader
   : Date.now() - syncedDb.followerSince()!.getTime();
 ```
 
+## 0.1.163 (2026-05-10)
+
 ### `onServerSyncWrite` callback
 
 Single-shot callback that fires once per `restInterface.updateCollections`
@@ -281,7 +478,7 @@ parity across **mongo + Dexie + in-mem** simultaneously after a partial
 `save({ postavke: [{_id: "P1", kolicina: 2}] })` over an existing
 `postavke[0] = {_id: "P1", opis: "postavka 1", kolicina: 1}`.
 
-## 0.1.162
+## 0.1.162 (2026-05-10)
 
 ### Bracket-by-_id paths flow through server unchanged
 
@@ -336,7 +533,7 @@ Replaced with `applyDiffLocally(base, diff, id)`:
 
 `deleteByPath` is now a sibling export of `setByPath` in `computeDiff.ts`.
 
-## 0.1.161
+## 0.1.161 (2026-05-10)
 
 ### Don't auto-stamp `_id` on bracket-array elements
 
@@ -347,7 +544,7 @@ preserved. This allows callers to mix:
 - Bracket-by-_id sub-field path: `update["postavke[<id>].field"] = value`
 in the same payload without the client mutating element identity.
 
-## 0.1.160
+## 0.1.160 (2026-05-09)
 
 ### Composition changes emit precise paths (not full-array replace)
 
@@ -369,7 +566,7 @@ Pre-fix, composition change emitted full-array replace at `basePath`,
 which `mergeDirtyPath` Case 2 then dropped pending sub-field paths on
 the same parent — race-y data-loss strip pattern visible in production.
 
-## 0.1.159
+## 0.1.159 (2026-05-09)
 
 ### Self-echo WS suppression for `_rev <= local._rev`
 
@@ -388,11 +585,11 @@ older snapshot because a self-echo WS arrived after writeback and
 overwrote in-mem with the server's `$set`-iterated copy of postavke
 (missing freshly-set `pop` and `navodilo` fields). Now in-mem is preserved.
 
-## 0.1.158
+## 0.1.158 (2026-05-09)
 
 Internal version bump consolidating 0.1.157 fixes for production publish.
 
-## 0.1.157
+## 0.1.157 (2026-05-08)
 
 ### Recursive server-managed metadata strip at upload boundary
 
@@ -429,7 +626,7 @@ stuck-dirty payload (mixing top-level full arrays with bracket paths)
 into Dexie's `_dirty_changes` and asserts upload succeeds without
 mongo path-conflict errors via a `MongoFaithfulRestInterface` mock.
 
-## 0.1.156
+## 0.1.156 (2026-05-08)
 
 Three related fixes targeting **dirty-payload metadata leak** and
 **concurrent array merge corruption** observed in production
@@ -505,7 +702,7 @@ Temporary upload-time scrubber dropping legacy position-based array
 paths (`field.<digit>(.…)?`) when `serverRev > baseRev`. Marked for
 removal after ~2026-05-15 once all clients have re-synced.
 
-## 0.1.155
+## 0.1.155 (2026-05-08)
 
 Two new `SyncedDbConfig` fields targeting **cross-device scope-exit**
 detection: situations where one device modifies a record so it no longer
@@ -562,7 +759,7 @@ wake.
 - `_collectScopeExitPlan` and single-collection `evictOutOfScopeRecords`
   both route through the new helper.
 
-## Unreleased
+## 0.1.149 (2026-04-27)
 
 ### `SyncSource` flag in `I_InMemDb.saveMany` / `deleteManyByIds`
 
@@ -600,6 +797,8 @@ Tests: `test/syncSource.test.ts` (9 cases) covers initial / incremental
 / refresh propagation across all public write paths. `MockInMemDb`
 exposes `recordedCalls: RecordedInMemCall[]` for assertion.
 
+## 0.1.148 (2026-04-26)
+
 ### `uploadDirtyItems` follow-up pass — drain in-sync writes immediately
 
 Writes that land **during** a sync iteration had their
@@ -630,6 +829,8 @@ first pass — a follow-up failure does not roll back the first pass's
 already-cleared dirty entries; affected items are caught at the next
 sync tick (same retry semantics as before).
 
+## 0.1.147 (2026-04-25)
+
 ### Auto-eviction co-located with sync — one round-trip total
 
 When `evictStaleRecordsEveryHrs > 0` and the interval has elapsed, the
@@ -701,6 +902,8 @@ request carry multiple specs against the same collection without
   library always populates them. Downstream code that constructs mock
   literals (e.g. tests) needs the new fields.
 
+## 0.1.144 (2026-04-24)
+
 ### Fix: filtered-sync tombstone (scope-exit from other writers)
 
 When a collection has `syncConfig.query` (e.g. `{ status: { $ne: "obsolete" } }`)
@@ -735,6 +938,8 @@ predicate (no implicit server policy).
   `$nor` support, required for the negated query to evaluate against the test
   mock and for any client-side filtering that uses logical operators.
 
+## 0.1.142 (2026-04-21)
+
 ### `getDirtyMeta()` for lightweight dirty-state inspection
 
 - New `SyncedDb.getDirtyMeta()` returns dirty-entry meta (everything except the
@@ -765,6 +970,8 @@ Two contributing causes, both fixed:
   cache learns of them via the existing shared-Dexie reload path. Reload
   broadcasts (post-full-sync) remain leader-only.
 
+## 0.1.141 (2026-04-21)
+
 ### BREAKING: Self-healing sync/reconnect lifecycle
 
 Fixes a class of bugs where the 60s auto-sync scheduler silently died after a
@@ -795,17 +1002,21 @@ tenants, 62–296 min of dead scheduler with dirty items accumulating.
 `onForcedOffline: (reason) => log(reason)` → `onSyncFailed: (reason) => log(reason)`.
 Signature is identical. No other callback changes.
 
-- Add `refreshInBackground` `QueryOpts` option for `findById` / `findByIds`
-  - Stale-while-revalidate: cache-hit returns local result immediately and
-    triggers a background fetch that updates Dexie + in-mem through conflict
-    resolution (`processCollectionServerData`).
-  - Orthogonal to `referToServer` — does not change miss behaviour. With
-    defaults (`referToServer: true`) misses are still awaited; with
-    `referToServer: false` misses return `null` and bg fetch loads them async.
-  - Dedupes against `referToServer`: IDs fetched blockingly are NOT re-fetched
-    in the background (no double-round-trip).
-  - Noop when offline or on writeOnly collections.
-  - Ignored on `find` / `findOne` (use `referToServer` there).
+## 0.1.139 (2026-04-21)
+
+### `refreshInBackground` `QueryOpts` option for `findById` / `findByIds`
+
+Stale-while-revalidate: cache-hit returns the local result immediately and
+triggers a background fetch that updates Dexie + in-mem through conflict
+resolution (`processCollectionServerData`).
+
+- Orthogonal to `referToServer` — does not change miss behaviour. With
+  defaults (`referToServer: true`) misses are still awaited; with
+  `referToServer: false` misses return `null` and bg fetch loads them async.
+- Dedupes against `referToServer`: IDs fetched blockingly are NOT re-fetched
+  in the background (no double-round-trip).
+- Noop when offline or on writeOnly collections.
+- Ignored on `find` / `findOne` (use `referToServer` there).
 
 ## 0.1.146 (2026-04-25)
 

package/dist/index.js

@@ -37,6 +37,21 @@ import Dexie2 from "dexie";
 import { ObjectId as ObjectId2 } from "bson";
 
 // src/utils/localQuery.ts
+var regexCache = /* @__PURE__ */ new Map();
+var REGEX_CACHE_MAX = 128;
+function compileRegex(operand) {
+  if (operand instanceof RegExp) return operand;
+  const key = String(operand);
+  let r = regexCache.get(key);
+  if (r) return r;
+  r = new RegExp(key);
+  if (regexCache.size >= REGEX_CACHE_MAX) {
+    const oldest = regexCache.keys().next().value;
+    if (oldest !== void 0) regexCache.delete(oldest);
+  }
+  regexCache.set(key, r);
+  return r;
+}
 function matchesQuery(item, query) {
   for (const [key, condition] of Object.entries(query)) {
     if (key === "$and") {
@@ -107,7 +122,7 @@ function matchesOperator(value, operator, operand) {
     case "$exists":
       return operand ? value !== void 0 : value === void 0;
     case "$regex": {
-      const regex = operand instanceof RegExp ? operand : new RegExp(operand);
+      const regex = compileRegex(operand);
       if (typeof value === "string") return regex.test(value);
       if (Array.isArray(value)) {
         return value.some((v) => typeof v === "string" && regex.test(v));
@@ -3083,6 +3098,9 @@ var _SyncEngine = class _SyncEngine {
           source: isInitial ? "initial" : "incremental"
         });
       }
+      let requestBytes;
+      let responseBytes;
+      let ttfbMs;
       try {
         const completedCollections = /* @__PURE__ */ new Set();
         const allSpecs = extras && extras.specs.length > 0 ? [...syncSpecs, ...extras.specs] : syncSpecs;
@@ -3118,6 +3136,17 @@ var _SyncEngine = class _SyncEngine {
                   items: items.length
                 });
               }
+            },
+            {
+              onRequestBytes: (bytes) => {
+                requestBytes = bytes;
+              },
+              onTtfbMs: (ms) => {
+                ttfbMs = ms;
+              },
+              onResponseChunkBytes: (bytes) => {
+                responseBytes = (responseBytes != null ? responseBytes : 0) + bytes;
+              }
             }
           ),
           "findNewerManyStream"
@@ -3130,7 +3159,15 @@ var _SyncEngine = class _SyncEngine {
             sentCount: 0
           };
         }
-        this.callOnFindNewerManyResult(syncSpecs, {}, findNewerManyStartTime, true, calledFrom);
+        this.callOnFindNewerManyResult(
+          syncSpecs,
+          {},
+          findNewerManyStartTime,
+          true,
+          calledFrom,
+          void 0,
+          { requestBytes, responseBytes, ttfbMs }
+        );
         this.callbackSafe(this.callbacks.onServerSyncEnd, {
           calledFrom,
           collectionCount: syncSpecs.length,
@@ -3139,7 +3176,15 @@ var _SyncEngine = class _SyncEngine {
           success: true
         });
       } catch (err) {
-        this.callOnFindNewerManyResult(syncSpecs, {}, findNewerManyStartTime, false, calledFrom, err);
+        this.callOnFindNewerManyResult(
+          syncSpecs,
+          {},
+          findNewerManyStartTime,
+          false,
+          calledFrom,
+          err,
+          { requestBytes, responseBytes, ttfbMs }
+        );
         this.callbackSafe(this.callbacks.onServerSyncEnd, {
           calledFrom,
           collectionCount: syncSpecs.length,
@@ -3223,6 +3268,7 @@ var _SyncEngine = class _SyncEngine {
       const skipped = [];
       const ids = dirtyChanges.map((dc) => dc._id);
       const fullItems = await this.dexieDb.getByIds(collectionName, ids);
+      const orphanReconstructed = [];
       for (let i = 0; i < fullItems.length; i++) {
         const fullItem = fullItems[i];
         const id = ids[i];
@@ -3238,7 +3284,7 @@ var _SyncEngine = class _SyncEngine {
           const delta = dirtyChangesMap.get(String(id));
           if (delta) {
             const reconstructed = __spreadProps(__spreadValues({}, delta), { _id: id });
-            await this.dexieDb.save(collectionName, id, reconstructed);
+            orphanReconstructed.push(reconstructed);
             updates.push({ _id: id, delta });
           } else {
             skipped.push({ _id: String(id), reason: "no-delta-for-orphan" });
@@ -3247,6 +3293,9 @@ var _SyncEngine = class _SyncEngine {
           skipped.push({ _id: "<null>", reason: "no-fullitem-no-id" });
         }
       }
+      if (orphanReconstructed.length > 0) {
+        await this.dexieDb.saveMany(collectionName, orphanReconstructed);
+      }
       if (updates.length === 0) {
         console.warn(
           `[SyncEngine] uploadDirtyItems: ${collectionName} has ${dirtyChanges.length} dirty entries but 0 resolvable items`,
@@ -3506,14 +3555,20 @@ var _SyncEngine = class _SyncEngine {
           );
         }
       }
-      const sentIds = /* @__PURE__ */ new Set([
-        ...collectionBatches.flat().filter((b) => b.collection === collection).flatMap((b) => [
-          ...b.batch.updates.map((u) => String(u._id)),
-          ...b.batch.deletes.map((d) => String(d._id))
-        ])
-      ]);
-      const ackIds = new Set(allSuccessIds.map(String));
-      const unacked = [...sentIds].filter((id) => !ackIds.has(id));
+      const sentIds = /* @__PURE__ */ new Set();
+      for (const batch of collectionBatches) {
+        for (const b of batch) {
+          if (b.collection !== collection) continue;
+          for (const u of b.batch.updates) sentIds.add(String(u._id));
+          for (const d of b.batch.deletes) sentIds.add(String(d._id));
+        }
+      }
+      const ackIds = /* @__PURE__ */ new Set();
+      for (const id of allSuccessIds) ackIds.add(String(id));
+      const unacked = [];
+      for (const id of sentIds) {
+        if (!ackIds.has(id)) unacked.push(id);
+      }
       if (unacked.length > 0) {
         console.warn(
           `[SyncEngine] uploadDirtyItems: ${collection}: ${unacked.length} items sent but not acknowledged:`,
@@ -3799,7 +3854,7 @@ var _SyncEngine = class _SyncEngine {
       }
     }
   }
-  callOnFindNewerManyResult(specs, results, startTime, success, calledFrom, error) {
+  callOnFindNewerManyResult(specs, results, startTime, success, calledFrom, error, metrics) {
     if (this.callbacks.onFindNewerManyResult) {
       try {
         this.callbacks.onFindNewerManyResult({
@@ -3808,7 +3863,10 @@ var _SyncEngine = class _SyncEngine {
           durationMs: Date.now() - startTime,
           success,
           error: error instanceof Error ? error : error ? new Error(String(error)) : void 0,
-          calledFrom
+          calledFrom,
+          requestBytes: metrics == null ? void 0 : metrics.requestBytes,
+          responseBytes: metrics == null ? void 0 : metrics.responseBytes,
+          ttfbMs: metrics == null ? void 0 : metrics.ttfbMs
         });
       } catch (err) {
         console.error("[SyncEngine] onFindNewerManyResult callback failed:", err);
@@ -3944,39 +4002,57 @@ var ServerUpdateHandler = class {
             deletes.push(item.data);
           }
         }
-        for (const serverItem of inserts) {
-          await this.handleServerItemInsert(collectionName, serverItem);
-          updatedIds.push(String(serverItem._id));
+        if (inserts.length > 0) {
+          await Promise.all(
+            inserts.map(
+              (serverItem) => this.handleServerItemInsert(collectionName, serverItem)
+            )
+          );
+          for (const serverItem of inserts) {
+            updatedIds.push(String(serverItem._id));
+          }
         }
         if (updates.length > 0) {
           const updateIds = updates.map((u) => u._id);
           const localItems = await this.dexieDb.getByIds(collectionName, updateIds);
           const missingIds = [];
+          const updatePromises = [];
           for (let i = 0; i < updates.length; i++) {
             const deltaData = updates[i];
             const localItem = localItems[i];
             if (localItem) {
-              await this.handleServerItemUpdate(collectionName, localItem, deltaData);
+              updatePromises.push(
+                this.handleServerItemUpdate(collectionName, localItem, deltaData)
+              );
               updatedIds.push(String(deltaData._id));
             } else {
               missingIds.push(deltaData._id);
             }
           }
+          if (updatePromises.length > 0) await Promise.all(updatePromises);
           if (missingIds.length > 0) {
             const fullItems = await this.restInterface.findByIds(
               collectionName,
               missingIds
             );
+            const insertPromises = [];
             for (const fullItem of fullItems) {
               if (!fullItem) continue;
-              await this.handleServerItemInsert(collectionName, fullItem);
+              insertPromises.push(
+                this.handleServerItemInsert(collectionName, fullItem)
+              );
               updatedIds.push(String(fullItem._id));
             }
+            if (insertPromises.length > 0) await Promise.all(insertPromises);
           }
         }
-        for (const deleteData of deletes) {
-          await this.handleServerItemDelete(collectionName, deleteData._id);
-          updatedIds.push(String(deleteData._id));
+        if (deletes.length > 0) {
+          await Promise.all(
+            deletes.map((d) => this.handleServerItemDelete(collectionName, d._id))
+          );
+          for (const deleteData of deletes) {
+            updatedIds.push(String(deleteData._id));
+          }
         }
         break;
       }
@@ -4313,6 +4389,7 @@ var _SyncedDb = class _SyncedDb {
     this.collections = /* @__PURE__ */ new Map();
     // State
     this.initialized = false;
+    this.closed = false;
     this.syncing = false;
     this.syncLock = false;
     this.wsUpdateQueue = [];
@@ -4571,6 +4648,36 @@ var _SyncedDb = class _SyncedDb {
   followerSince() {
     return this.leaderElection.followerSince();
   }
+  /**
+   * WS round-trip time (client → notifier server → client). Delegates
+   * to `serverUpdateNotifier.measureWsRtt`. Throws if no notifier is
+   * configured or the notifier implementation doesn't support RTT.
+   */
+  async measureWsRtt(timeoutMs) {
+    var _a;
+    const fn = (_a = this.serverUpdateNotifier) == null ? void 0 : _a.measureWsRtt;
+    if (!fn) {
+      throw new Error(
+        "[SyncedDb] measureWsRtt: no serverUpdateNotifier or notifier does not support RTT"
+      );
+    }
+    return fn.call(this.serverUpdateNotifier, timeoutMs);
+  }
+  /**
+   * End-to-end RTT including downstream broker/worker hop. Delegates
+   * to `serverUpdateNotifier.measureEndToEndRtt`. Throws if no
+   * notifier is configured or the notifier doesn't support it.
+   */
+  async measureEndToEndRtt(timeoutMs) {
+    var _a;
+    const fn = (_a = this.serverUpdateNotifier) == null ? void 0 : _a.measureEndToEndRtt;
+    if (!fn) {
+      throw new Error(
+        "[SyncedDb] measureEndToEndRtt: no serverUpdateNotifier or notifier does not support end-to-end RTT"
+      );
+    }
+    return fn.call(this.serverUpdateNotifier, timeoutMs);
+  }
   /**
    * Register a collection for sync at runtime. See `I_SyncedDb.addCollectionToSync`.
    */
@@ -4821,6 +4928,8 @@ var _SyncedDb = class _SyncedDb {
   }
   async close() {
     var _a, _b;
+    if (this.closed) return;
+    this.closed = true;
     this.leaderElection.setClosing(true);
     this.pendingChanges.cancelRestUploadTimer();
     this.connectionManager.stopTimers();
@@ -9347,11 +9456,12 @@ var RestProxy = class {
    *   type=0x01 for data, type=0x00 for end-of-stream.
    */
   async findNewerManyStream(spec, onChunk, options) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     const connectTimeout = (_a = options == null ? void 0 : options.timeoutMs) != null ? _a : this.defaultTimeoutMs;
     const activityTimeout = (_b = options == null ? void 0 : options.activityTimeoutMs) != null ? _b : 3e4;
     const externalSignal = (_c = options == null ? void 0 : options.signal) != null ? _c : this.globalSignal;
     const startTime = this.timeRequests ? performance.now() : 0;
+    const fetchStart = performance.now();
     const data = {
       payload: {
         db: this.tenant,
@@ -9365,6 +9475,7 @@ var RestProxy = class {
       }
     };
     const body = pack2(data);
+    (_d = options == null ? void 0 : options.onRequestBytes) == null ? void 0 : _d.call(options, body.byteLength);
     const requestUrl = this.apiKey ? `${this.endpoint}?apikey=${this.apiKey}&stream=1` : `${this.endpoint}?stream=1`;
     const controller = new AbortController();
     let timeoutId = setTimeout(
@@ -9379,6 +9490,7 @@ var RestProxy = class {
         body,
         signal: combinedSignal
       });
+      (_e = options == null ? void 0 : options.onTtfbMs) == null ? void 0 : _e.call(options, performance.now() - fetchStart);
       clearTimeout(timeoutId);
       timeoutId = void 0;
       if (!response.ok) {
@@ -9390,7 +9502,12 @@ var RestProxy = class {
         timeoutId = setTimeout(() => controller.abort(), activityTimeout);
       };
       resetActivity();
-      await this.parseStreamingResponse(response, onChunk, resetActivity);
+      await this.parseStreamingResponse(
+        response,
+        onChunk,
+        resetActivity,
+        options == null ? void 0 : options.onResponseChunkBytes
+      );
       if (timeoutId !== void 0) clearTimeout(timeoutId);
       timeoutId = void 0;
       if (this.timeRequests) {
@@ -9428,7 +9545,7 @@ var RestProxy = class {
    *
    * `onChunk` receives `specId` as the third arg for type-0x02 frames; `undefined` otherwise.
    */
-  async parseStreamingResponse(response, onChunk, onActivity) {
+  async parseStreamingResponse(response, onChunk, onActivity, onChunkBytes) {
     const reader = response.body.getReader();
     const buffer = new StreamBuffer();
     const decoder2 = new TextDecoder();
@@ -9436,6 +9553,7 @@ var RestProxy = class {
       const { done, value } = await reader.read();
       if (done) return false;
       onActivity();
+      if (onChunkBytes) onChunkBytes(value.byteLength);
       buffer.append(value);
       return true;
     };
@@ -9570,6 +9688,13 @@ var Ebus2ProxyServerUpdateNotifier = class {
     this.reconnectAttempt = 0;
     this.forcedOffline = false;
     this.subscribedChannels = /* @__PURE__ */ new Set();
+    /**
+     * Pending RTT measurement promises keyed by ping id. Each entry is a
+     * resolver that the pong handler invokes once the matching pong
+     * arrives. Disconnect clears the map (caller's timeout fires soon
+     * after if any are still pending).
+     */
+    this._pendingRttPings = /* @__PURE__ */ new Map();
     var _a, _b, _c, _d, _e;
     this.endpoint = config.wsUrl;
     this.wsUrl = config.wsUrl;
@@ -9625,10 +9750,88 @@ var Ebus2ProxyServerUpdateNotifier = class {
     this.onWsConnectCallbacks.length = 0;
     this.onWsDisconnectCallbacks.length = 0;
     this.onWsReconnectCallbacks.length = 0;
+    this._pendingRttPings.clear();
   }
   isConnected() {
     return this.connected && !this.forcedOffline;
   }
+  /**
+   * WS round-trip time (client → proxy → client). Sends a tagged ping
+   * over the existing WebSocket and resolves with `performance.now()`
+   * delta when the matching pong arrives. Does NOT touch the cry-ebus2
+   * broker or any worker — measures pure proxy responsiveness +
+   * network latency.
+   *
+   * Throws if the WebSocket is not OPEN. The keepalive ping/pong
+   * watchdog is unaffected; multiple `measureWsRtt()` calls can be
+   * in flight simultaneously (each uses a unique correlation id).
+   *
+   * @param timeoutMs Max wait for matching pong (default: 5000)
+   * @returns RTT in milliseconds
+   */
+  async measureWsRtt(timeoutMs = 5e3) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("[Ebus2ProxyNotifier] measureWsRtt: WebSocket not OPEN");
+    }
+    const id = `rtt-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const t0 = performance.now();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this._pendingRttPings.delete(id);
+        reject(new Error(`[Ebus2ProxyNotifier] measureWsRtt: timeout after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this._pendingRttPings.set(id, () => {
+        clearTimeout(timer);
+        resolve(performance.now() - t0);
+      });
+      const pingMsg = { type: "ping", id };
+      this.ws.send(packr2.pack(preprocessForPack2(pingMsg)));
+    });
+  }
+  /**
+   * 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.
+   *
+   * The HTTP base URL is derived from `wsUrl` (`ws://` → `http://`,
+   * `wss://` → `https://`). Throws on HTTP error, payload mismatch,
+   * or timeout.
+   *
+   * @param timeoutMs Max wait for HTTP response (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);
+    if (echoed !== sentAt) {
+      throw new Error(
+        `[Ebus2ProxyNotifier] measureEndToEndRtt: payload mismatch (sent ${sentAt}, got ${JSON.stringify(echoed)})`
+      );
+    }
+    return performance.now() - t0;
+  }
   /**
    * Set connection lifecycle callbacks.
    * These are merged with any callbacks provided in the constructor config.
@@ -9775,6 +9978,13 @@ var Ebus2ProxyServerUpdateNotifier = class {
           break;
         case "pong":
           this.handlePong();
+          if (message.id !== void 0) {
+            const resolver = this._pendingRttPings.get(message.id);
+            if (resolver) {
+              this._pendingRttPings.delete(message.id);
+              resolver(message);
+            }
+          }
           break;
         case "error":
           console.error("[Ebus2ProxyNotifier] WebSocket server error:", message.error);

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

@@ -62,6 +62,13 @@ export declare class Ebus2ProxyServerUpdateNotifier implements I_ServerUpdateNot
     private pongTimer?;
     private forcedOffline;
     private subscribedChannels;
+    /**
+     * Pending RTT measurement promises keyed by ping id. Each entry is a
+     * resolver that the pong handler invokes once the matching pong
+     * arrives. Disconnect clears the map (caller's timeout fires soon
+     * after if any are still pending).
+     */
+    private _pendingRttPings;
     constructor(config: Ebus2ProxyServerUpdateNotifierConfig);
     subscribe(callback: ServerUpdateCallback): () => void;
     connect(): Promise<void>;
@@ -73,6 +80,36 @@ export declare class Ebus2ProxyServerUpdateNotifier implements I_ServerUpdateNot
      */
     dispose(): void;
     isConnected(): boolean;
+    /**
+     * WS round-trip time (client → proxy → client). Sends a tagged ping
+     * over the existing WebSocket and resolves with `performance.now()`
+     * delta when the matching pong arrives. Does NOT touch the cry-ebus2
+     * broker or any worker — measures pure proxy responsiveness +
+     * network latency.
+     *
+     * Throws if the WebSocket is not OPEN. The keepalive ping/pong
+     * watchdog is unaffected; multiple `measureWsRtt()` calls can be
+     * in flight simultaneously (each uses a unique correlation id).
+     *
+     * @param timeoutMs Max wait for matching pong (default: 5000)
+     * @returns RTT in milliseconds
+     */
+    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.
+     *
+     * The HTTP base URL is derived from `wsUrl` (`ws://` → `http://`,
+     * `wss://` → `https://`). Throws on HTTP error, payload mismatch,
+     * or timeout.
+     *
+     * @param timeoutMs Max wait for HTTP response (default: 5000)
+     * @returns RTT in milliseconds (full round-trip)
+     */
+    measureEndToEndRtt(timeoutMs?: number): Promise<number>;
     /**
      * Set connection lifecycle callbacks.
      * These are merged with any callbacks provided in the constructor config.

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

@@ -119,6 +119,9 @@ export declare class RestProxy implements I_RestInterface {
         timeoutMs?: number;
         signal?: AbortSignal;
         activityTimeoutMs?: number;
+        onRequestBytes?: (bytes: number) => void;
+        onTtfbMs?: (ms: number) => void;
+        onResponseChunkBytes?: (bytes: number) => void;
     }): Promise<void>;
     /**
      * Parse streaming response. Auto-detects format:

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

@@ -24,6 +24,7 @@ export declare class SyncedDb implements I_SyncedDb {
     private readonly wakeSync?;
     private readonly networkStatus?;
     private initialized;
+    private closed;
     private syncing;
     private syncLock;
     private wsUpdateQueue;
@@ -65,6 +66,18 @@ export declare class SyncedDb implements I_SyncedDb {
     isLeaderTab(): boolean;
     leaderSince(): Date | undefined;
     followerSince(): Date | undefined;
+    /**
+     * WS round-trip time (client → notifier server → client). Delegates
+     * to `serverUpdateNotifier.measureWsRtt`. Throws if no notifier is
+     * configured or the notifier implementation doesn't support RTT.
+     */
+    measureWsRtt(timeoutMs?: number): Promise<number>;
+    /**
+     * End-to-end RTT including downstream broker/worker hop. Delegates
+     * to `serverUpdateNotifier.measureEndToEndRtt`. Throws if no
+     * notifier is configured or the notifier doesn't support it.
+     */
+    measureEndToEndRtt(timeoutMs?: number): Promise<number>;
     /**
      * Register a collection for sync at runtime. See `I_SyncedDb.addCollectionToSync`.
      */

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

@@ -106,10 +106,26 @@ export interface I_RestInterface {
      * Streaming variant of findNewerMany. Calls onChunk for each batch of items as they arrive.
      * `specId` is forwarded as the third arg when the originating spec set one — `undefined` otherwise.
      * Old two-arg `onChunk` callbacks keep working unchanged (the third arg is ignored).
+     *
+     * Optional metric callbacks (all fire even on failure paths where applicable):
+     * - `onRequestBytes(bytes)` — fires once just before fetch with the
+     *   msgpack-encoded request body's byte length.
+     * - `onTtfbMs(ms)` — fires once when response headers are received,
+     *   with elapsed time since the fetch started. TTFB conflates
+     *   upload + server processing + first-byte travel — server-side
+     *   timing header (if available) is required to split further.
+     * - `onResponseChunkBytes(bytes)` — fires per response chunk read
+     *   with that chunk's byte length (summed = total response bytes).
+     *
+     * Combined, callers can compute upload/download throughput AND
+     * server-vs-network breakdown without extra round-trips.
      */
     findNewerManyStream<T>(spec: GetNewerSpec<T>[], onChunk: (collection: string, items: T[], specId?: string) => Promise<void>, options?: {
         timeoutMs?: number;
         signal?: AbortSignal;
+        onRequestBytes?: (bytes: number) => void;
+        onTtfbMs?: (ms: number) => void;
+        onResponseChunkBytes?: (bytes: number) => void;
     }): Promise<void>;
     deleteOne<T>(collection: string, query: QuerySpec<T>): Promise<T>;
     /** Izvede agregacijo na serverju */

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

@@ -54,4 +54,33 @@ export interface I_ServerUpdateNotifier {
      * Optional method.
      */
     dispose?(): void;
+    /**
+     * Measure round-trip time over the existing transport (e.g. WebSocket
+     * ping/pong). Returns RTT in milliseconds. Does NOT involve any
+     * downstream broker or worker — measures the client ↔ notifier
+     * server hop only.
+     *
+     * Useful for diagnosing connection quality. Compare with
+     * `measureEndToEndRtt` to isolate broker/worker overhead.
+     *
+     * Optional. Throws if transport is not connected or doesn't support
+     * RTT measurement.
+     *
+     * @param timeoutMs Max wait for response (default: 5000)
+     */
+    measureWsRtt?(timeoutMs?: number): Promise<number>;
+    /**
+     * Measure full round-trip time including any downstream broker /
+     * worker hop (e.g. ebus-proxy → cry-ebus2 broker → echo worker →
+     * back). Returns RTT in milliseconds.
+     *
+     * Implementation typically invokes a server-side `echo` service that
+     * returns the payload unchanged, so the measurement is end-to-end.
+     *
+     * Optional. Throws if not supported or if the round-trip fails
+     * (e.g. timeout, payload mismatch, transport error).
+     *
+     * @param timeoutMs Max wait for response (default: 5000)
+     */
+    measureEndToEndRtt?(timeoutMs?: number): Promise<number>;
 }

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

@@ -189,6 +189,27 @@ export interface FindNewerManyResultInfo {
     error?: Error;
     /** Where sync was called from (for debugging) */
     calledFrom?: string;
+    /**
+     * Msgpack-encoded request body size in bytes (upload payload).
+     * Undefined when the transport implementation didn't report it.
+     */
+    requestBytes?: number;
+    /**
+     * Sum of wire bytes received across all streaming chunks (download
+     * payload). For passive download-speed measurement compute
+     * `responseBytes / (durationMs - ttfbMs) * 1000` for bytes/sec
+     * (excludes server processing time).
+     * Undefined when the transport didn't report per-chunk byte counts.
+     */
+    responseBytes?: number;
+    /**
+     * Time-to-first-byte in ms — elapsed from request send until response
+     * headers are received. Conflates upload travel + server processing +
+     * first-byte travel. Together with `responseBytes` and `durationMs`
+     * enables passive throughput + server-vs-network breakdown estimates.
+     * Undefined when the transport didn't report it.
+     */
+    ttfbMs?: number;
 }
 /**
  * Callback payload for Dexie write requests (before writing)
@@ -1070,6 +1091,33 @@ export interface I_SyncedDb {
      * @returns Date of follower transition, or undefined if currently the leader
      */
     followerSince(): Date | undefined;
+    /**
+     * Measure WS round-trip time: client → notifier server → client.
+     * Pure proxy / network latency, without any downstream broker or
+     * worker hop. Pairs with `measureEndToEndRtt` for diagnostics:
+     * a low WS RTT + high end-to-end RTT points at the broker/worker
+     * as the bottleneck; a high WS RTT points at the network or proxy.
+     *
+     * Throws when no `serverUpdateNotifier` is configured or the
+     * notifier implementation does not support RTT measurement.
+     *
+     * @param timeoutMs Max wait for response (default: 5000)
+     * @returns RTT in milliseconds
+     */
+    measureWsRtt(timeoutMs?: number): Promise<number>;
+    /**
+     * Measure end-to-end RTT including the downstream broker/worker
+     * hop (e.g. ebus-proxy → cry-ebus2 broker → echo worker → back).
+     * The implementation typically calls a server-side `echo` service
+     * that returns the payload unchanged.
+     *
+     * Throws when no `serverUpdateNotifier` is configured or the
+     * notifier implementation does not support end-to-end RTT.
+     *
+     * @param timeoutMs Max wait for response (default: 5000)
+     * @returns RTT in milliseconds (full round-trip)
+     */
+    measureEndToEndRtt(timeoutMs?: number): Promise<number>;
     /**
      * 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.175",
+  "version": "0.1.177",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",