@multiplatform.one/frappe 6.0.0

package/dist/jsx/sync/subscriptionManager.native.js

@@ -0,0 +1,948 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var subscriptionManager_exports = {};
+__export(subscriptionManager_exports, {
+  SubscriptionManager: () => SubscriptionManager
+});
+module.exports = __toCommonJS(subscriptionManager_exports);
+var import_backfill = require("./backfill.native.js");
+var import_filters = require("./filters.native.js");
+var import_types = require("./types.native.js");
+var import_virtualPageManager = require("./virtualPageManager.native.js");
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var _this_options_pageSize;
+var SubscriptionManager = /* @__PURE__ */function () {
+  "use strict";
+
+  function SubscriptionManager2(db, normalizedCache) {
+    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    _class_call_check(this, SubscriptionManager2);
+    _define_property(this, "db", void 0);
+    _define_property(this, "normalizedCache", void 0);
+    _define_property(this, "options", void 0);
+    _define_property(this, "subscriptions", void 0);
+    _define_property(this, "virtualPageManager", void 0);
+    _define_property(this, "backfillManager", void 0);
+    _define_property(this, "queryKeyToSubId", void 0);
+    _define_property(this, "subRefCounts", void 0);
+    this.db = db;
+    this.normalizedCache = normalizedCache;
+    this.options = options;
+    this.subscriptions = /* @__PURE__ */new Map();
+    this.queryKeyToSubId = /* @__PURE__ */new Map();
+    this.subRefCounts = /* @__PURE__ */new Map();
+    this.virtualPageManager = new import_virtualPageManager.VirtualPageManager(this.normalizedCache, this.db, {
+      batchSize: this.options.batchSize
+    });
+    this.backfillManager = new import_backfill.BackfillManager(this.db, this.normalizedCache, {
+      pageSize: this.options.pageSize
+    });
+  }
+  _create_class(SubscriptionManager2, [{
+    key: "subscribe",
+    value: async function subscribe(query) {
+      var _query_fields;
+      var queryKey = JSON.stringify(query);
+      var existingId = this.queryKeyToSubId.get(queryKey);
+      if (existingId && this.subscriptions.has(existingId)) {
+        this.subRefCounts.set(existingId, (this.subRefCounts.get(existingId) || 1) + 1);
+        var rows = this.getDocsForSubscription(existingId);
+        var checkpoint = this.subscriptions.get(existingId).checkpoint;
+        return {
+          subscriptionId: existingId,
+          rows,
+          checkpoint
+        };
+      }
+      var subscriptionId = cryptoRandomId();
+      var queryFields = ((_query_fields = query.fields) === null || _query_fields === void 0 ? void 0 : _query_fields.length) ? Array.from(/* @__PURE__ */new Set([...query.fields, "modified", "name"])) : void 0;
+      var rows1 = [];
+      var cursor;
+      var singleName = (0, import_filters.extractSingleName)(query.filters);
+      if (singleName) {
+        try {
+          var document = await this.db.getDoc(query.doctype, singleName);
+          rows1 = document ? [document] : [];
+        } catch (error) {
+          var errorWithStatus = error;
+          if ((errorWithStatus === null || errorWithStatus === void 0 ? void 0 : errorWithStatus.status) === 404) {
+            rows1 = [];
+          } else {
+            throw error;
+          }
+        }
+      } else {
+        var listOptions = {
+          fields: queryFields,
+          filters: query.filters,
+          orderBy: query.orderBy
+        };
+        if (this.options.useCursorPagination) listOptions.cursor = void 0;
+        var response = await this.db.getDocList(query.doctype, listOptions);
+        if ((typeof response === "undefined" ? "undefined" : _type_of(response)) === "object" && response !== null && "data" in response) {
+          rows1 = response.data;
+          cursor = response.cursor;
+        } else {
+          rows1 = response;
+        }
+      }
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = rows1[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var row = _step.value;
+          if (!row.doctype) row.doctype = query.doctype;
+          this.normalizedCache.upsert(row);
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+      var checkpoint1 = void 0;
+      var _iteratorNormalCompletion1 = true,
+        _didIteratorError1 = false,
+        _iteratorError1 = void 0;
+      try {
+        for (var _iterator1 = rows1[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+          var row1 = _step1.value;
+          if (!row1.modified) continue;
+          if (!checkpoint1 || row1.modified > checkpoint1) checkpoint1 = row1.modified;
+        }
+      } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
+        } finally {
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
+        }
+      }
+      var subscription = {
+        id: subscriptionId,
+        query,
+        checkpoint: checkpoint1,
+        // For CDC backfill
+        cursor,
+        // For stable pagination
+        docIds: rows1.map(function (row2) {
+          return row2.name;
+        }),
+        tombstones: /* @__PURE__ */new Map()
+      };
+      if (rows1.length > 0) {
+        subscription.boundaries = {
+          firstItem: rows1[0],
+          lastItem: rows1[rows1.length - 1],
+          offset: query.limitStart || 0,
+          pageSize: query.limit || 20
+        };
+      }
+      subscription.metadata = {
+        itemsBeforePage: 0,
+        itemsAfterPage: 0
+      };
+      this.subscriptions.set(subscriptionId, subscription);
+      this.queryKeyToSubId.set(queryKey, subscriptionId);
+      this.subRefCounts.set(subscriptionId, 1);
+      if (query.progressive) {
+        this.virtualPageManager.registerSubscription(subscriptionId, subscription, subscription.docIds, cursor);
+      }
+      return {
+        subscriptionId,
+        rows: rows1,
+        checkpoint: checkpoint1
+      };
+    }
+  }, {
+    /**
+    * Removes a subscription by id. Cached docs remain until evicted by
+    * realtime/backfill or explicit resets. This keeps other subs fast if they
+    * share the same doctypes.
+    */
+    key: "unsubscribe",
+    value: function unsubscribe(subscriptionId) {
+      var refCount = (this.subRefCounts.get(subscriptionId) || 1) - 1;
+      if (refCount > 0) {
+        this.subRefCounts.set(subscriptionId, refCount);
+        return;
+      }
+      this.subRefCounts.delete(subscriptionId);
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = this.queryKeyToSubId[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var [key, id] = _step.value;
+          if (id === subscriptionId) {
+            this.queryKeyToSubId.delete(key);
+            break;
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+      this.subscriptions.delete(subscriptionId);
+    }
+  }, {
+    /** Returns subscription metadata by id. */
+    key: "getSubscription",
+    value: function getSubscription(id) {
+      return this.subscriptions.get(id);
+    }
+  }, {
+    /**
+    * Returns current rows for a subscription from the cache.
+    * Note: This is local-only; authoritative refresh happens via backfill/realtime.
+    */
+    key: "getDocsForSubscription",
+    value: function getDocsForSubscription(id) {
+      var virtualSub = this.virtualPageManager.getSubscription(id);
+      if (virtualSub) {
+        var docIds = virtualSub.getProgressiveCache().docIds.filter(function (id2) {
+          return id2 !== "";
+        });
+        var out = [];
+        var _iteratorNormalCompletion = true,
+          _didIteratorError = false,
+          _iteratorError = void 0;
+        try {
+          for (var _iterator = docIds[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var name = _step.value;
+            var document = this.normalizedCache.get({
+              doctype: virtualSub.query.doctype,
+              name
+            });
+            if (document) out.push(document);
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+        return out;
+      }
+      var subscription = this.subscriptions.get(id);
+      if (!subscription) return [];
+      var out1 = [];
+      var _iteratorNormalCompletion1 = true,
+        _didIteratorError1 = false,
+        _iteratorError1 = void 0;
+      try {
+        for (var _iterator1 = subscription.docIds[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+          var name1 = _step1.value;
+          var document1 = this.normalizedCache.get({
+            doctype: subscription.query.doctype,
+            name: name1
+          });
+          if (document1) out1.push(document1);
+        }
+      } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
+        } finally {
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
+        }
+      }
+      return out1;
+    }
+  }, {
+    key: "getPage",
+    value: (
+    /**
+    * Get a specific page of documents using virtual pagination
+    */
+    async function getPage(subscriptionId, page) {
+      return this.virtualPageManager.getPage(subscriptionId, page);
+    })
+  }, {
+    key: "getNextBatch",
+    value: (
+    /**
+    * Get documents after a cursor (for infinite scroll)
+    */
+    async function getNextBatch(subscriptionId, cursorDocId, limit) {
+      return this.virtualPageManager.getNextBatch(subscriptionId, cursorDocId, limit);
+    })
+  }, {
+    /**
+    * Get page information
+    */
+    key: "getPageInfo",
+    value: function getPageInfo(subscriptionId) {
+      return this.virtualPageManager.getPageInfo(subscriptionId);
+    }
+  }, {
+    key: "backfill",
+    value: (
+    /**
+    * Reconciles local state by fetching changes since stored cursors.
+    *
+    * Scopes
+    * - all: iterate all subscriptions
+    * - subscriptions: selected subscription ids
+    * - doctypes: all subscriptions matching any of these doctypes
+    * - docs: refetch specific documents (authority refresh)
+    */
+    async function backfill(args) {
+      if (args.scope === import_types.BackfillScope.All) {
+        var _iteratorNormalCompletion = true,
+          _didIteratorError = false,
+          _iteratorError = void 0;
+        try {
+          for (var _iterator = this.subscriptions.values()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var subscription = _step.value;
+            await this.backfillSub(subscription, args.pageSize);
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+        return;
+      }
+      if (args.scope === import_types.BackfillScope.Subscriptions) {
+        var _iteratorNormalCompletion1 = true,
+          _didIteratorError1 = false,
+          _iteratorError1 = void 0;
+        try {
+          for (var _iterator1 = (args.subscriptions || [])[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+            var subscriptionId = _step1.value;
+            var subscription1 = this.subscriptions.get(subscriptionId);
+            if (subscription1) await this.backfillSub(subscription1, args.pageSize);
+          }
+        } catch (err) {
+          _didIteratorError1 = true;
+          _iteratorError1 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+              _iterator1.return();
+            }
+          } finally {
+            if (_didIteratorError1) {
+              throw _iteratorError1;
+            }
+          }
+        }
+        return;
+      }
+      if (args.scope === import_types.BackfillScope.Doctypes) {
+        var set = new Set(args.doctypes || []);
+        var _iteratorNormalCompletion2 = true,
+          _didIteratorError2 = false,
+          _iteratorError2 = void 0;
+        try {
+          for (var _iterator2 = this.subscriptions.values()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+            var subscription2 = _step2.value;
+            if (set.has(subscription2.query.doctype)) await this.backfillSub(subscription2, args.pageSize);
+          }
+        } catch (err) {
+          _didIteratorError2 = true;
+          _iteratorError2 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+              _iterator2.return();
+            }
+          } finally {
+            if (_didIteratorError2) {
+              throw _iteratorError2;
+            }
+          }
+        }
+        return;
+      }
+      if (args.scope === import_types.BackfillScope.Docs) {
+        var _iteratorNormalCompletion3 = true,
+          _didIteratorError3 = false,
+          _iteratorError3 = void 0;
+        try {
+          for (var _iterator3 = (args.docs || [])[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+            var docTarget = _step3.value;
+            var document = await this.db.getDoc(docTarget.doctype, docTarget.name);
+            this.normalizedCache.upsert(document);
+          }
+        } catch (err) {
+          _didIteratorError3 = true;
+          _iteratorError3 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+              _iterator3.return();
+            }
+          } finally {
+            if (_didIteratorError3) {
+              throw _iteratorError3;
+            }
+          }
+        }
+      }
+    })
+  }, {
+    key: "backfillSub",
+    value: (
+    /**
+    * Backfills one subscription using CDC checkpoint and updates membership.
+    *
+    * Algorithm
+    * - Query backfill using checkpoint for CDC (Change Data Capture)
+    * - Upsert each row to cache
+    * - For each row: test client-side filters; add/remove membership accordingly
+    * - Track tombstones for deleted documents
+    * - Advance checkpoint to response checkpoint
+    * - If no filters were specified, derive membership directly from returned rows
+    */
+    async function backfillSub(subscription) {
+      var pageSize = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : (_this_options_pageSize = this.options.pageSize) !== null && _this_options_pageSize !== void 0 ? _this_options_pageSize : 200;
+      var response = await this.db.backfill({
+        doctype: subscription.query.doctype,
+        fields: subscription.query.fields,
+        filters: subscription.query.filters,
+        modifiedAfter: subscription.checkpoint,
+        // CDC checkpoint
+        limit: pageSize
+      });
+      if (response.deleted && Array.isArray(response.deleted)) {
+        var _iteratorNormalCompletion = true,
+          _didIteratorError = false,
+          _iteratorError = void 0;
+        try {
+          var _this,
+            _loop = function () {
+              var deleted = _step.value;
+              if (!(deleted === null || deleted === void 0 ? void 0 : deleted.name)) return "continue";
+              var deletedDoctype = deleted.doctype || subscription.query.doctype;
+              if (deletedDoctype === subscription.query.doctype && subscription.tombstones) {
+                subscription.tombstones.set(deleted.name, Date.now());
+              }
+              _this.normalizedCache.remove({
+                doctype: deletedDoctype,
+                name: deleted.name
+              });
+              if (deletedDoctype === subscription.query.doctype) subscription.docIds = subscription.docIds.filter(function (currentName) {
+                return currentName !== deleted.name;
+              });
+            };
+          for (var _iterator = response.deleted[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) _this = this, _loop();
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+      }
+      var _iteratorNormalCompletion1 = true,
+        _didIteratorError1 = false,
+        _iteratorError1 = void 0;
+      try {
+        var _this1,
+          _loop1 = function () {
+            var row = _step1.value;
+            if (!row.doctype) row.doctype = subscription.query.doctype;
+            _this1.normalizedCache.upsert(row);
+            var name = row.name;
+            if (!name) return "continue";
+            var match = (0, import_filters.matchesFilters)(row, subscription.query.filters);
+            if (match && !subscription.docIds.includes(name)) subscription.docIds.push(name);
+            if (!match) subscription.docIds = subscription.docIds.filter(function (currentName) {
+              return currentName !== name;
+            });
+          };
+        for (var _iterator1 = response.rows[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) _this1 = this, _loop1();
+      } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
+        } finally {
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
+        }
+      }
+      if (response.checkpoint) subscription.checkpoint = response.checkpoint;
+      if (response.rows.length && !subscription.query.filters) subscription.docIds = response.rows.map(function (row) {
+        return row.name;
+      });
+      if (subscription.docIds.length > 0) {
+        var firstDoc = this.normalizedCache.get({
+          doctype: subscription.query.doctype,
+          name: subscription.docIds[0]
+        });
+        var lastDoc = this.normalizedCache.get({
+          doctype: subscription.query.doctype,
+          name: subscription.docIds[subscription.docIds.length - 1]
+        });
+        if (firstDoc && lastDoc) {
+          var _subscription_boundaries, _subscription_boundaries1;
+          subscription.boundaries = {
+            firstItem: firstDoc,
+            lastItem: lastDoc,
+            offset: ((_subscription_boundaries = subscription.boundaries) === null || _subscription_boundaries === void 0 ? void 0 : _subscription_boundaries.offset) || 0,
+            pageSize: ((_subscription_boundaries1 = subscription.boundaries) === null || _subscription_boundaries1 === void 0 ? void 0 : _subscription_boundaries1.pageSize) || subscription.query.limit || 20
+          };
+        }
+      }
+      this.resortSubscriptionDocIds(subscription);
+      this.cleanupTombstones(subscription.id);
+      if (this.options.onBackfill) this.options.onBackfill({
+        doctype: subscription.query.doctype,
+        fetched: response.rows.length,
+        checkpoint: subscription.checkpoint
+      });
+    })
+  }, {
+    key: "resortSubscriptionDocIds",
+    value: function resortSubscriptionDocIds(subscription) {
+      var _this = this;
+      var {
+        orderBy,
+        doctype
+      } = subscription.query;
+      if (!orderBy) return;
+      var orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
+      subscription.docIds.sort(function (firstId, secondId) {
+        var firstDoc = _this.normalizedCache.get({
+          doctype,
+          name: firstId
+        });
+        var secondDoc = _this.normalizedCache.get({
+          doctype,
+          name: secondId
+        });
+        var _iteratorNormalCompletion = true,
+          _didIteratorError = false,
+          _iteratorError = void 0;
+        try {
+          for (var _iterator = orderByArray[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var orderByField = _step.value;
+            var field = orderByField.field;
+            var ascending = orderByField.order !== import_types.Order.Desc;
+            var firstValue = firstDoc === null || firstDoc === void 0 ? void 0 : firstDoc[field];
+            var secondValue = secondDoc === null || secondDoc === void 0 ? void 0 : secondDoc[field];
+            var firstIsNullish = firstValue === null || firstValue === void 0;
+            var secondIsNullish = secondValue === null || secondValue === void 0;
+            if (firstIsNullish && !secondIsNullish) return ascending ? -1 : 1;
+            if (secondIsNullish && !firstIsNullish) return ascending ? 1 : -1;
+            if (firstIsNullish && secondIsNullish) continue;
+            if (firstIsNullish || secondIsNullish) continue;
+            if (firstValue < secondValue) return ascending ? -1 : 1;
+            if (firstValue > secondValue) return ascending ? 1 : -1;
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+        return firstId < secondId ? -1 : firstId > secondId ? 1 : 0;
+      });
+    }
+  }, {
+    key: "updateSubscriptionMembership",
+    value: function updateSubscriptionMembership(doc) {
+      var subscriptionsNeedingRehydration = [];
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = this.subscriptions.values()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var subscription = _step.value;
+          if (subscription.query.doctype !== doc.doctype) continue;
+          var match = (0, import_filters.matchesFilters)(doc, subscription.query.filters);
+          var isExisting = subscription.docIds.includes(doc.name);
+          if (match && !isExisting) {
+            subscriptionsNeedingRehydration.push(subscription);
+            this.virtualPageManager.handleRemoteCreate(subscription.id, doc);
+          } else if (isExisting) {
+            if (!match) {
+              subscription.docIds = subscription.docIds.filter(function (docId) {
+                return docId !== doc.name;
+              });
+              this.virtualPageManager.handleRemoteDelete(subscription.id, doc.name);
+            } else {
+              this.virtualPageManager.handleRemoteUpdate(subscription.id, doc);
+            }
+            this.resortSubscriptionDocIds(subscription);
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+      return subscriptionsNeedingRehydration;
+    }
+  }, {
+    /**
+    * Removes a document from all subscription memberships.
+    * Returns subscriptions that had the document removed (for potential backfill).
+    */
+    key: "removeFromAllSubscriptions",
+    value: function removeFromAllSubscriptions(doctype, name) {
+      var affectedSubscriptions = [];
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = this.subscriptions.values()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var subscription = _step.value;
+          if (subscription.query.doctype !== doctype) continue;
+          var hadDocument = subscription.docIds.includes(name);
+          if (hadDocument) {
+            subscription.docIds = subscription.docIds.filter(function (docId) {
+              return docId !== name;
+            });
+            this.virtualPageManager.handleRemoteDelete(subscription.id, name);
+            affectedSubscriptions.push(subscription);
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+      return affectedSubscriptions;
+    }
+  }, {
+    /** Gets all active subscriptions. */
+    key: "getAllSubscriptions",
+    value: function getAllSubscriptions() {
+      return this.subscriptions;
+    }
+  }, {
+    key: "getVirtualPageManager",
+    value: function getVirtualPageManager() {
+      return this.virtualPageManager;
+    }
+  }, {
+    key: "insertDocumentIntoSubscription",
+    value: function insertDocumentIntoSubscription(subscription, doc) {
+      if (subscription.docIds.includes(doc.name)) return;
+      if (!subscription.query.orderBy || subscription.docIds.length === 0) {
+        return subscription.docIds.push(doc.name);
+      }
+      var insertIndex = this.findInsertionIndex(subscription, doc);
+      subscription.docIds.splice(insertIndex, 0, doc.name);
+    }
+  }, {
+    key: "findInsertionIndex",
+    value: function findInsertionIndex(subscription, doc) {
+      var {
+        docIds,
+        query
+      } = subscription;
+      var orderByArray = Array.isArray(query.orderBy) ? query.orderBy : [query.orderBy];
+      var left = 0;
+      var right = docIds.length - 1;
+      while (left <= right) {
+        var mid = Math.floor((left + right) / 2);
+        var midDoc = this.normalizedCache.get({
+          doctype: query.doctype,
+          name: docIds[mid]
+        });
+        if (!midDoc) {
+          return docIds.length;
+        }
+        var comparison = this.compareDocuments(doc, midDoc, orderByArray);
+        if (comparison <= 0) {
+          right = mid - 1;
+        } else {
+          left = mid + 1;
+        }
+      }
+      return left;
+    }
+  }, {
+    key: "compareDocuments",
+    value: function compareDocuments(doc1, doc2, orderByArray) {
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = orderByArray[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var {
+            field,
+            order
+          } = _step.value;
+          var value1 = doc1[field];
+          var value2 = doc2[field];
+          var isAsc = order !== import_types.Order.Desc;
+          var isNull1 = value1 == null;
+          var isNull2 = value2 == null;
+          if (isNull1 && !isNull2) return isAsc ? -1 : 1;
+          if (!isNull1 && isNull2) return isAsc ? 1 : -1;
+          if (isNull1 && isNull2) continue;
+          if (value1 < value2) return isAsc ? -1 : 1;
+          if (value1 > value2) return isAsc ? 1 : -1;
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+      var name1 = doc1.name || "";
+      var name2 = doc2.name || "";
+      return name1 < name2 ? -1 : name1 > name2 ? 1 : 0;
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.subscriptions.clear();
+      this.queryKeyToSubId.clear();
+      this.subRefCounts.clear();
+    }
+  }, {
+    /**
+    * Cleans up expired tombstones based on age and count limits.
+    * Should be called periodically or after backfill operations.
+    */
+    key: "cleanupTombstones",
+    value: function cleanupTombstones(subscriptionId) {
+      var _this_options_tombstoneMaxAge, _this_options_tombstoneMaxCount;
+      var maxAge = (_this_options_tombstoneMaxAge = this.options.tombstoneMaxAge) !== null && _this_options_tombstoneMaxAge !== void 0 ? _this_options_tombstoneMaxAge : 30 * 60 * 1e3;
+      var maxCount = (_this_options_tombstoneMaxCount = this.options.tombstoneMaxCount) !== null && _this_options_tombstoneMaxCount !== void 0 ? _this_options_tombstoneMaxCount : 1e3;
+      var now = Date.now();
+      var subscriptionsToClean = subscriptionId ? [this.subscriptions.get(subscriptionId)].filter(Boolean) : [...this.subscriptions.values()];
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = subscriptionsToClean[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var subscription = _step.value;
+          if (!(subscription === null || subscription === void 0 ? void 0 : subscription.tombstones) || subscription.tombstones.size === 0) continue;
+          var _iteratorNormalCompletion1 = true,
+            _didIteratorError1 = false,
+            _iteratorError1 = void 0;
+          try {
+            for (var _iterator1 = subscription.tombstones[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+              var [name, timestamp] = _step1.value;
+              if (now - timestamp > maxAge) {
+                subscription.tombstones.delete(name);
+              }
+            }
+          } catch (err) {
+            _didIteratorError1 = true;
+            _iteratorError1 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                _iterator1.return();
+              }
+            } finally {
+              if (_didIteratorError1) {
+                throw _iteratorError1;
+              }
+            }
+          }
+          if (subscription.tombstones.size > maxCount) {
+            var entries = [...subscription.tombstones.entries()];
+            entries.sort(function (a, b) {
+              return a[1] - b[1];
+            });
+            var toRemove = entries.slice(0, subscription.tombstones.size - maxCount);
+            var _iteratorNormalCompletion2 = true,
+              _didIteratorError2 = false,
+              _iteratorError2 = void 0;
+            try {
+              for (var _iterator2 = toRemove[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+                var [name1] = _step2.value;
+                subscription.tombstones.delete(name1);
+              }
+            } catch (err) {
+              _didIteratorError2 = true;
+              _iteratorError2 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                  _iterator2.return();
+                }
+              } finally {
+                if (_didIteratorError2) {
+                  throw _iteratorError2;
+                }
+              }
+            }
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+    }
+  }]);
+  return SubscriptionManager2;
+}();
+function cryptoRandomId() {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+    return crypto.randomUUID();
+  }
+  return Math.random().toString(36).slice(2);
+}
+//# sourceMappingURL=subscriptionManager.native.js.map