cry-synced-db-client 0.1.188 → 0.1.190

package/CHANGELOG.md

@@ -1,5 +1,110 @@
 # Versions
 
+## 0.1.190 (2026-05-15)
+
+### `addCollectionsToSync(specs[])` — batch register with single-RTT download
+
+Plural counterpart to `addCollectionToSync`. Per-spec semantics are
+identical (permanent existing = skip; temporary or absent = install),
+but the install work is decomposed into three phases optimized for
+batching:
+
+1. **Filter + register (sync)** — every survivor's
+   `this.collections.set()` and `syncOnlyTheseCollections` extension
+   happen up front, so a sync triggered mid-install already sees the
+   new collections.
+2. **Hydrate (parallel)** — Dexie cursor reads + in-mem hydrations
+   fan out via `Promise.allSettled`. Per-collection failure is logged
+   and isolated; the collection stays installed and hydrates on the
+   next sync tick.
+3. **Download (one RTT)** — every newly-installed non-`writeOnly`
+   spec is bundled into a **single `findNewerMany` request**, then
+   each result is fed through `processCollectionServerData` for
+   conflict resolution. **N collections = 1 RTT** of wall-clock time.
+
+```ts
+// Login flow: install a workspace's collections in one shot.
+await syncedDb.addCollectionsToSync([
+  { name: "obravnave", syncConfig: { query: () => ({ lokacija_id }) } },
+  { name: "zivali",    syncConfig: { query: () => ({ tenant }) } },
+  { name: "racuni",    syncConfig: { query: () => ({ leto }) } },
+  { name: "audit_log", writeOnly: true }, // installed but excluded from RTT
+]);
+// → 1 findNewerMany covering [obravnave, zivali, racuni].
+```
+
+Skipped specs (existing permanent) consume zero install work. No-op
+when `specs` is empty or every spec is skipped. Network failure on the
+batched download leaves collections registered; next auto-sync tick
+retries via the normal sync flow.
+
+Compared to looping `addCollectionToSync(spec)` per item:
+- N collections × per-collection RTT (sequential or `Promise.all`)
+  → 1 RTT for the whole batch.
+- Hydration also parallelized.
+- Compatible with `syncOnlyTheseCollections` filter (each addition
+  extends the active set).
+
+## 0.1.189 (2026-05-15)
+
+### Periodic full-resync maintenance heartbeat
+
+New `SyncedDbConfig` options that guarantee a full server re-read at a
+configurable cadence — useful when long-running tabs accumulate
+server-side state drift (eviction window misses, race-ridden
+tombstones, missed WS-push notifications while the tab was throttled).
+
+```ts
+new SyncedDb({
+  // ...
+  forceFullResyncIfOlderThanDays: 7,   // threshold (off when undefined)
+  forceFullResyncCheckEveryHrs: 24,    // continuous re-check (init-only when undefined)
+  onForceFullResyncTriggered: (info) => {
+    // info: { reason: "init" | "timer", lastFullSyncDate?, daysSinceLastFullSync?, thresholdDays, timestamp }
+    syslog.info("force-full-resync", info);
+  },
+});
+```
+
+**What it does** — when `lastSuccessfulServerSync()` is older than the
+threshold (checked once at `init()` + continuously every
+`forceFullResyncCheckEveryHrs`):
+
+1. `onForceFullResyncTriggered` fires (idempotent — flag-gated, no
+   re-fire if a previous trigger is still pending).
+2. Internal `_pendingFullResync` flag is set.
+3. If `canSync()`, fires `sync("force-full-resync:<reason>")`.
+4. The consuming sync slot resets **every** collection's
+   `syncMeta.lastSyncTs` (Dexie + cache) just before `syncEngine.sync`
+   runs. Server returns the full dataset.
+5. Conflict resolution overwrites local rows record-by-record as the
+   stream lands. Bundled eviction sweeps records the server no longer
+   reports.
+6. On success the flag is cleared. On failure (offline, server error,
+   abort) the flag persists; the next sync slot retries.
+
+**Safety guarantees** — `_dirty_changes` and Dexie main rows are
+**never deleted** by this flow. The trigger only mutates cursors;
+conflict resolution + eviction handle row updates and out-of-scope
+removal as part of normal sync. A failed resync leaves the local
+cache exactly as it was. There is no window where Dexie is empty
+and the server response hasn't yet landed — fundamentally different
+from the legacy `refreshDatabaseFromServer()` which wipes Dexie
+before re-downloading.
+
+Implementation notes:
+
+- The check (`_checkForceFullResyncThreshold`) is cheap (memory + Date
+  math). The continuous timer runs for the SyncedDb's lifetime
+  (`init() → close()`); ticks during an in-flight sync no-op via
+  `syncLock`. The flag is boolean — multiple triggers between sync
+  slots collapse to one.
+- Records with `_lastFullSyncDate === undefined` (never synced) are
+  NOT considered stale — initial sync handles those.
+- Subset mode (`syncOnlyCollections !== null`) never sets
+  `__lastFullSync`, so the trigger never fires in that mode.
+- `dropDatabase()` clears `__lastFullSync`, restoring "never synced".
+
 ## 0.1.188 (2026-05-15)
 
 ### `clearDirty()` — manual dirty drain + `onBeforeDirtyClearAll` callback

package/dist/index.js

@@ -4456,6 +4456,7 @@ var _SyncedDb = class _SyncedDb {
     this.syncOnlyCollections = null;
     // Sync metadata cache
     this.syncMetaCache = /* @__PURE__ */ new Map();
+    this._pendingFullResync = false;
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
     this.tenant = config.tenant;
     this.dexieDb = config.dexieDb;
@@ -4485,6 +4486,9 @@ var _SyncedDb = class _SyncedDb {
     this.onSaveIdMismatch = config.onSaveIdMismatch;
     this.onUploadSkip = config.onUploadSkip;
     this.onBeforeDirtyClearAll = config.onBeforeDirtyClearAll;
+    this.forceFullResyncIfOlderThanDays = config.forceFullResyncIfOlderThanDays;
+    this.forceFullResyncCheckEveryHrs = config.forceFullResyncCheckEveryHrs;
+    this.onForceFullResyncTriggered = config.onForceFullResyncTriggered;
     this.evictStaleRecordsEveryHrs = (_e = config.evictStaleRecordsEveryHrs) != null ? _e : 0;
     this.scopeExitLookbehindMs = (_f = config.scopeExitLookbehindMs) != null ? _f : 0;
     this.evictOnWake = (_g = config.evictOnWake) != null ? _g : false;
@@ -4766,6 +4770,99 @@ var _SyncedDb = class _SyncedDb {
     }
     await this._installCollectionConfig(spec);
   }
+  /**
+   * Batch register. See `I_SyncedDb.addCollectionsToSync`.
+   *
+   * The work decomposes into three phases:
+   *
+   *   1. Filter + synchronously seed `this.collections` and the
+   *      `syncOnlyCollections` filter so any concurrent sync triggered
+   *      mid-install already sees the new collections.
+   *   2. Parallel Dexie cursor load + in-mem hydration.
+   *   3. Parallel per-collection one-shot download.
+   *
+   * Per-spec errors in phase 2/3 are isolated via `Promise.allSettled`:
+   * one collection's hydration / download failure does not block the
+   * others. Failures are logged and the spec is left installed (its
+   * cache will hydrate on the next sync tick).
+   */
+  async addCollectionsToSync(specs) {
+    var _a;
+    if (specs.length === 0) return;
+    const toInstall = [];
+    for (const spec of specs) {
+      const existing = this.collections.get(spec.name);
+      if (existing && !existing.temporaryConfig) continue;
+      this.collections.set(spec.name, spec);
+      if (this.syncOnlyCollections) {
+        this.syncOnlyCollections.add(spec.name);
+      }
+      toInstall.push(spec);
+    }
+    if (toInstall.length === 0) return;
+    const hydrationResults = await Promise.allSettled(
+      toInstall.map(async (spec) => {
+        const meta = await this.dexieDb.getSyncMeta(spec.name);
+        if (meta) this.syncMetaCache.set(spec.name, meta);
+        if (!spec.writeOnly) {
+          await this.loadCollectionToInMem(spec.name);
+        }
+      })
+    );
+    for (let i = 0; i < hydrationResults.length; i++) {
+      const r = hydrationResults[i];
+      if (r.status === "rejected") {
+        console.error(
+          `[SyncedDb] addCollectionsToSync: hydration failed for "${toInstall[i].name}":`,
+          r.reason
+        );
+      }
+    }
+    if (!this.connectionManager.canSync()) return;
+    const downloadable = toInstall.filter((s) => !s.writeOnly);
+    if (downloadable.length === 0) return;
+    const plans = [];
+    const fetchSpecs = [];
+    for (const spec of downloadable) {
+      const rawQuery = (_a = spec.syncConfig) == null ? void 0 : _a.query;
+      const query = typeof rawQuery === "function" ? rawQuery() : rawQuery;
+      const meta = this.syncMetaCache.get(spec.name);
+      const timestamp = (meta == null ? void 0 : meta.lastSyncTs) || 0;
+      plans.push({ spec, wasFirstTime: !timestamp });
+      fetchSpecs.push({
+        collection: spec.name,
+        timestamp,
+        query,
+        opts: { returnDeleted: true }
+      });
+    }
+    let results;
+    try {
+      results = await this.connectionManager.withRestTimeout(
+        this.restInterface.findNewerMany(fetchSpecs),
+        "addCollectionsToSync"
+      );
+    } catch (err) {
+      console.error(
+        `[SyncedDb] addCollectionsToSync: batched findNewerMany failed:`,
+        err
+      );
+      return;
+    }
+    for (const plan of plans) {
+      const data = results[plan.spec.name];
+      if (!data || data.length === 0) continue;
+      const source = plan.wasFirstTime ? "initial" : "incremental";
+      try {
+        await this.syncEngine.processCollectionServerData(plan.spec.name, data, { source });
+      } catch (err) {
+        console.error(
+          `[SyncedDb] addCollectionsToSync: processCollectionServerData failed for "${plan.spec.name}":`,
+          err
+        );
+      }
+    }
+  }
   /**
    * Replace the collection config and re-sync. See `I_SyncedDb.replaceSyncCollection`.
    */
@@ -4925,6 +5022,8 @@ var _SyncedDb = class _SyncedDb {
       };
       document.addEventListener("visibilitychange", this.visibilityFlushHandler);
     }
+    this._checkForceFullResyncThreshold("init");
+    this._startForceResyncCheckTimer();
     this.initialized = true;
   }
   /**
@@ -5004,6 +5103,73 @@ var _SyncedDb = class _SyncedDb {
       this._lastInitialSyncDate = new Date(meta.lastSyncTs);
     }
   }
+  /**
+   * Trip the `_pendingFullResync` flag iff `_lastFullSyncDate` is older
+   * than `forceFullResyncIfOlderThanDays`. Fires `onForceFullResyncTriggered`
+   * exactly once per trigger event (idempotent — repeated calls while the
+   * flag is already set are a no-op). Attempts to kick off a sync
+   * immediately if `canSync()`; otherwise the flag waits for the next
+   * online sync slot (auto-sync timer, reconnect, manual `sync()`, …).
+   *
+   * Never deletes Dexie data; the actual cursor reset happens inside
+   * `sync()` just before `syncEngine.sync()` runs (see `_resetSyncCursors`).
+   */
+  _checkForceFullResyncThreshold(reason) {
+    if (this._pendingFullResync) return;
+    const days = this.forceFullResyncIfOlderThanDays;
+    if (!days || days <= 0) return;
+    const last = this._lastFullSyncDate;
+    if (!last) return;
+    const ageMs = Date.now() - last.getTime();
+    const ageDays = ageMs / 864e5;
+    if (ageDays < days) return;
+    this._pendingFullResync = true;
+    this.safeCallback(this.onForceFullResyncTriggered, {
+      reason,
+      lastFullSyncDate: last,
+      daysSinceLastFullSync: ageDays,
+      thresholdDays: days,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    if (this.connectionManager.canSync()) {
+      this.sync(`force-full-resync:${reason}`).catch((err) => {
+        console.error(`[SyncedDb] force full resync sync() failed: ${err}`, err);
+      });
+    }
+  }
+  _startForceResyncCheckTimer() {
+    const hrs = this.forceFullResyncCheckEveryHrs;
+    if (!hrs || hrs <= 0) return;
+    this._forceResyncCheckTimer = setInterval(() => {
+      this._checkForceFullResyncThreshold("timer");
+    }, hrs * 36e5);
+  }
+  /**
+   * Cursor-reset path for the force-full-resync flow. Resets every
+   * collection's `syncMeta.lastSyncTs` to undefined (Dexie + cache) so
+   * the next `syncEngine.sync` call fetches from the beginning. Does
+   * NOT delete Dexie main rows, in-mem rows, or `_dirty_changes`.
+   * Conflict resolution + eviction (handled by the normal sync flow)
+   * sweep what needs sweeping AFTER the server response arrives — so
+   * a failed sync leaves local data intact.
+   *
+   * Per-collection deleteSyncMeta failures are logged and tolerated
+   * (cache is cleared unconditionally → in-memory effect is fully
+   * reset even if some Dexie rows lingered).
+   */
+  async _resetSyncCursors() {
+    for (const [name] of this.collections) {
+      try {
+        await this.dexieDb.deleteSyncMeta(name);
+      } catch (err) {
+        console.error(
+          `[SyncedDb] _resetSyncCursors: deleteSyncMeta(${name}) failed: ${err}`,
+          err
+        );
+      }
+    }
+    this.syncMetaCache.clear();
+  }
   async close() {
     var _a, _b;
     if (this.closed) return;
@@ -5011,6 +5177,10 @@ var _SyncedDb = class _SyncedDb {
     this.leaderElection.setClosing(true);
     this.pendingChanges.cancelRestUploadTimer();
     this.connectionManager.stopTimers();
+    if (this._forceResyncCheckTimer) {
+      clearInterval(this._forceResyncCheckTimer);
+      this._forceResyncCheckTimer = void 0;
+    }
     await this.pendingChanges.flushAll();
     (_a = this.networkStatus) == null ? void 0 : _a.dispose();
     (_b = this.wakeSync) == null ? void 0 : _b.dispose();
@@ -5634,6 +5804,10 @@ var _SyncedDb = class _SyncedDb {
           this._applyScopeExitChunkToPlan(evictionPlan, specId, items);
         }
       } : void 0;
+      const consumingPendingFullResync = this._pendingFullResync;
+      if (consumingPendingFullResync) {
+        await this._resetSyncCursors();
+      }
       try {
         await this.syncEngine.sync(calledFrom, evictionExtras);
         if (!this.syncOnlyCollections) {
@@ -5646,6 +5820,7 @@ var _SyncedDb = class _SyncedDb {
           this._setLastFullSync(now).catch((err) => {
             console.error(`[SyncedDb] Failed to persist lastFullSync: ${err}`, err);
           });
+          if (consumingPendingFullResync) this._pendingFullResync = false;
         }
       } catch (err) {
         if (evictionExtras) evictionServerFailed = true;

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

@@ -57,6 +57,11 @@ export declare class SyncedDb implements I_SyncedDb {
     private readonly onSaveIdMismatch?;
     private readonly onUploadSkip?;
     private readonly onBeforeDirtyClearAll?;
+    private readonly forceFullResyncIfOlderThanDays?;
+    private readonly forceFullResyncCheckEveryHrs?;
+    private readonly onForceFullResyncTriggered?;
+    private _pendingFullResync;
+    private _forceResyncCheckTimer?;
     private readonly evictStaleRecordsEveryHrs;
     private readonly scopeExitLookbehindMs;
     private readonly evictOnWake;
@@ -95,6 +100,23 @@ export declare class SyncedDb implements I_SyncedDb {
      * Register a collection for sync at runtime. See `I_SyncedDb.addCollectionToSync`.
      */
     addCollectionToSync(spec: CollectionConfig): Promise<void>;
+    /**
+     * Batch register. See `I_SyncedDb.addCollectionsToSync`.
+     *
+     * The work decomposes into three phases:
+     *
+     *   1. Filter + synchronously seed `this.collections` and the
+     *      `syncOnlyCollections` filter so any concurrent sync triggered
+     *      mid-install already sees the new collections.
+     *   2. Parallel Dexie cursor load + in-mem hydration.
+     *   3. Parallel per-collection one-shot download.
+     *
+     * Per-spec errors in phase 2/3 are isolated via `Promise.allSettled`:
+     * one collection's hydration / download failure does not block the
+     * others. Failures are logged and the spec is left installed (its
+     * cache will hydrate on the next sync tick).
+     */
+    addCollectionsToSync(specs: CollectionConfig[]): Promise<void>;
     /**
      * Replace the collection config and re-sync. See `I_SyncedDb.replaceSyncCollection`.
      */
@@ -168,6 +190,33 @@ export declare class SyncedDb implements I_SyncedDb {
     _setLastInitialSync(date: Date): Promise<void>;
     /** @internal Load cached value from Dexie */
     private _loadLastInitialSync;
+    /**
+     * Trip the `_pendingFullResync` flag iff `_lastFullSyncDate` is older
+     * than `forceFullResyncIfOlderThanDays`. Fires `onForceFullResyncTriggered`
+     * exactly once per trigger event (idempotent — repeated calls while the
+     * flag is already set are a no-op). Attempts to kick off a sync
+     * immediately if `canSync()`; otherwise the flag waits for the next
+     * online sync slot (auto-sync timer, reconnect, manual `sync()`, …).
+     *
+     * Never deletes Dexie data; the actual cursor reset happens inside
+     * `sync()` just before `syncEngine.sync()` runs (see `_resetSyncCursors`).
+     */
+    private _checkForceFullResyncThreshold;
+    private _startForceResyncCheckTimer;
+    /**
+     * Cursor-reset path for the force-full-resync flow. Resets every
+     * collection's `syncMeta.lastSyncTs` to undefined (Dexie + cache) so
+     * the next `syncEngine.sync` call fetches from the beginning. Does
+     * NOT delete Dexie main rows, in-mem rows, or `_dirty_changes`.
+     * Conflict resolution + eviction (handled by the normal sync flow)
+     * sweep what needs sweeping AFTER the server response arrives — so
+     * a failed sync leaves local data intact.
+     *
+     * Per-collection deleteSyncMeta failures are logged and tolerated
+     * (cache is cleared unconditionally → in-memory effect is fully
+     * reset even if some Dexie rows lingered).
+     */
+    private _resetSyncCursors;
     close(): Promise<void>;
     isOnline(): boolean;
     forceOffline(forced: boolean): void;

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

@@ -113,6 +113,34 @@ export interface BeforeDirtyClearAllInfo {
     /** Timestamp when the callback fires. */
     timestamp: Date;
 }
+/**
+ * Callback payload fired when the `forceFullResyncIfOlderThanDays`
+ * threshold trips — either on `init()` (`reason: "init"`) or on a
+ * `forceFullResyncCheckEveryHrs` timer tick (`reason: "timer"`).
+ *
+ * Fires BEFORE the cursor reset / sync. Use for telemetry, syslog,
+ * UI ("refreshing your data…"), or to gate UX during the resync.
+ *
+ * The trigger sets an internal `_pendingFullResync` flag and tries to
+ * initiate a sync immediately. If offline or `forcedOffline`, the
+ * flag persists in memory; the next online sync slot consumes it.
+ * On sync failure, the flag persists and the next slot retries.
+ * Dexie data is NEVER deleted as part of this flow — only cursors
+ * are reset; conflict resolution overwrites local rows record-by-
+ * record as the server response streams in.
+ */
+export interface ForceFullResyncInfo {
+    /** What triggered the resync check. */
+    reason: "init" | "timer";
+    /** Last successful full sync timestamp; undefined if never synced. */
+    lastFullSyncDate?: Date;
+    /** Age of last full sync in days; undefined if never synced. */
+    daysSinceLastFullSync?: number;
+    /** Configured threshold (`forceFullResyncIfOlderThanDays`) in days. */
+    thresholdDays: number;
+    /** Wall-clock at trigger time. */
+    timestamp: Date;
+}
 /**
  * Callback payload for server write requests (before sending)
  */
@@ -682,6 +710,60 @@ export interface SyncedDbConfig {
      * don't fire this callback.
      */
     onBeforeDirtyClearAll?: (info: BeforeDirtyClearAllInfo) => void;
+    /**
+     * Periodic full-resync maintenance heartbeat.
+     *
+     * If `lastSuccessfulServerSync()` is older than this many days, the
+     * library schedules a **safe full resync**:
+     *
+     *   1. Reset every collection's `syncMeta.lastSyncTs` to 0 (Dexie + cache).
+     *   2. Run `sync()` — cursors at 0 force the server to return everything.
+     *   3. Each record applied via normal conflict resolution; eviction
+     *      sweeps records the server no longer reports.
+     *
+     * Dexie main rows and `_dirty_changes` are **never deleted**. If the
+     * resync fails (offline, server error, timeout, tab closed), the
+     * local cache stays exactly as it was; cursors remain at 0 so the
+     * next online sync retries.
+     *
+     * Checked at `init()` (once, after Dexie sync metas have loaded) and
+     * on each `forceFullResyncCheckEveryHrs` timer tick. Records with
+     * `_lastFullSyncDate === undefined` (never synced) are NOT considered
+     * stale — the normal initial sync handles them.
+     *
+     * Default: `undefined` (disabled). Set to a positive integer to enable.
+     *
+     * @see forceFullResyncCheckEveryHrs for the timer interval.
+     * @see onForceFullResyncTriggered for the telemetry hook.
+     */
+    forceFullResyncIfOlderThanDays?: number;
+    /**
+     * Continuous timer interval (in hours) that re-checks the
+     * `forceFullResyncIfOlderThanDays` threshold. The timer keeps running
+     * for the lifetime of the SyncedDb (`init()` → `close()`) and never
+     * self-disables — every tick is a cheap memory + Date math check.
+     *
+     * Set to `undefined` (default) to only check at `init()`. Set to e.g.
+     * `24` to check every 24h. Independent of
+     * `forceFullResyncIfOlderThanDays`: the timer fires regardless, but
+     * does nothing if the threshold is unset or not exceeded.
+     *
+     * Multiple triggers between sync attempts are idempotent (the flag is
+     * boolean). A timer tick during an in-flight sync no-ops; the next
+     * sync slot picks up the pending flag.
+     */
+    forceFullResyncCheckEveryHrs?: number;
+    /**
+     * Fires when `forceFullResyncIfOlderThanDays` trips — BEFORE the
+     * cursor reset and sync. Use for telemetry / syslog / UI banners
+     * ("refreshing your data…").
+     *
+     * Fires at most once per trigger event. Even if the trigger sets the
+     * flag while a previous trigger's flag is still pending, this
+     * callback does NOT re-fire — the `_pendingFullResync` flag is
+     * boolean.
+     */
+    onForceFullResyncTriggered?: (info: ForceFullResyncInfo) => void;
     /**
      * Enable in-memory object metadata feature.
      * When true, collections with hasMetadata=true will have their metadata callbacks invoked
@@ -861,6 +943,34 @@ export interface I_SyncedDb {
      * @param spec Collection config to register
      */
     addCollectionToSync(spec: CollectionConfig): Promise<void>;
+    /**
+     * Batch variant of `addCollectionToSync`. Semantics are identical
+     * per-spec (permanent existing: no-op; temporary or absent: install).
+     *
+     * Three-phase install:
+     *
+     *  1. **Filter + register (sync)** — `this.collections.set()` and
+     *     `syncOnlyTheseCollections` extensions happen up front so any
+     *     concurrent sync triggered mid-install already sees the new
+     *     collections.
+     *  2. **Hydrate (parallel)** — Dexie cursor reads + in-mem
+     *     hydrations run via `Promise.allSettled`. Per-collection
+     *     failures are logged and isolated; the collection stays
+     *     installed and hydrates on the next sync tick.
+     *  3. **Download (one RTT)** — every newly-installed non-writeOnly
+     *     collection is bundled into a SINGLE `findNewerMany` request,
+     *     then each result is fed through `processCollectionServerData`
+     *     for conflict resolution. N collections cost 1 RTT total
+     *     instead of N parallel RTTs.
+     *
+     * Skipped specs (existing permanent) consume no install work. No-op
+     * when `specs` is empty or every spec is a no-op. Network failure on
+     * the batched download leaves the collections installed; the next
+     * auto-sync tick retries via the normal sync flow.
+     *
+     * @param specs Array of collection configs to register
+     */
+    addCollectionsToSync(specs: CollectionConfig[]): Promise<void>;
     /**
      * Replace the collection config and re-sync.
      *

package/package.json

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