@firtoz/collection-sync 4.0.0 → 6.0.0

package/dist/chunk-P3JOTUAB.js

@@ -0,0 +1,802 @@
+import { DEFAULT_SYNC_COLLECTION_ID, createClientMutationId } from './chunk-BJJEAKXL.js';
+import { partialSyncRowKey, partialSyncRowVersionWatermarkMs } from './chunk-UJ24XW52.js';
+import { __privateAdd, __privateSet, __privateGet, __privateMethod } from './chunk-HMLY7DHA.js';
+import { exhaustiveGuard } from '@firtoz/maybe-error';
+
+function serverRowSupersedesLocal(local, server) {
+  const lm = partialSyncRowVersionWatermarkMs(local);
+  const sm = partialSyncRowVersionWatermarkMs(server);
+  if (sm > lm) return true;
+  if (sm < lm) return false;
+  try {
+    return JSON.stringify(local) !== JSON.stringify(server);
+  } catch {
+    return true;
+  }
+}
+var _connected, _state, _inFlightRequests, _inFlightReconcileRequests, _cachedIds, _cacheUtilization, _totalCount, _sendFn, _serverConfirmedKeys, _serverConfirmedKeysRevision, _confirmedRevisionListeners, _rangeFetchApplySerial, _pendingCoalescedUpdatesByKey, _PartialSyncClientBridge_instances, out_fn, scheduleRangeFetchApply_fn, exitFetchingAfterApplyFailure_fn, notifyConfirmedKeysRevision_fn, buildReconcileManifest_fn, handleRangePatch_fn, replaceServerConfirmedKeysFromRows_fn, prunePartialInterestTrackingAfterExitView_fn, mergeServerConfirmedKeysFromMessages_fn, isActiveRangeRequest_fn, handleQueryRangeChunk_fn, handleRangeUpToDate_fn, handleRangeDelta_fn, handleRangeReconcileResult_fn, refreshCachedCountInState_fn, drainPendingCoalescedUpdates_fn, receiveSyncAndTrack_fn, applyAndTrack_fn, setState_fn;
+var PartialSyncClientBridge = class {
+  constructor(options) {
+    this.options = options;
+    __privateAdd(this, _PartialSyncClientBridge_instances);
+    __privateAdd(this, _connected, false);
+    __privateAdd(this, _state, { status: "offline" });
+    __privateAdd(this, _inFlightRequests, /* @__PURE__ */ new Map());
+    __privateAdd(this, _inFlightReconcileRequests, /* @__PURE__ */ new Map());
+    __privateAdd(this, _cachedIds, /* @__PURE__ */ new Set());
+    __privateAdd(this, _cacheUtilization, 0);
+    __privateAdd(this, _totalCount, 0);
+    __privateAdd(this, _sendFn);
+    /** Row keys last delivered by a completed server range response (see viewport `cacheDisplayMode`). */
+    __privateAdd(this, _serverConfirmedKeys, /* @__PURE__ */ new Set());
+    __privateAdd(this, _serverConfirmedKeysRevision, 0);
+    __privateAdd(this, _confirmedRevisionListeners, /* @__PURE__ */ new Set());
+    /**
+     * Ensures `queryRangeChunk` / `rangeDelta` handlers never overlap: concurrent
+     * {@link handleServerMessage} calls must not run `receiveSync` in parallel for range fetches.
+     */
+    __privateAdd(this, _rangeFetchApplySerial, Promise.resolve());
+    /**
+     * Plain `rangePatch` updates: merge by row key. `connectPartialSync` calls
+     * `flushPendingCoalescedInboundUpdates` after each inbound pump pass; call it yourself if you use
+     * the bridge without that helper.
+     */
+    __privateAdd(this, _pendingCoalescedUpdatesByKey, /* @__PURE__ */ new Map());
+    this.clientId = options.clientId ?? crypto.randomUUID();
+    this.collectionId = options.collectionId ?? DEFAULT_SYNC_COLLECTION_ID;
+    __privateSet(this, _sendFn, options.send);
+  }
+  get state() {
+    return __privateGet(this, _state);
+  }
+  get cachedCount() {
+    return __privateGet(this, _cachedIds).size;
+  }
+  setConnecting() {
+    __privateGet(this, _pendingCoalescedUpdatesByKey).clear();
+    __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, { status: "connecting" });
+  }
+  setConnected(connected) {
+    __privateSet(this, _connected, connected);
+    if (!connected) {
+      __privateGet(this, _pendingCoalescedUpdatesByKey).clear();
+      __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, { status: "disconnected", cachedCount: this.cachedCount });
+      return;
+    }
+    if (this.cachedCount > 0) {
+      __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, {
+        status: "realtime",
+        cachedCount: this.cachedCount,
+        totalCount: __privateGet(this, _totalCount),
+        cacheUtilization: __privateGet(this, _cacheUtilization)
+      });
+      return;
+    }
+    __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, { status: "connected" });
+  }
+  setOffline() {
+    __privateSet(this, _connected, false);
+    __privateGet(this, _pendingCoalescedUpdatesByKey).clear();
+    __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, { status: "offline" });
+  }
+  setSend(send) {
+    __privateSet(this, _sendFn, send);
+  }
+  setError(message) {
+    __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, { status: "error", message });
+  }
+  setCacheUtilization(utilization) {
+    __privateSet(this, _cacheUtilization, Math.max(0, utilization));
+    if (__privateGet(this, _state).status === "partial" || __privateGet(this, _state).status === "realtime") {
+      __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, {
+        ...__privateGet(this, _state),
+        cacheUtilization: __privateGet(this, _cacheUtilization)
+      });
+    }
+  }
+  setEvicting(evictingCount) {
+    __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, {
+      status: "evicting",
+      cachedCount: this.cachedCount,
+      evictingCount
+    });
+  }
+  clearEvictingState() {
+    __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, {
+      status: __privateGet(this, _connected) ? "realtime" : "partial",
+      cachedCount: this.cachedCount,
+      totalCount: __privateGet(this, _totalCount),
+      cacheUtilization: __privateGet(this, _cacheUtilization)
+    });
+  }
+  /**
+   * Drop in-flight `queryRange` / `queryByOffset` / `rangeQuery` requests (e.g. user seek / sort reset).
+   * {@link requestRange}, {@link requestByOffset}, and {@link requestRangeQuery} call this first so
+   * overlapping viewport debounces cannot double-apply the same rows.
+   */
+  abortRangeRequests() {
+    for (const inflight of __privateGet(this, _inFlightRequests).values()) {
+      inflight.reject(
+        Object.assign(new Error("Range request aborted"), {
+          name: "AbortError"
+        })
+      );
+    }
+    __privateGet(this, _inFlightRequests).clear();
+    for (const inflight of __privateGet(this, _inFlightReconcileRequests).values()) {
+      inflight.reject(
+        Object.assign(new Error("Range request aborted"), {
+          name: "AbortError"
+        })
+      );
+    }
+    __privateGet(this, _inFlightReconcileRequests).clear();
+  }
+  /**
+   * Clear tracked row ids (e.g. after a local `truncate()` on the collection). Local truncate
+   * does not flow through `receiveSync`, so the bridge must be reset to match.
+   */
+  clearServerConfirmedKeys() {
+    __privateGet(this, _serverConfirmedKeys).clear();
+    __privateSet(this, _serverConfirmedKeysRevision, __privateGet(this, _serverConfirmedKeysRevision) + 1);
+    __privateMethod(this, _PartialSyncClientBridge_instances, notifyConfirmedKeysRevision_fn).call(this);
+  }
+  /** Keys from the latest completed `rangeQuery` / chunk response. */
+  get serverConfirmedKeys() {
+    return __privateGet(this, _serverConfirmedKeys);
+  }
+  /** Bumps when {@link serverConfirmedKeys} changes; pass into predicate hooks as a dependency. */
+  get serverConfirmedKeysRevision() {
+    return __privateGet(this, _serverConfirmedKeysRevision);
+  }
+  /** Subscribe to {@link serverConfirmedKeysRevision} changes (for `useSyncExternalStore`). */
+  subscribeConfirmedKeysRevision(listener) {
+    __privateGet(this, _confirmedRevisionListeners).add(listener);
+    return () => {
+      __privateGet(this, _confirmedRevisionListeners).delete(listener);
+    };
+  }
+  clearTrackedRowIds() {
+    __privateGet(this, _cachedIds).clear();
+    __privateGet(this, _serverConfirmedKeys).clear();
+    __privateSet(this, _serverConfirmedKeysRevision, __privateGet(this, _serverConfirmedKeysRevision) + 1);
+    __privateMethod(this, _PartialSyncClientBridge_instances, notifyConfirmedKeysRevision_fn).call(this);
+    const s = __privateGet(this, _state);
+    if (s.status === "partial" || s.status === "realtime") {
+      __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, { ...s, cachedCount: 0 });
+    } else if (s.status === "disconnected") {
+      __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, { status: "disconnected", cachedCount: 0 });
+    } else if (s.status === "evicting") {
+      __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, { ...s, cachedCount: 0 });
+    }
+  }
+  requestRange(sort, limit, afterCursor) {
+    this.abortRangeRequests();
+    const requestId = createClientMutationId("qr");
+    __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, {
+      status: "fetching",
+      requestId,
+      chunksReceived: 0
+    });
+    return new Promise((resolve, reject) => {
+      __privateGet(this, _inFlightRequests).set(requestId, {
+        requestId,
+        rows: [],
+        totalCount: 0,
+        lastCursor: afterCursor,
+        hasMore: false,
+        chunksReceived: 0,
+        resolve,
+        reject
+      });
+      __privateMethod(this, _PartialSyncClientBridge_instances, out_fn).call(this, {
+        type: "queryRange",
+        clientId: this.clientId,
+        requestId,
+        sort,
+        limit,
+        afterCursor
+      });
+    });
+  }
+  requestByOffset(sort, limit, offset) {
+    this.abortRangeRequests();
+    const requestId = createClientMutationId("qo");
+    __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, {
+      status: "fetching",
+      requestId,
+      chunksReceived: 0
+    });
+    return new Promise((resolve, reject) => {
+      __privateGet(this, _inFlightRequests).set(requestId, {
+        requestId,
+        rows: [],
+        totalCount: 0,
+        lastCursor: null,
+        hasMore: false,
+        chunksReceived: 0,
+        resolve,
+        reject
+      });
+      __privateMethod(this, _PartialSyncClientBridge_instances, out_fn).call(this, {
+        type: "queryByOffset",
+        clientId: this.clientId,
+        requestId,
+        sort,
+        limit,
+        offset
+      });
+    });
+  }
+  requestRangeQuery(range, fingerprint) {
+    this.abortRangeRequests();
+    const requestId = createClientMutationId("rq");
+    __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, {
+      status: "fetching",
+      requestId,
+      chunksReceived: 0
+    });
+    return new Promise((resolve, reject) => {
+      __privateGet(this, _inFlightRequests).set(requestId, {
+        requestId,
+        rows: [],
+        totalCount: 0,
+        lastCursor: null,
+        hasMore: false,
+        chunksReceived: 0,
+        resolve,
+        reject
+      });
+      __privateMethod(this, _PartialSyncClientBridge_instances, out_fn).call(this, {
+        type: "rangeQuery",
+        clientId: this.clientId,
+        requestId,
+        range,
+        ...fingerprint !== void 0 ? { fingerprint } : {}
+      });
+    });
+  }
+  /**
+   * Reconcile the client's cached window against the server using a row manifest (id + version ms).
+   * Pass `manifest` to override rows; otherwise uses {@link PartialSyncClientBridge.serverConfirmedKeys} and {@link PartialSyncClientBridgeOptions.collection} `get`.
+   */
+  requestRangeReconcile(range, manifest) {
+    this.abortRangeRequests();
+    const requestId = createClientMutationId("rc");
+    const resolvedManifest = manifest ?? __privateMethod(this, _PartialSyncClientBridge_instances, buildReconcileManifest_fn).call(this);
+    __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, {
+      status: "fetching",
+      requestId,
+      chunksReceived: 0
+    });
+    return new Promise((resolve, reject) => {
+      __privateGet(this, _inFlightReconcileRequests).set(requestId, {
+        requestId,
+        resolve,
+        reject
+      });
+      __privateMethod(this, _PartialSyncClientBridge_instances, out_fn).call(this, {
+        type: "rangeReconcile",
+        clientId: this.clientId,
+        requestId,
+        range,
+        manifest: resolvedManifest
+      });
+    });
+  }
+  async handleServerMessage(message) {
+    const mid = message.collectionId ?? DEFAULT_SYNC_COLLECTION_ID;
+    if (mid !== this.collectionId) return;
+    switch (message.type) {
+      case "queryRangeChunk":
+        await __privateMethod(this, _PartialSyncClientBridge_instances, scheduleRangeFetchApply_fn).call(this, () => __privateMethod(this, _PartialSyncClientBridge_instances, handleQueryRangeChunk_fn).call(this, message));
+        return;
+      case "rangeUpToDate":
+        __privateMethod(this, _PartialSyncClientBridge_instances, handleRangeUpToDate_fn).call(this, message);
+        return;
+      case "rangeDelta":
+        await __privateMethod(this, _PartialSyncClientBridge_instances, scheduleRangeFetchApply_fn).call(this, () => __privateMethod(this, _PartialSyncClientBridge_instances, handleRangeDelta_fn).call(this, message));
+        return;
+      case "rangeReconcileResult":
+        await __privateMethod(this, _PartialSyncClientBridge_instances, scheduleRangeFetchApply_fn).call(this, () => __privateMethod(this, _PartialSyncClientBridge_instances, handleRangeReconcileResult_fn).call(this, message));
+        return;
+      case "rangePatch":
+        await __privateMethod(this, _PartialSyncClientBridge_instances, handleRangePatch_fn).call(this, message);
+        return;
+      case "syncBatch":
+        await __privateMethod(this, _PartialSyncClientBridge_instances, applyAndTrack_fn).call(this, message.changes);
+        return;
+      case "ack":
+        await __privateMethod(this, _PartialSyncClientBridge_instances, applyAndTrack_fn).call(this, message.changes);
+        return;
+      case "syncBackfill":
+        await __privateMethod(this, _PartialSyncClientBridge_instances, applyAndTrack_fn).call(this, message.changes);
+        return;
+      case "reject":
+        this.setError(message.reason);
+        return;
+      case "pong":
+        return;
+      default:
+        exhaustiveGuard(message);
+    }
+  }
+  /**
+   * Merge rows already present in the local collection (e.g. IndexedDB eager `initialLoad`) into
+   * `#cachedIds` so {@link cachedCount} and React-driven `bridgeState` match durable storage after reload.
+   * Safe to call multiple times; ids are a set. Does not call `receiveSync`.
+   */
+  seedHydratedLocalRows(rows) {
+    if (rows.length === 0) return;
+    for (const row of rows) {
+      __privateGet(this, _cachedIds).add(partialSyncRowKey(row.id));
+    }
+    __privateMethod(this, _PartialSyncClientBridge_instances, refreshCachedCountInState_fn).call(this);
+  }
+  /**
+   * Updates `#cachedIds` after {@link SyncClientBridge} has already applied the same messages via `receiveSync`
+   * (e.g. `syncBatch`) so we do not double-apply.
+   */
+  syncTrackedIdsFromMessages(changes) {
+    for (const change of changes) {
+      switch (change.type) {
+        case "insert":
+          __privateGet(this, _cachedIds).add(partialSyncRowKey(change.value.id));
+          break;
+        case "update":
+          __privateGet(this, _cachedIds).add(partialSyncRowKey(change.value.id));
+          break;
+        case "delete":
+          __privateGet(this, _cachedIds).delete(change.key);
+          break;
+        case "truncate":
+          __privateGet(this, _cachedIds).clear();
+          break;
+        default:
+          exhaustiveGuard(change);
+      }
+    }
+  }
+  /**
+   * Apply pending plain `rangePatch` updates coalesced by row id. Idempotent when the map is empty.
+   * Invoked automatically by `connectPartialSync` after each inbound pump drain.
+   */
+  async flushPendingCoalescedInboundUpdates() {
+    await __privateMethod(this, _PartialSyncClientBridge_instances, drainPendingCoalescedUpdates_fn).call(this);
+  }
+};
+_connected = new WeakMap();
+_state = new WeakMap();
+_inFlightRequests = new WeakMap();
+_inFlightReconcileRequests = new WeakMap();
+_cachedIds = new WeakMap();
+_cacheUtilization = new WeakMap();
+_totalCount = new WeakMap();
+_sendFn = new WeakMap();
+_serverConfirmedKeys = new WeakMap();
+_serverConfirmedKeysRevision = new WeakMap();
+_confirmedRevisionListeners = new WeakMap();
+_rangeFetchApplySerial = new WeakMap();
+_pendingCoalescedUpdatesByKey = new WeakMap();
+_PartialSyncClientBridge_instances = new WeakSet();
+out_fn = function(msg) {
+  __privateGet(this, _sendFn).call(this, {
+    ...msg,
+    collectionId: this.collectionId
+  });
+};
+scheduleRangeFetchApply_fn = function(fn) {
+  const next = __privateGet(this, _rangeFetchApplySerial).catch(() => {
+  }).then(fn);
+  __privateSet(this, _rangeFetchApplySerial, next);
+  return next;
+};
+exitFetchingAfterApplyFailure_fn = function() {
+  if (__privateGet(this, _connected)) {
+    __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, {
+      status: "realtime",
+      cachedCount: this.cachedCount,
+      totalCount: __privateGet(this, _totalCount),
+      cacheUtilization: __privateGet(this, _cacheUtilization)
+    });
+  } else {
+    __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, {
+      status: "partial",
+      cachedCount: this.cachedCount,
+      totalCount: __privateGet(this, _totalCount),
+      cacheUtilization: __privateGet(this, _cacheUtilization)
+    });
+  }
+};
+notifyConfirmedKeysRevision_fn = function() {
+  for (const listener of __privateGet(this, _confirmedRevisionListeners)) {
+    listener();
+  }
+};
+buildReconcileManifest_fn = function() {
+  const get = this.options.collection.get;
+  if (get === void 0) return [];
+  const out = [];
+  for (const key of __privateGet(this, _serverConfirmedKeys)) {
+    let local = get(key);
+    if (local === void 0 && typeof key === "number") {
+      local = get(String(key));
+    } else if (local === void 0 && typeof key === "string") {
+      const asNum = Number(key);
+      if (!Number.isNaN(asNum)) {
+        local = get(asNum);
+      }
+    }
+    if (local === void 0) continue;
+    const rowId = local.id;
+    if (typeof rowId !== "string" && typeof rowId !== "number") {
+      continue;
+    }
+    out.push({
+      id: rowId,
+      version: partialSyncRowVersionWatermarkMs(local)
+    });
+  }
+  return out;
+};
+handleRangePatch_fn = async function(message) {
+  const { change, viewTransition } = message;
+  if (viewTransition === "exitView") {
+    if (change.type === "update") {
+      this.options.onViewTransition?.({ type: "exitView", change });
+    }
+    await __privateMethod(this, _PartialSyncClientBridge_instances, applyAndTrack_fn).call(this, [change]);
+    __privateMethod(this, _PartialSyncClientBridge_instances, prunePartialInterestTrackingAfterExitView_fn).call(this, change);
+    this.options.onRangePatchApplied?.({ change, viewTransition });
+    return;
+  }
+  if (viewTransition === "enterView") {
+    if (change.type === "update") {
+      this.options.onViewTransition?.({ type: "enterView", change });
+      const key = partialSyncRowKey(change.value.id);
+      const getRow = this.options.collection.get;
+      let local = getRow !== void 0 ? getRow(key) : void 0;
+      if (local === void 0 && getRow !== void 0) {
+        if (typeof key === "number") {
+          local = getRow(String(key));
+        } else {
+          const asNum = Number(key);
+          if (!Number.isNaN(asNum)) {
+            local = getRow(asNum);
+          }
+        }
+      }
+      const alreadyInCollection = __privateGet(this, _cachedIds).has(key) || local !== void 0;
+      const toApply = alreadyInCollection ? [change] : [{ type: "insert", value: change.value }];
+      await __privateMethod(this, _PartialSyncClientBridge_instances, applyAndTrack_fn).call(this, toApply);
+      this.options.onRangePatchApplied?.({ change, viewTransition });
+      return;
+    }
+    await __privateMethod(this, _PartialSyncClientBridge_instances, applyAndTrack_fn).call(this, [change]);
+    this.options.onRangePatchApplied?.({ change, viewTransition });
+    return;
+  }
+  await __privateMethod(this, _PartialSyncClientBridge_instances, applyAndTrack_fn).call(this, [change], change.type === "update");
+  __privateMethod(this, _PartialSyncClientBridge_instances, mergeServerConfirmedKeysFromMessages_fn).call(this, [change]);
+  this.options.onRangePatchApplied?.({ change, viewTransition });
+};
+replaceServerConfirmedKeysFromRows_fn = function(rows) {
+  __privateGet(this, _serverConfirmedKeys).clear();
+  for (const row of rows) {
+    __privateGet(this, _serverConfirmedKeys).add(partialSyncRowKey(row.id));
+  }
+  __privateSet(this, _serverConfirmedKeysRevision, __privateGet(this, _serverConfirmedKeysRevision) + 1);
+  __privateMethod(this, _PartialSyncClientBridge_instances, notifyConfirmedKeysRevision_fn).call(this);
+};
+/** Row left the client's server-confirmed window; stop counting it as partial-sync cached. */
+prunePartialInterestTrackingAfterExitView_fn = function(change) {
+  switch (change.type) {
+    case "insert":
+    case "update": {
+      const key = partialSyncRowKey(change.value.id);
+      __privateGet(this, _cachedIds).delete(key);
+      __privateGet(this, _serverConfirmedKeys).delete(key);
+      break;
+    }
+    case "delete": {
+      __privateGet(this, _cachedIds).delete(change.key);
+      __privateGet(this, _serverConfirmedKeys).delete(change.key);
+      break;
+    }
+    case "truncate":
+      __privateGet(this, _cachedIds).clear();
+      __privateGet(this, _serverConfirmedKeys).clear();
+      break;
+    default:
+      exhaustiveGuard(change);
+  }
+  __privateSet(this, _serverConfirmedKeysRevision, __privateGet(this, _serverConfirmedKeysRevision) + 1);
+  __privateMethod(this, _PartialSyncClientBridge_instances, notifyConfirmedKeysRevision_fn).call(this);
+  __privateMethod(this, _PartialSyncClientBridge_instances, refreshCachedCountInState_fn).call(this);
+};
+mergeServerConfirmedKeysFromMessages_fn = function(changes) {
+  if (changes.length === 0) return;
+  for (const change of changes) {
+    switch (change.type) {
+      case "insert":
+      case "update":
+        __privateGet(this, _serverConfirmedKeys).add(partialSyncRowKey(change.value.id));
+        break;
+      case "delete":
+        __privateGet(this, _serverConfirmedKeys).delete(change.key);
+        break;
+      case "truncate":
+        __privateGet(this, _serverConfirmedKeys).clear();
+        break;
+      default:
+        exhaustiveGuard(change);
+    }
+  }
+  __privateSet(this, _serverConfirmedKeysRevision, __privateGet(this, _serverConfirmedKeysRevision) + 1);
+  __privateMethod(this, _PartialSyncClientBridge_instances, notifyConfirmedKeysRevision_fn).call(this);
+};
+/** True only if this handler still owns the in-flight entry (not superseded by {@link abortRangeRequests}). */
+isActiveRangeRequest_fn = function(requestId, inFlight) {
+  return __privateGet(this, _inFlightRequests).get(requestId) === inFlight;
+};
+handleQueryRangeChunk_fn = async function(message) {
+  const inFlight = __privateGet(this, _inFlightRequests).get(message.requestId);
+  if (!inFlight) return;
+  inFlight.chunksReceived += 1;
+  inFlight.totalCount = message.totalCount;
+  inFlight.lastCursor = message.lastCursor;
+  inFlight.hasMore = message.hasMore;
+  __privateSet(this, _totalCount, message.totalCount);
+  __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, {
+    status: "fetching",
+    requestId: message.requestId,
+    chunksReceived: inFlight.chunksReceived
+  });
+  if (message.rows.length > 0) {
+    await this.options.beforeApplyRows?.(message.rows);
+    if (!__privateMethod(this, _PartialSyncClientBridge_instances, isActiveRangeRequest_fn).call(this, message.requestId, inFlight)) return;
+    const getRow = this.options.collection.get;
+    const changes = [];
+    let cacheTouched = false;
+    for (const row of message.rows) {
+      const pk = partialSyncRowKey(row.id);
+      const local = getRow !== void 0 ? getRow(pk) : void 0;
+      if (local !== void 0) {
+        if (!__privateGet(this, _cachedIds).has(pk)) {
+          __privateGet(this, _cachedIds).add(pk);
+          cacheTouched = true;
+        }
+        if (serverRowSupersedesLocal(local, row)) {
+          changes.push({
+            type: "update",
+            value: row,
+            previousValue: local
+          });
+        }
+        continue;
+      }
+      if (!__privateGet(this, _cachedIds).has(pk)) {
+        changes.push({ type: "insert", value: row });
+      }
+    }
+    if (changes.length > 0) {
+      try {
+        await __privateMethod(this, _PartialSyncClientBridge_instances, applyAndTrack_fn).call(this, changes);
+      } catch (err) {
+        if (!__privateMethod(this, _PartialSyncClientBridge_instances, isActiveRangeRequest_fn).call(this, message.requestId, inFlight)) {
+          return;
+        }
+        __privateGet(this, _inFlightRequests).delete(message.requestId);
+        inFlight.reject(err);
+        __privateMethod(this, _PartialSyncClientBridge_instances, exitFetchingAfterApplyFailure_fn).call(this);
+        return;
+      }
+      if (!__privateMethod(this, _PartialSyncClientBridge_instances, isActiveRangeRequest_fn).call(this, message.requestId, inFlight)) {
+        return;
+      }
+    } else if (cacheTouched) {
+      __privateMethod(this, _PartialSyncClientBridge_instances, refreshCachedCountInState_fn).call(this);
+    }
+    inFlight.rows.push(...message.rows);
+  }
+  if (!message.done) return;
+  if (!__privateMethod(this, _PartialSyncClientBridge_instances, isActiveRangeRequest_fn).call(this, message.requestId, inFlight)) return;
+  __privateMethod(this, _PartialSyncClientBridge_instances, replaceServerConfirmedKeysFromRows_fn).call(this, inFlight.rows);
+  __privateGet(this, _inFlightRequests).delete(message.requestId);
+  const result = {
+    rows: inFlight.rows,
+    totalCount: inFlight.totalCount,
+    lastCursor: inFlight.lastCursor,
+    hasMore: inFlight.hasMore
+  };
+  inFlight.resolve(result);
+  __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, {
+    status: __privateGet(this, _connected) ? "realtime" : "partial",
+    cachedCount: this.cachedCount,
+    totalCount: __privateGet(this, _totalCount),
+    cacheUtilization: __privateGet(this, _cacheUtilization)
+  });
+};
+handleRangeUpToDate_fn = function(message) {
+  const inFlight = __privateGet(this, _inFlightRequests).get(message.requestId);
+  if (!inFlight) return;
+  __privateGet(this, _inFlightRequests).delete(message.requestId);
+  __privateSet(this, _totalCount, message.totalCount);
+  inFlight.resolve({
+    rows: [],
+    totalCount: message.totalCount,
+    lastCursor: null,
+    hasMore: false,
+    upToDate: true
+  });
+  __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, {
+    status: __privateGet(this, _connected) ? "realtime" : "partial",
+    cachedCount: this.cachedCount,
+    totalCount: __privateGet(this, _totalCount),
+    cacheUtilization: __privateGet(this, _cacheUtilization)
+  });
+};
+handleRangeDelta_fn = async function(message) {
+  const inFlight = __privateGet(this, _inFlightRequests).get(message.requestId);
+  if (!inFlight) return;
+  const delta = message.changes;
+  await __privateMethod(this, _PartialSyncClientBridge_instances, applyAndTrack_fn).call(this, delta);
+  if (!__privateMethod(this, _PartialSyncClientBridge_instances, isActiveRangeRequest_fn).call(this, message.requestId, inFlight)) return;
+  __privateMethod(this, _PartialSyncClientBridge_instances, mergeServerConfirmedKeysFromMessages_fn).call(this, delta);
+  __privateGet(this, _inFlightRequests).delete(message.requestId);
+  __privateSet(this, _totalCount, message.totalCount);
+  inFlight.resolve({
+    rows: [],
+    totalCount: message.totalCount,
+    lastCursor: message.lastCursor ?? null,
+    hasMore: false,
+    invalidateWindow: true
+  });
+  __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, {
+    status: __privateGet(this, _connected) ? "realtime" : "partial",
+    cachedCount: this.cachedCount,
+    totalCount: __privateGet(this, _totalCount),
+    cacheUtilization: __privateGet(this, _cacheUtilization)
+  });
+};
+handleRangeReconcileResult_fn = async function(message) {
+  const inFlight = __privateGet(this, _inFlightReconcileRequests).get(message.requestId);
+  if (!inFlight) return;
+  const get = this.options.collection.get;
+  const toApply = [
+    ...message.added,
+    ...message.updated
+  ];
+  for (const staleKey of message.stale) {
+    let local;
+    if (get !== void 0) {
+      local = get(staleKey);
+      if (local === void 0 && typeof staleKey === "number") {
+        local = get(String(staleKey));
+      } else if (local === void 0 && typeof staleKey === "string") {
+        const asNum = Number(staleKey);
+        if (!Number.isNaN(asNum)) {
+          local = get(asNum);
+        }
+      }
+    }
+    if (local !== void 0) {
+      const syn = {
+        type: "update",
+        value: local,
+        previousValue: local
+      };
+      this.options.onViewTransition?.({ type: "exitView", change: syn });
+    }
+    toApply.push({ type: "delete", key: staleKey });
+  }
+  if (toApply.length > 0) {
+    await __privateMethod(this, _PartialSyncClientBridge_instances, applyAndTrack_fn).call(this, toApply);
+    if (__privateGet(this, _inFlightReconcileRequests).get(message.requestId) !== inFlight) {
+      return;
+    }
+    __privateMethod(this, _PartialSyncClientBridge_instances, mergeServerConfirmedKeysFromMessages_fn).call(this, toApply);
+  }
+  __privateGet(this, _inFlightReconcileRequests).delete(message.requestId);
+  __privateSet(this, _totalCount, message.totalCount);
+  const addedRows = [];
+  for (const ch of message.added) {
+    if (ch.type === "insert") {
+      addedRows.push(ch.value);
+    }
+  }
+  const updatedRows = [];
+  for (const ch of message.updated) {
+    if (ch.type === "update") {
+      updatedRows.push(ch.value);
+    }
+  }
+  inFlight.resolve({
+    added: addedRows,
+    updated: updatedRows,
+    staleIds: [...message.stale],
+    movedHints: [...message.movedHints],
+    totalCount: message.totalCount
+  });
+  __privateMethod(this, _PartialSyncClientBridge_instances, refreshCachedCountInState_fn).call(this);
+  __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, {
+    status: __privateGet(this, _connected) ? "realtime" : "partial",
+    cachedCount: this.cachedCount,
+    totalCount: __privateGet(this, _totalCount),
+    cacheUtilization: __privateGet(this, _cacheUtilization)
+  });
+};
+refreshCachedCountInState_fn = function() {
+  const s = __privateGet(this, _state);
+  switch (s.status) {
+    case "partial":
+    case "realtime":
+      __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, { ...s, cachedCount: this.cachedCount });
+      break;
+    case "disconnected":
+      __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, {
+        status: "disconnected",
+        cachedCount: this.cachedCount
+      });
+      break;
+    case "evicting":
+      __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, { ...s, cachedCount: this.cachedCount });
+      break;
+    case "connected":
+      if (__privateGet(this, _connected) && this.cachedCount > 0) {
+        __privateMethod(this, _PartialSyncClientBridge_instances, setState_fn).call(this, {
+          status: "realtime",
+          cachedCount: this.cachedCount,
+          totalCount: __privateGet(this, _totalCount),
+          cacheUtilization: __privateGet(this, _cacheUtilization)
+        });
+      }
+      break;
+  }
+};
+drainPendingCoalescedUpdates_fn = async function() {
+  if (__privateGet(this, _pendingCoalescedUpdatesByKey).size === 0) return;
+  const batch = [...__privateGet(this, _pendingCoalescedUpdatesByKey).values()];
+  __privateGet(this, _pendingCoalescedUpdatesByKey).clear();
+  const get = this.options.collection.get;
+  const toApply = get === void 0 ? batch : batch.map((ch) => {
+    if (ch.type !== "update") return ch;
+    const id = ch.value.id;
+    const current = (typeof id === "string" || typeof id === "number" ? get(id) : void 0) ?? get(partialSyncRowKey(id));
+    if (current === void 0) return ch;
+    return { ...ch, previousValue: current };
+  });
+  await __privateMethod(this, _PartialSyncClientBridge_instances, receiveSyncAndTrack_fn).call(this, toApply);
+};
+receiveSyncAndTrack_fn = async function(changes) {
+  if (changes.length === 0) return;
+  await this.options.collection.utils.receiveSync(changes);
+  this.syncTrackedIdsFromMessages(changes);
+};
+applyAndTrack_fn = async function(changes, coalesceSameRowUpdates = false) {
+  if (changes.length === 0) return;
+  if (!coalesceSameRowUpdates) {
+    await __privateMethod(this, _PartialSyncClientBridge_instances, drainPendingCoalescedUpdates_fn).call(this);
+    await __privateMethod(this, _PartialSyncClientBridge_instances, receiveSyncAndTrack_fn).call(this, changes);
+    return;
+  }
+  for (const ch of changes) {
+    if (ch.type !== "update") {
+      await __privateMethod(this, _PartialSyncClientBridge_instances, drainPendingCoalescedUpdates_fn).call(this);
+      await __privateMethod(this, _PartialSyncClientBridge_instances, receiveSyncAndTrack_fn).call(this, changes);
+      return;
+    }
+    __privateGet(this, _pendingCoalescedUpdatesByKey).set(
+      partialSyncRowKey(ch.value.id),
+      ch
+    );
+  }
+};
+setState_fn = function(state) {
+  __privateSet(this, _state, state);
+  this.options.onStateChange?.(state);
+};
+
+export { PartialSyncClientBridge };
+//# sourceMappingURL=chunk-P3JOTUAB.js.map
+//# sourceMappingURL=chunk-P3JOTUAB.js.map