cry-synced-db-client 0.1.141 → 0.1.144

package/CHANGELOG.md

@@ -2,6 +2,70 @@
 
 ## Unreleased
 
+### Fix: filtered-sync tombstone (scope-exit from other writers)
+
+When a collection has `syncConfig.query` (e.g. `{ status: { $ne: "obsolete" } }`)
+and another device mutates a record out of scope while this client is offline,
+the filtered delta feed (`findNewer` with the positive query) never returns the
+mutated record — the server filters it out. The local copy stayed stale
+indefinitely, even across reloads and full re-syncs (positive query still
+excludes it).
+
+`evictOutOfScopeRecords` now runs a second, server-assisted pass that fires the
+**negated** query `{ $and: [{ $nor: [syncConfig.query] }, { _id: { $in: knownIds } }] }`
+against the server (scoped by local IDs for both bandwidth and authz) and
+evicts any returned records locally. Purely client-side — no server protocol
+change. Sound only when `syncConfig.query` is the complete server-side
+predicate (no implicit server policy).
+
+- New `opts.serverAssisted` parameter on `evictOutOfScopeRecords(collection, opts?)`.
+  Defaults to `true` when online and not `writeOnly`. Set `false` for pure
+  local pass (previous behavior).
+- New `opts.outOfWindowLookbehindMs` parameter restricts the server-assisted
+  query to records changed in the last N ms (translates to `findNewer`'s
+  seconds-resolution timestamp filter). When unspecified, the scope-exit
+  scan uses the collection's current `meta.lastSyncTs` — the same cursor
+  `sync()` passes to `findNewer`, so it covers the same window as a delta
+  sync. Pass `Date.now()` to scan full history. Note: when eviction runs
+  post-sync, `lastSyncTs` has advanced past the window sync just covered;
+  set a lookbehind to re-scan that window.
+- Dirty records are still preserved across the combined eviction.
+- Auto-eviction (`evictStaleRecordsEveryHrs`) picks up the new behavior
+  transparently — no config change needed.
+- `matchesQuery` (`src/utils/localQuery.ts`) gained top-level `$and`, `$or`,
+  `$nor` support, required for the negated query to evaluate against the test
+  mock and for any client-side filtering that uses logical operators.
+
+### `getDirtyMeta()` for lightweight dirty-state inspection
+
+- New `SyncedDb.getDirtyMeta()` returns dirty-entry meta (everything except the
+  `changes` payload) grouped per collection, only for collections with ≥1 dirty
+  record. Mirrors `getDirty()` shape but avoids loading change payloads —
+  useful for counts, timestamps, and indicator UIs.
+- New `I_DexieDb.getDirtyMeta(collection)` returning `DirtyMeta[]`.
+- New exported `DirtyMeta` type (`Omit<DirtyChange, "changes">`) and
+  `DirtyChange` type surfaced from the package entry.
+
+### Fix: multi-tab divergence when offline edits cross leader/follower
+
+Fixes a bug where, after both tabs edited different records offline and came
+online with leader-first, the leader ended up with stale record content
+carrying the new server `_rev`. Because `resolveConflict` ignores server
+echoes with equal-or-lower `_rev`, the divergence was permanent until page
+reload. Follower-first came out clean; leader-first did not.
+
+Two contributing causes, both fixed:
+
+- `SyncEngine` post-upload in-mem patch no longer spreads stale `getInMemById`
+  result over server-returned `_rev`/`_ts`. In-mem is now fed the freshly
+  patched Dexie item (authoritative content + server meta), so the tab that
+  uploaded on behalf of another tab's dirty write ends up with matching
+  content and `_rev` in-mem.
+- `CrossTabSyncManager.broadcastMetaUpdate` no longer gated by `isLeader()`.
+  Non-leader tabs now broadcast their local writes so the leader's in-mem
+  cache learns of them via the existing shared-Dexie reload path. Reload
+  broadcasts (post-full-sync) remain leader-only.
+
 ### BREAKING: Self-healing sync/reconnect lifecycle
 
 Fixes a class of bugs where the 60s auto-sync scheduler silently died after a

package/dist/index.js

@@ -39,6 +39,27 @@ import { ObjectId as ObjectId2 } from "bson";
 // src/utils/localQuery.ts
 function matchesQuery(item, query) {
   for (const [key, condition] of Object.entries(query)) {
+    if (key === "$and") {
+      if (!Array.isArray(condition)) return false;
+      if (!condition.every((sub) => matchesQuery(item, sub))) {
+        return false;
+      }
+      continue;
+    }
+    if (key === "$or") {
+      if (!Array.isArray(condition) || condition.length === 0) return false;
+      if (!condition.some((sub) => matchesQuery(item, sub))) {
+        return false;
+      }
+      continue;
+    }
+    if (key === "$nor") {
+      if (!Array.isArray(condition) || condition.length === 0) return false;
+      if (condition.some((sub) => matchesQuery(item, sub))) {
+        return false;
+      }
+      continue;
+    }
     if (!matchesCondition(item, key, condition)) {
       return false;
     }
@@ -634,13 +655,14 @@ var CrossTabSyncManager = class {
   }
   /**
    * Broadcast updated IDs to other tabs (debounced).
-   * Only the leader should broadcast.
+   * Any tab with local writes broadcasts so other tabs refresh their in-mem
+   * from shared Dexie. Otherwise non-leader writes stay invisible to the leader's
+   * in-mem cache, and a later upload patches new _rev onto stale content.
    * While a server sync is in progress, suppresses delta broadcasts and only
    * records which collections were affected (for the post-sync reload broadcast).
    */
   broadcastMetaUpdate(updates) {
     if (!this.metaUpdateChannel) return;
-    if (!this.deps.isLeader()) return;
     if (this.serverSyncInProgress) {
       for (const collection of Object.keys(updates)) {
         this.syncAffectedCollections.add(collection);
@@ -2668,13 +2690,7 @@ var _SyncEngine = class _SyncEngine {
                 dexieDeleteIds.push(entity._id);
               } else {
                 dexieSaveBatch.push(dexieItem);
-                const inMemItem = this.deps.getInMemById(collection, entity._id);
-                if (inMemItem) {
-                  inMemUpdateBatch.push(__spreadProps(__spreadValues({}, inMemItem), {
-                    _rev: entity._rev,
-                    _ts: entity._ts
-                  }));
-                }
+                inMemUpdateBatch.push(dexieItem);
               }
             }
           }
@@ -4550,6 +4566,16 @@ var _SyncedDb = class _SyncedDb {
     }
     return result;
   }
+  async getDirtyMeta() {
+    const result = {};
+    for (const [collectionName] of this.collections) {
+      const metas = await this.dexieDb.getDirtyMeta(collectionName);
+      if (metas.length > 0) {
+        result[collectionName] = metas;
+      }
+    }
+    return result;
+  }
   // ==================== Data Deletion ====================
   async dropCollection(collection, force = false) {
     this.assertCollection(collection);
@@ -4657,9 +4683,42 @@ var _SyncedDb = class _SyncedDb {
    * Remove records from Dexie and in-mem that no longer match the
    * collection's current syncConfig.query. Does NOT delete from server.
    * Skips records with dirty changes (pending local writes).
+   *
+   * Runs two passes:
+   * 1. Local: evicts items whose locally-cached state fails the query.
+   *    Covers self-inflicted scope exits (the client moved an item out).
+   * 2. Server-assisted (default when online and not writeOnly): of the
+   *    items that still match locally, ask the server which now fail the
+   *    query server-side. Covers scope exits caused by other writers — the
+   *    filtered delta feed (`findNewer` with the positive query) never
+   *    ships those records, so the local cache would otherwise go stale
+   *    forever.
+   *
+   * The server-assisted query is `{ $and: [{ $nor: [query] }, { _id: { $in: chunk } }] }`
+   * with `project: { _id: 1 }`. Scoped to known IDs to preserve both
+   * bandwidth and authorization (server only reveals state of IDs the
+   * client already knew about). Sound only if `syncConfig.query` is the
+   * complete server-side predicate (no implicit server policy).
+   *
+   * @param opts.serverAssisted - Override auto-detection. Default: `true`
+   *   when online and not writeOnly. Set `false` for pure local eviction.
+   * @param opts.outOfWindowLookbehindMs - Restrict the server-assisted
+   *   query to records changed in the last N ms (adds `_ts > now-N` via
+   *   `findNewer`'s timestamp filter). When unspecified, the collection's
+   *   current `meta.lastSyncTs` is used — the same cursor `sync()` passes
+   *   to `findNewer`, so scope-exit scan covers the same time window as a
+   *   regular delta sync. Pass `Date.now()` (or any value larger than
+   *   elapsed time) to scan full history.
+   *
+   *   Note on post-sync timing: when this method runs AFTER `sync()`
+   *   (including via auto-eviction), `lastSyncTs` has already advanced
+   *   past the window sync just covered, so a record whose scope-exit
+   *   mutation landed in that window will not be re-examined on this
+   *   pass. Specify `outOfWindowLookbehindMs` (e.g., to cover since last
+   *   eviction) or call this before `sync()` to close that gap.
    */
-  async evictOutOfScopeRecords(collection) {
-    var _a;
+  async evictOutOfScopeRecords(collection, opts) {
+    var _a, _b, _c, _d;
     this.assertCollection(collection);
     const config = this.collections.get(collection);
     const syncQuery = (_a = config.syncConfig) == null ? void 0 : _a.query;
@@ -4670,9 +4729,11 @@ var _SyncedDb = class _SyncedDb {
     await this.pendingChanges.flushForCollection(collection);
     const dirtyItems = await this.dexieDb.getDirty(collection);
     const dirtyIds = new Set(dirtyItems.map((d) => String(d._id)));
+    const serverAssisted = (_b = opts == null ? void 0 : opts.serverAssisted) != null ? _b : !config.writeOnly && this.connectionManager.isOnline();
     let scannedCount = 0;
     let dirtySkipped = 0;
     const evictIds = [];
+    const serverCandidateIds = [];
     await this.dexieDb.forEachBatch(
       collection,
       2e3,
@@ -4686,10 +4747,38 @@ var _SyncedDb = class _SyncedDb {
           }
           if (!matchesQuery(item, query)) {
             evictIds.push(id);
+          } else if (serverAssisted) {
+            serverCandidateIds.push(id);
           }
         }
       }
     );
+    if (serverAssisted && serverCandidateIds.length > 0) {
+      let scopeExitTimestamp;
+      const lookbehindMs = opts == null ? void 0 : opts.outOfWindowLookbehindMs;
+      if (lookbehindMs != null && lookbehindMs > 0) {
+        scopeExitTimestamp = Math.max(
+          0,
+          Math.floor((Date.now() - lookbehindMs) / 1e3)
+        );
+      } else {
+        scopeExitTimestamp = (_d = (_c = this.syncMetaCache.get(collection)) == null ? void 0 : _c.lastSyncTs) != null ? _d : 0;
+      }
+      try {
+        const serverExits = await this.findServerSideScopeExits(
+          collection,
+          query,
+          serverCandidateIds,
+          scopeExitTimestamp
+        );
+        for (const id of serverExits) evictIds.push(id);
+      } catch (err) {
+        console.error(
+          `[evict] server-assisted pass failed for ${collection} (proceeding with local-only):`,
+          err
+        );
+      }
+    }
     if (evictIds.length > 0) {
       await this.dexieDb.deleteMany(collection, evictIds);
       if (!config.writeOnly) {
@@ -4703,6 +4792,49 @@ var _SyncedDb = class _SyncedDb {
     }
     return { collection, evictedCount: evictIds.length, dirtySkipped, scannedCount };
   }
+  /**
+   * Ask the server which of the given IDs no longer match the positive
+   * query server-side. Used by `evictOutOfScopeRecords` server-assisted
+   * pass to close the "filtered-delta tombstone" gap — records mutated
+   * out of scope by other writers that the filtered delta feed would
+   * never report.
+   *
+   * Chunks `candidateIds` into `$in`-sized batches to keep the request
+   * payload bounded. Uses `project: { _id: 1 }` to keep the response
+   * payload minimal.
+   *
+   * @param timestamp - `findNewer` timestamp cursor. Only records with
+   *   `_ts > timestamp` are examined. Caller decides the window (usually
+   *   the collection's `meta.lastSyncTs` to mirror the positive sync's
+   *   cursor, or a lookbehind-derived value for shorter windows).
+   * @returns IDs the server reports as out-of-scope (i.e. matching
+   *   `NOT query`). These are candidates for local-only eviction.
+   */
+  async findServerSideScopeExits(collection, positiveQuery, candidateIds, timestamp) {
+    const CHUNK_SIZE = 500;
+    const scopeExits = [];
+    const negated = { $nor: [positiveQuery] };
+    for (let i = 0; i < candidateIds.length; i += CHUNK_SIZE) {
+      const chunk = candidateIds.slice(i, i + CHUNK_SIZE);
+      const scopedNegation = {
+        $and: [negated, { _id: { $in: chunk } }]
+      };
+      const results = await this.connectionManager.withRestTimeout(
+        this.restInterface.findNewer(
+          collection,
+          timestamp,
+          scopedNegation,
+          { project: { _id: 1 } }
+        ),
+        "evictOutOfScopeRecords.serverAssisted"
+      );
+      for (const item of results) {
+        const id = item._id;
+        if (id !== void 0) scopeExits.push(String(id));
+      }
+    }
+    return scopeExits;
+  }
   /**
    * Evict out-of-scope records for all collections.
    * Skips writeOnly and collections without syncConfig.query.
@@ -5170,6 +5302,21 @@ var DexieDb = class extends Dexie {
     }
     return result;
   }
+  async getDirtyMeta(collection) {
+    const dirtyEntries = await this.dirtyChanges.where("[collection+id]").between([collection, Dexie.minKey], [collection, Dexie.maxKey]).toArray();
+    const result = [];
+    for (const entry of dirtyEntries) {
+      result.push({
+        collection: entry.collection,
+        id: entry.id,
+        baseTs: entry.baseTs,
+        baseRev: entry.baseRev,
+        createdAt: entry.createdAt,
+        updatedAt: entry.updatedAt
+      });
+    }
+    return result;
+  }
   async addDirtyChange(collection, id, changes, baseMeta) {
     const stringId = this.idToString(id);
     const existing = await this.dirtyChanges.get([collection, stringId]);

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

@@ -1,5 +1,5 @@
 import Dexie from "dexie";
-import type { DirtyChange, I_DexieDb, SyncMeta } from "../types/I_DexieDb";
+import type { DirtyChange, DirtyMeta, I_DexieDb, SyncMeta } from "../types/I_DexieDb";
 import type { CollectionConfig } from "../types/CollectionConfig";
 import type { Id, LocalDbEntity } from "../types/DbEntity";
 /**
@@ -31,6 +31,7 @@ export declare class DexieDb extends Dexie implements I_DexieDb {
     forEachBatch<T extends LocalDbEntity>(collection: string, batchSize: number, callback: (items: T[]) => Promise<void>): Promise<void>;
     count(collection: string): Promise<number>;
     getDirty<T extends LocalDbEntity>(collection: string): Promise<Partial<T>[]>;
+    getDirtyMeta(collection: string): Promise<DirtyMeta[]>;
     addDirtyChange(collection: string, id: Id, changes: Record<string, any>, baseMeta?: {
         _ts?: any;
         _rev?: number;

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

@@ -1,6 +1,6 @@
 import type { AggregateOptions } from "mongodb";
 import type { I_SyncedDb, SyncedDbConfig, WsNotificationInfo, EvictionInfo, EvictionCollectionInfo } from "../types/I_SyncedDb";
-import type { MetaUpdateBroadcast } from "../types/I_DexieDb";
+import type { DirtyMeta, MetaUpdateBroadcast } from "../types/I_DexieDb";
 import type { QuerySpec, QueryOpts, UpdateSpec, InsertSpec, BatchSpec } from "../types/I_RestInterface";
 import type { Id, DbEntity } from "../types/DbEntity";
 /**
@@ -161,6 +161,7 @@ export declare class SyncedDb implements I_SyncedDb {
     getOnWsNotification(): ((info: WsNotificationInfo) => void) | undefined;
     getOnWakeSync(): ((info: import("./types/managers").WakeSyncInfo) => void) | undefined;
     getDirty<T extends DbEntity>(): Promise<Readonly<Record<string, readonly T[]>>>;
+    getDirtyMeta(): Promise<Readonly<Record<string, readonly DirtyMeta[]>>>;
     dropCollection(collection: string, force?: boolean): Promise<void>;
     dropDatabase(force?: boolean): Promise<void>;
     /**
@@ -182,8 +183,63 @@ export declare class SyncedDb implements I_SyncedDb {
      * Remove records from Dexie and in-mem that no longer match the
      * collection's current syncConfig.query. Does NOT delete from server.
      * Skips records with dirty changes (pending local writes).
+     *
+     * Runs two passes:
+     * 1. Local: evicts items whose locally-cached state fails the query.
+     *    Covers self-inflicted scope exits (the client moved an item out).
+     * 2. Server-assisted (default when online and not writeOnly): of the
+     *    items that still match locally, ask the server which now fail the
+     *    query server-side. Covers scope exits caused by other writers — the
+     *    filtered delta feed (`findNewer` with the positive query) never
+     *    ships those records, so the local cache would otherwise go stale
+     *    forever.
+     *
+     * The server-assisted query is `{ $and: [{ $nor: [query] }, { _id: { $in: chunk } }] }`
+     * with `project: { _id: 1 }`. Scoped to known IDs to preserve both
+     * bandwidth and authorization (server only reveals state of IDs the
+     * client already knew about). Sound only if `syncConfig.query` is the
+     * complete server-side predicate (no implicit server policy).
+     *
+     * @param opts.serverAssisted - Override auto-detection. Default: `true`
+     *   when online and not writeOnly. Set `false` for pure local eviction.
+     * @param opts.outOfWindowLookbehindMs - Restrict the server-assisted
+     *   query to records changed in the last N ms (adds `_ts > now-N` via
+     *   `findNewer`'s timestamp filter). When unspecified, the collection's
+     *   current `meta.lastSyncTs` is used — the same cursor `sync()` passes
+     *   to `findNewer`, so scope-exit scan covers the same time window as a
+     *   regular delta sync. Pass `Date.now()` (or any value larger than
+     *   elapsed time) to scan full history.
+     *
+     *   Note on post-sync timing: when this method runs AFTER `sync()`
+     *   (including via auto-eviction), `lastSyncTs` has already advanced
+     *   past the window sync just covered, so a record whose scope-exit
+     *   mutation landed in that window will not be re-examined on this
+     *   pass. Specify `outOfWindowLookbehindMs` (e.g., to cover since last
+     *   eviction) or call this before `sync()` to close that gap.
+     */
+    evictOutOfScopeRecords(collection: string, opts?: {
+        serverAssisted?: boolean;
+        outOfWindowLookbehindMs?: number;
+    }): Promise<EvictionCollectionInfo>;
+    /**
+     * Ask the server which of the given IDs no longer match the positive
+     * query server-side. Used by `evictOutOfScopeRecords` server-assisted
+     * pass to close the "filtered-delta tombstone" gap — records mutated
+     * out of scope by other writers that the filtered delta feed would
+     * never report.
+     *
+     * Chunks `candidateIds` into `$in`-sized batches to keep the request
+     * payload bounded. Uses `project: { _id: 1 }` to keep the response
+     * payload minimal.
+     *
+     * @param timestamp - `findNewer` timestamp cursor. Only records with
+     *   `_ts > timestamp` are examined. Caller decides the window (usually
+     *   the collection's `meta.lastSyncTs` to mirror the positive sync's
+     *   cursor, or a lookbehind-derived value for shorter windows).
+     * @returns IDs the server reports as out-of-scope (i.e. matching
+     *   `NOT query`). These are candidates for local-only eviction.
      */
-    evictOutOfScopeRecords(collection: string): Promise<EvictionCollectionInfo>;
+    private findServerSideScopeExits;
     /**
      * Evict out-of-scope records for all collections.
      * Skips writeOnly and collections without syncConfig.query.

package/dist/src/db/managers/CrossTabSyncManager.d.ts

@@ -1,8 +1,9 @@
 /**
  * CrossTabSyncManager - Manages cross-tab synchronization via BroadcastChannel.
  *
- * When the leader tab syncs data or receives WebSocket updates, it broadcasts
- * the IDs of updated records so other tabs can refresh their in-memory state.
+ * Any tab with local writes (leader or follower) broadcasts the IDs of updated
+ * records so other tabs refresh their in-memory state from shared Dexie.
+ * Reload broadcasts (post-full-sync) remain leader-only.
  */
 import type { MetaUpdateBroadcast } from "../../types/I_DexieDb";
 import type { I_CrossTabSyncManager, CrossTabSyncConfig } from "../types/managers";
@@ -31,7 +32,9 @@ export declare class CrossTabSyncManager implements I_CrossTabSyncManager {
     init(): void;
     /**
      * Broadcast updated IDs to other tabs (debounced).
-     * Only the leader should broadcast.
+     * Any tab with local writes broadcasts so other tabs refresh their in-mem
+     * from shared Dexie. Otherwise non-leader writes stay invisible to the leader's
+     * in-mem cache, and a later upload patches new _rev onto stale content.
      * While a server sync is in progress, suppresses delta broadcasts and only
      * records which collections were affected (for the post-sync reload broadcast).
      */

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

@@ -27,6 +27,12 @@ export interface DirtyChange {
     /** When last change was accumulated */
     updatedAt: number;
 }
+/**
+ * Meta fields of a DirtyChange entry, without the `changes` payload.
+ * Used by `getDirtyMeta` for lightweight dirty-state inspection
+ * (counts, timestamps) without loading change payloads into memory.
+ */
+export type DirtyMeta = Omit<DirtyChange, "changes">;
 /** Shared fields for all cross-tab broadcast messages */
 interface BroadcastBase {
     /** Unique ID of the SyncedDb instance that sent this broadcast */
@@ -84,6 +90,8 @@ export interface I_DexieDb {
     forEachBatch<T extends LocalDbEntity>(collection: string, batchSize: number, callback: (items: T[]) => Promise<void>): Promise<void>;
     /** Vrne vse dirty objekte (z lokalnimi spremembami) - returns only changed fields + _id + metadata */
     getDirty<T extends LocalDbEntity>(collection: string): Promise<Partial<T>[]>;
+    /** Vrne meta podatke vseh dirty vnosov za kolekcijo (brez `changes` payloada) */
+    getDirtyMeta(collection: string): Promise<DirtyMeta[]>;
     /** Add or accumulate changes for a record */
     addDirtyChange(collection: string, id: Id, changes: Record<string, any>, baseMeta?: {
         _ts?: any;

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

@@ -1,7 +1,7 @@
 import type { AggregateOptions } from "mongodb";
 import type { Id, DbEntity, LocalDbEntity } from "./DbEntity";
 import type { QuerySpec, QueryOpts, UpdateSpec, InsertSpec, BatchSpec, I_RestInterface, CollectionUpdateRequest, CollectionUpdateResult, GetNewerSpec } from "./I_RestInterface";
-import type { I_DexieDb } from "./I_DexieDb";
+import type { DirtyMeta, I_DexieDb } from "./I_DexieDb";
 import type { I_InMemDb } from "./I_InMemDb";
 import type { I_ServerUpdateNotifier } from "./I_ServerUpdateNotifier";
 import type { WakeSyncInfo, NetworkStatusChangeInfo } from "../db/types/managers";
@@ -700,6 +700,11 @@ export interface I_SyncedDb {
     getDebounceRestWritesMs(): number;
     /** Vrne vse dirty objekte iz vseh kolekcij */
     getDirty<T extends DbEntity>(): Promise<Readonly<Record<string, readonly T[]>>>;
+    /**
+     * Vrne meta podatke dirty vnosov (brez `changes` payloada) po kolekcijah,
+     * ki imajo vsaj en dirty zapis. Kolekcije brez dirty vnosov niso vključene.
+     */
+    getDirtyMeta(): Promise<Readonly<Record<string, readonly DirtyMeta[]>>>;
     /**
      * Drops a collection, ensuring no data loss.
      * - Throws if offline or forcedOffline (unless force=true)
@@ -733,9 +738,25 @@ export interface I_SyncedDb {
      * Remove records from Dexie and in-mem that no longer match the
      * collection's current syncConfig.query. Does NOT delete from server.
      * Skips records with dirty changes (pending local writes).
-     * Returns per-collection eviction stats.
-     */
-    evictOutOfScopeRecords(collection: string): Promise<EvictionCollectionInfo>;
+     *
+     * When `serverAssisted` is true (default when online and not writeOnly),
+     * also asks the server which of the locally-matching records no longer
+     * match the query server-side. This catches scope-exits caused by other
+     * writers — records the filtered delta feed would never report because
+     * the server-side state no longer matches the positive query.
+     *
+     * @param opts.serverAssisted - Override default auto-detection. Set
+     *   `false` to skip the server round-trip (local-only pass).
+     * @param opts.outOfWindowLookbehindMs - Restrict the server-assisted
+     *   query to records changed in the last N ms. When unspecified, uses
+     *   the collection's current `meta.lastSyncTs` — the same cursor
+     *   `sync()` passes to `findNewer`. Pass `Date.now()` to scan full
+     *   history.
+     */
+    evictOutOfScopeRecords(collection: string, opts?: {
+        serverAssisted?: boolean;
+        outOfWindowLookbehindMs?: number;
+    }): Promise<EvictionCollectionInfo>;
     /**
      * Same as evictOutOfScopeRecords but for all configured collections.
      * Skips writeOnly collections and collections without syncConfig.query.

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

@@ -2,7 +2,7 @@ export type { Id, Entity, IdOrEntity, DbEntity, LocalDbEntity } from "./DbEntity
 export type { PublishableOperation, PublishRevsPayloadInsert, PublishRevsPayloadUpdate, PublishRevsPayloadDelete, PublishRevsPayloadUpdateMany, PublishRevsPayloadDeleteMany, PublishRevsPayloadBatchItem, PublishRevsPayloadBatch, PublishRevsPayload, PublishRevsSpec, PublishDataPayloadBase, PublishDataPayloadInsert, PublishDataPayloadUpdate, PublishDataPayloadDelete, PublishDataPayloadBatch, PublishDataPayload, PublishDataSpec, PublishSpec, } from "./PublishRevsPayload";
 export type { Obj, QuerySpec, Projection, QueryOpts, KeyOf, InsertKeyOf, InsertSpec, UpdateSpec, BatchSpec, UpsertOptions, GetNewerSpec, I_RestInterface as RestInterface, } from "./I_RestInterface";
 export type { I_InMemDb as InMemDb } from "./I_InMemDb";
-export type { I_DexieDb as DexieDb, SyncMeta } from "./I_DexieDb";
+export type { I_DexieDb as DexieDb, SyncMeta, DirtyChange, DirtyMeta } from "./I_DexieDb";
 export type { I_ServerUpdateNotifier as ServerUpdateNotifier, ServerUpdateCallback, ServerUpdateNotifierCallbacks } from "./I_ServerUpdateNotifier";
 export type { I_SyncedDb as SyncedDb, SyncedDbConfig, CollectionConfig, CollectionSyncConfig, SyncInfo, ServerWriteRequestInfo, ServerWriteResultInfo, FindNewerManyCallInfo, FindNewerManyResultInfo, DexieWriteRequestInfo, DexieWriteResultInfo, LocalstorageWriteResultInfo, WsNotificationInfo, InfrastructureErrorType, InfrastructureErrorInfo, ConflictSource, ConflictResolutionReport, CrossTabSyncInfo, EvictionInfo, EvictionCollectionInfo, } from "./I_SyncedDb";
 export type { NetworkStatusChangeInfo } from "../db/types/managers";

package/dist/src/utils/localQuery.d.ts

@@ -1,8 +1,10 @@
 import type { QuerySpec, QueryOpts, Projection } from "../types/I_RestInterface";
 import type { DbEntity } from "../types/DbEntity";
 /**
- * Preveri, ali objekt ustreza MongoDB-style query specifikaciji
- * Podpira osnovne operatorje: $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin, $exists, $regex
+ * Preveri, ali objekt ustreza MongoDB-style query specifikaciji.
+ * Podpira polje-operatorje: $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin,
+ * $exists, $regex, $elemMatch, $size, $all — in logične operatorje
+ * $and, $or, $nor na top-levelu.
  */
 export declare function matchesQuery<T extends DbEntity>(item: T, query: QuerySpec<T>): boolean;
 /**

package/package.json

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