@firtoz/collection-sync 5.0.0 → 6.0.0

package/dist/chunk-RDDS7JQW.js

@@ -0,0 +1,623 @@
+import { DEFAULT_SYNC_COLLECTION_ID } from './chunk-BJJEAKXL.js';
+import { classifyPartialSyncRangePatch, filterSyncMessagesForPredicateRange } from './chunk-6EHROJFY.js';
+import { defaultPredicateColumnValue } from './chunk-3EHHMLSV.js';
+import { partialSyncRowKey, partialSyncRowVersionWatermarkMs } from './chunk-UJ24XW52.js';
+import { __privateAdd, __privateSet, __privateGet, __privateMethod } from './chunk-HMLY7DHA.js';
+import { exhaustiveGuard } from '@firtoz/maybe-error';
+
+function deliveredRowIdKey(id) {
+  return String(partialSyncRowKey(id));
+}
+var _clientStates, _cid, _PartialSyncServerBridge_instances, emit_fn, resetClientInterest_fn, trackDeliveredRowIdsFromRows_fn, trackDeliveredRowIdsFromMessages_fn, applyPatchToDeliveredRowIds_fn, handleRangeQuery_fn, handleRangeReconcile_fn, collectRowsForRange_fn, syncInterestAfterReconcile_fn, handleQueryPredicate_fn, mergeDeliveredRangesFromChanges_fn, handleQueryRange_fn, handleQueryByOffset_fn, getOrCreateClientState_fn, trackDeliveredRange_fn, flushPendingPatches_fn;
+var PartialSyncServerBridge = class {
+  constructor(options) {
+    this.options = options;
+    __privateAdd(this, _PartialSyncServerBridge_instances);
+    __privateAdd(this, _clientStates, /* @__PURE__ */ new Map());
+    __privateAdd(this, _cid);
+    __privateSet(this, _cid, options.collectionId ?? DEFAULT_SYNC_COLLECTION_ID);
+  }
+  get collectionId() {
+    return __privateGet(this, _cid);
+  }
+  async handleClientMessage(message) {
+    const mid = message.collectionId ?? DEFAULT_SYNC_COLLECTION_ID;
+    if (mid !== __privateGet(this, _cid)) return;
+    switch (message.type) {
+      case "ping":
+        __privateMethod(this, _PartialSyncServerBridge_instances, emit_fn).call(this, message.clientId, {
+          type: "pong",
+          timestamp: message.timestamp
+        });
+        return;
+      case "queryRange":
+        await __privateMethod(this, _PartialSyncServerBridge_instances, handleQueryRange_fn).call(this, message);
+        return;
+      case "queryByOffset":
+        await __privateMethod(this, _PartialSyncServerBridge_instances, handleQueryByOffset_fn).call(this, message);
+        return;
+      case "rangeQuery":
+        await __privateMethod(this, _PartialSyncServerBridge_instances, handleRangeQuery_fn).call(this, message);
+        return;
+      case "rangeReconcile":
+        await __privateMethod(this, _PartialSyncServerBridge_instances, handleRangeReconcile_fn).call(this, message);
+        return;
+      case "syncHello":
+      case "mutateBatch":
+        return;
+      default:
+        exhaustiveGuard(message);
+    }
+  }
+  async pushServerChanges(changes, options) {
+    const exclude = options?.excludeClientId;
+    for (const state of __privateGet(this, _clientStates).values()) {
+      if (exclude !== void 0 && state.clientId === exclude) continue;
+      for (const change of changes) {
+        const patch = classifyPartialSyncRangePatch(
+          state.deliveredRanges,
+          state.predicateGroups,
+          change,
+          (row, column) => this.options.store.getSortValue(row, column),
+          (row, column) => defaultPredicateColumnValue(row, column),
+          { deliveredRowIds: state.deliveredRowIds }
+        );
+        if (patch === null) continue;
+        if (state.streaming) {
+          state.pendingPatches.push(patch);
+          continue;
+        }
+        __privateMethod(this, _PartialSyncServerBridge_instances, emit_fn).call(this, state.clientId, {
+          type: "rangePatch",
+          change: patch.change,
+          ...patch.viewTransition !== void 0 ? { viewTransition: patch.viewTransition } : {}
+        });
+        __privateMethod(this, _PartialSyncServerBridge_instances, applyPatchToDeliveredRowIds_fn).call(this, state, patch);
+      }
+    }
+  }
+  /**
+   * Drop partial-sync interest for a disconnected client (prevents unbounded `#clientStates`
+   * growth and stale subscriptions).
+   */
+  removeClient(clientId) {
+    __privateGet(this, _clientStates).delete(clientId);
+  }
+  /**
+   * Replace predicate interest for a client (server-authoritative visibility). Clears sort-range
+   * tracking; the next `rangeQuery` should re-establish delivered ranges from fresh chunks.
+   */
+  setClientVisibility(clientId, conditions) {
+    const state = __privateMethod(this, _PartialSyncServerBridge_instances, getOrCreateClientState_fn).call(this, clientId);
+    state.predicateGroups = [[...conditions]];
+    state.deliveredRanges.length = 0;
+    state.deliveredRowIds.clear();
+  }
+  getClientState(clientId) {
+    return __privateGet(this, _clientStates).get(clientId);
+  }
+};
+_clientStates = new WeakMap();
+_cid = new WeakMap();
+_PartialSyncServerBridge_instances = new WeakSet();
+emit_fn = function(clientId, body) {
+  this.options.sendToClient(clientId, {
+    ...body,
+    collectionId: __privateGet(this, _cid)
+  });
+};
+resetClientInterest_fn = function(state) {
+  state.deliveredRanges.length = 0;
+  state.predicateGroups.length = 0;
+  state.pendingPatches.length = 0;
+  state.deliveredRowIds.clear();
+};
+trackDeliveredRowIdsFromRows_fn = function(state, rows) {
+  for (const row of rows) {
+    state.deliveredRowIds.add(deliveredRowIdKey(row.id));
+  }
+};
+trackDeliveredRowIdsFromMessages_fn = function(state, messages) {
+  for (const c of messages) {
+    if (c.type === "insert" || c.type === "update") {
+      state.deliveredRowIds.add(deliveredRowIdKey(c.value.id));
+    }
+    if (c.type === "delete") {
+      state.deliveredRowIds.delete(deliveredRowIdKey(c.key));
+    }
+    if (c.type === "truncate") {
+      state.deliveredRowIds.clear();
+    }
+  }
+};
+applyPatchToDeliveredRowIds_fn = function(state, patch) {
+  const ch = patch.change;
+  if (ch.type === "truncate") {
+    state.deliveredRowIds.clear();
+    return;
+  }
+  if (ch.type === "delete") {
+    state.deliveredRowIds.delete(deliveredRowIdKey(ch.key));
+    return;
+  }
+  if (ch.type === "insert") {
+    state.deliveredRowIds.add(deliveredRowIdKey(ch.value.id));
+    return;
+  }
+  if (ch.type === "update") {
+    const id = deliveredRowIdKey(ch.value.id);
+    if (patch.viewTransition === "exitView") {
+      state.deliveredRowIds.delete(id);
+    } else {
+      state.deliveredRowIds.add(id);
+    }
+  }
+};
+handleRangeQuery_fn = async function(message) {
+  const { clientId, requestId, fingerprint } = message;
+  let range = message.range;
+  const state = __privateMethod(this, _PartialSyncServerBridge_instances, getOrCreateClientState_fn).call(this, clientId);
+  if (range.kind === "predicate") {
+    __privateMethod(this, _PartialSyncServerBridge_instances, resetClientInterest_fn).call(this, state);
+  } else {
+    state.predicateGroups.length = 0;
+    state.pendingPatches.length = 0;
+  }
+  if (range.kind === "predicate") {
+    const resolved = this.options.resolveClientVisibility !== void 0 ? await this.options.resolveClientVisibility(
+      clientId,
+      range.conditions
+    ) : range.conditions;
+    range = { ...range, conditions: resolved };
+    state.predicateGroups.push([...resolved]);
+  }
+  const rangeLimit = range.kind === "index" ? range.limit : range.limit ?? 200;
+  if (fingerprint !== void 0 && this.options.store.changesSince) {
+    const delta = await this.options.store.changesSince({
+      range,
+      sinceVersion: fingerprint.version,
+      chunkSize: Math.max(1, this.options.queryChunkSize ?? 200)
+    });
+    if (delta !== null) {
+      if (delta.changes.length === 0) {
+        __privateMethod(this, _PartialSyncServerBridge_instances, emit_fn).call(this, clientId, {
+          type: "rangeUpToDate",
+          requestId,
+          totalCount: delta.totalCount
+        });
+        __privateMethod(this, _PartialSyncServerBridge_instances, mergeDeliveredRangesFromChanges_fn).call(this, state, range, delta.changes);
+        return;
+      }
+      const maxDelta = Math.max(1, Math.ceil(rangeLimit * 0.5));
+      if (delta.changes.length <= maxDelta) {
+        const filteredDelta = range.kind === "predicate" ? filterSyncMessagesForPredicateRange(
+          range.conditions,
+          delta.changes,
+          (row, column) => this.options.store.getSortValue(row, column),
+          defaultPredicateColumnValue
+        ) : delta.changes;
+        __privateMethod(this, _PartialSyncServerBridge_instances, emit_fn).call(this, clientId, {
+          type: "rangeDelta",
+          requestId,
+          totalCount: delta.totalCount,
+          changes: filteredDelta
+        });
+        __privateMethod(this, _PartialSyncServerBridge_instances, mergeDeliveredRangesFromChanges_fn).call(this, state, range, filteredDelta);
+        __privateMethod(this, _PartialSyncServerBridge_instances, trackDeliveredRowIdsFromMessages_fn).call(this, state, filteredDelta);
+        return;
+      }
+    }
+  }
+  if (range.kind === "index" && range.mode === "cursor") {
+    await __privateMethod(this, _PartialSyncServerBridge_instances, handleQueryRange_fn).call(this, {
+      type: "queryRange",
+      collectionId: __privateGet(this, _cid),
+      clientId,
+      requestId,
+      sort: range.sort,
+      limit: range.limit,
+      afterCursor: range.afterCursor
+    });
+    return;
+  }
+  if (range.kind === "index" && range.mode === "offset") {
+    await __privateMethod(this, _PartialSyncServerBridge_instances, handleQueryByOffset_fn).call(this, {
+      type: "queryByOffset",
+      collectionId: __privateGet(this, _cid),
+      clientId,
+      requestId,
+      sort: range.sort,
+      limit: range.limit,
+      offset: range.offset
+    });
+    return;
+  }
+  if (range.kind === "predicate") {
+    await __privateMethod(this, _PartialSyncServerBridge_instances, handleQueryPredicate_fn).call(this, message, range);
+    return;
+  }
+  exhaustiveGuard(range);
+};
+handleRangeReconcile_fn = async function(message) {
+  const { clientId, requestId, manifest } = message;
+  let range = message.range;
+  const state = __privateMethod(this, _PartialSyncServerBridge_instances, getOrCreateClientState_fn).call(this, clientId);
+  if (range.kind === "predicate") {
+    __privateMethod(this, _PartialSyncServerBridge_instances, resetClientInterest_fn).call(this, state);
+  } else {
+    state.predicateGroups.length = 0;
+    state.pendingPatches.length = 0;
+  }
+  if (range.kind === "predicate") {
+    const resolved = this.options.resolveClientVisibility !== void 0 ? await this.options.resolveClientVisibility(
+      clientId,
+      range.conditions
+    ) : range.conditions;
+    range = { ...range, conditions: resolved };
+    state.predicateGroups.push([...resolved]);
+  }
+  const { rows, totalCount } = await __privateMethod(this, _PartialSyncServerBridge_instances, collectRowsForRange_fn).call(this, range);
+  const byKey = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    byKey.set(deliveredRowIdKey(row.id), row);
+  }
+  const manifestKeys = new Set(
+    manifest.map((m) => String(partialSyncRowKey(m.id)))
+  );
+  const added = [];
+  const updated = [];
+  const stale = [];
+  const movedHints = [];
+  for (const row of rows) {
+    const k = deliveredRowIdKey(row.id);
+    if (!manifestKeys.has(k)) {
+      added.push({ type: "insert", value: row });
+    }
+  }
+  for (const entry of manifest) {
+    const k = String(partialSyncRowKey(entry.id));
+    const serverRow = byKey.get(k);
+    if (serverRow === void 0) {
+      stale.push(entry.id);
+      const getRow = this.options.store.getRow;
+      const resolveMovedHint = this.options.resolveMovedHint;
+      if (getRow !== void 0 && resolveMovedHint !== void 0) {
+        const current = await getRow(entry.id);
+        if (current !== void 0) {
+          const hint = await resolveMovedHint(current, range);
+          if (hint !== null) {
+            movedHints.push({ id: entry.id, hint });
+          }
+        }
+      }
+      continue;
+    }
+    const serverV = partialSyncRowVersionWatermarkMs(serverRow);
+    if (serverV !== entry.version) {
+      updated.push({
+        type: "update",
+        value: serverRow,
+        previousValue: {
+          ...serverRow,
+          updatedAt: entry.version
+        }
+      });
+    }
+  }
+  __privateMethod(this, _PartialSyncServerBridge_instances, syncInterestAfterReconcile_fn).call(this, state, range, rows);
+  __privateMethod(this, _PartialSyncServerBridge_instances, emit_fn).call(this, clientId, {
+    type: "rangeReconcileResult",
+    requestId,
+    added,
+    updated,
+    stale,
+    movedHints,
+    totalCount
+  });
+};
+collectRowsForRange_fn = async function(range) {
+  const chunkSize = Math.max(1, this.options.queryChunkSize ?? 200);
+  if (range.kind === "predicate") {
+    const queryByPredicate = this.options.store.queryByPredicate;
+    if (!queryByPredicate) {
+      return {
+        rows: [],
+        totalCount: await this.options.store.getTotalCount()
+      };
+    }
+    const limit = range.limit ?? chunkSize;
+    const totalCount = this.options.store.getPredicateCount ? await this.options.store.getPredicateCount(range.conditions) : await this.options.store.getTotalCount();
+    const rows = [];
+    for await (const chunk of queryByPredicate({
+      conditions: range.conditions,
+      sort: range.sort,
+      limit,
+      chunkSize
+    })) {
+      rows.push(...chunk);
+      if (rows.length >= limit) break;
+    }
+    return { rows: rows.slice(0, limit), totalCount };
+  }
+  if (range.kind === "index" && range.mode === "offset") {
+    const totalCount = await this.options.store.getTotalCount();
+    const rows = [];
+    for await (const chunk of this.options.store.queryByOffset({
+      sort: range.sort,
+      limit: range.limit,
+      offset: range.offset,
+      chunkSize
+    })) {
+      rows.push(...chunk);
+      if (rows.length >= range.limit) break;
+    }
+    return { rows: rows.slice(0, range.limit), totalCount };
+  }
+  if (range.kind === "index" && range.mode === "cursor") {
+    const totalCount = await this.options.store.getTotalCount();
+    const rows = [];
+    for await (const chunk of this.options.store.queryRange({
+      sort: range.sort,
+      limit: range.limit,
+      afterCursor: range.afterCursor,
+      chunkSize
+    })) {
+      rows.push(...chunk);
+      if (rows.length >= range.limit) break;
+    }
+    return { rows: rows.slice(0, range.limit), totalCount };
+  }
+  exhaustiveGuard(range);
+};
+syncInterestAfterReconcile_fn = function(state, range, rows) {
+  state.deliveredRowIds.clear();
+  for (const row of rows) {
+    state.deliveredRowIds.add(deliveredRowIdKey(row.id));
+  }
+  state.deliveredRanges.length = 0;
+  const sort = range.kind === "index" ? range.sort : range.kind === "predicate" ? range.sort : void 0;
+  if (sort !== void 0 && rows.length > 0) {
+    __privateMethod(this, _PartialSyncServerBridge_instances, trackDeliveredRange_fn).call(this, state, sort, null, rows);
+  }
+};
+handleQueryPredicate_fn = async function(message, range) {
+  const queryByPredicate = this.options.store.queryByPredicate;
+  if (!queryByPredicate) {
+    const totalCount2 = await this.options.store.getTotalCount();
+    __privateMethod(this, _PartialSyncServerBridge_instances, emit_fn).call(this, message.clientId, {
+      type: "queryRangeChunk",
+      requestId: message.requestId,
+      rows: [],
+      totalCount: totalCount2,
+      lastCursor: null,
+      hasMore: false,
+      chunkIndex: 0,
+      done: true
+    });
+    return;
+  }
+  const state = __privateMethod(this, _PartialSyncServerBridge_instances, getOrCreateClientState_fn).call(this, message.clientId);
+  state.streaming = true;
+  const chunkSize = Math.max(1, this.options.queryChunkSize ?? 200);
+  const limit = range.limit ?? chunkSize;
+  const totalCount = this.options.store.getPredicateCount ? await this.options.store.getPredicateCount(range.conditions) : await this.options.store.getTotalCount();
+  const iterable = queryByPredicate({
+    conditions: range.conditions,
+    sort: range.sort,
+    limit,
+    chunkSize
+  });
+  let chunkIndex = 0;
+  let totalDelivered = 0;
+  let emittedAny = false;
+  const sortForTrack = range.sort;
+  for await (const rows of iterable) {
+    emittedAny = true;
+    totalDelivered += rows.length;
+    const reachedLimit = totalDelivered >= limit;
+    const likelyFinalChunk = rows.length < chunkSize || reachedLimit;
+    const isFinalChunk = likelyFinalChunk;
+    const lastRow = rows[rows.length - 1];
+    const lastCursor = lastRow === void 0 || sortForTrack === void 0 ? null : this.options.store.getSortValue(lastRow, sortForTrack.column);
+    const hasMoreForClient = isFinalChunk ? totalDelivered === limit && totalDelivered < totalCount : true;
+    __privateMethod(this, _PartialSyncServerBridge_instances, emit_fn).call(this, message.clientId, {
+      type: "queryRangeChunk",
+      requestId: message.requestId,
+      rows,
+      totalCount,
+      lastCursor,
+      hasMore: hasMoreForClient,
+      chunkIndex,
+      done: isFinalChunk
+    });
+    if (sortForTrack !== void 0) {
+      __privateMethod(this, _PartialSyncServerBridge_instances, trackDeliveredRange_fn).call(this, state, sortForTrack, null, rows);
+    }
+    __privateMethod(this, _PartialSyncServerBridge_instances, trackDeliveredRowIdsFromRows_fn).call(this, state, rows);
+    chunkIndex += 1;
+    if (isFinalChunk) break;
+  }
+  if (!emittedAny) {
+    __privateMethod(this, _PartialSyncServerBridge_instances, emit_fn).call(this, message.clientId, {
+      type: "queryRangeChunk",
+      requestId: message.requestId,
+      rows: [],
+      totalCount,
+      lastCursor: null,
+      hasMore: false,
+      chunkIndex,
+      done: true
+    });
+  }
+  state.streaming = false;
+  __privateMethod(this, _PartialSyncServerBridge_instances, flushPendingPatches_fn).call(this, state);
+};
+mergeDeliveredRangesFromChanges_fn = function(state, range, changes) {
+  const sort = range.kind === "index" ? range.sort : range.kind === "predicate" ? range.sort : void 0;
+  if (sort === void 0) return;
+  const rows = [];
+  for (const change of changes) {
+    if (change.type === "insert" || change.type === "update") {
+      rows.push(change.value);
+    }
+  }
+  if (rows.length === 0) return;
+  __privateMethod(this, _PartialSyncServerBridge_instances, trackDeliveredRange_fn).call(this, state, sort, null, rows);
+  __privateMethod(this, _PartialSyncServerBridge_instances, trackDeliveredRowIdsFromRows_fn).call(this, state, rows);
+};
+handleQueryRange_fn = async function(message) {
+  const state = __privateMethod(this, _PartialSyncServerBridge_instances, getOrCreateClientState_fn).call(this, message.clientId);
+  state.streaming = true;
+  const totalCount = await this.options.store.getTotalCount();
+  const chunkSize = Math.max(1, this.options.queryChunkSize ?? 200);
+  const iterable = this.options.store.queryRange({
+    sort: message.sort,
+    limit: message.limit,
+    afterCursor: message.afterCursor,
+    chunkSize
+  });
+  let chunkIndex = 0;
+  let totalDelivered = 0;
+  let emittedAny = false;
+  for await (const rows of iterable) {
+    emittedAny = true;
+    totalDelivered += rows.length;
+    const reachedLimit = totalDelivered >= message.limit;
+    const likelyFinalChunk = rows.length < chunkSize || reachedLimit;
+    const isFinalChunk = likelyFinalChunk;
+    const lastRow = rows[rows.length - 1];
+    const lastCursor = lastRow === void 0 ? message.afterCursor : this.options.store.getSortValue(lastRow, message.sort.column);
+    const hasMoreForClient = isFinalChunk ? totalDelivered === message.limit && totalDelivered < totalCount : true;
+    __privateMethod(this, _PartialSyncServerBridge_instances, emit_fn).call(this, message.clientId, {
+      type: "queryRangeChunk",
+      requestId: message.requestId,
+      rows,
+      totalCount,
+      lastCursor,
+      hasMore: hasMoreForClient,
+      chunkIndex,
+      done: isFinalChunk
+    });
+    __privateMethod(this, _PartialSyncServerBridge_instances, trackDeliveredRange_fn).call(this, state, message.sort, message.afterCursor, rows);
+    __privateMethod(this, _PartialSyncServerBridge_instances, trackDeliveredRowIdsFromRows_fn).call(this, state, rows);
+    chunkIndex += 1;
+    if (isFinalChunk) {
+      break;
+    }
+  }
+  if (!emittedAny) {
+    __privateMethod(this, _PartialSyncServerBridge_instances, emit_fn).call(this, message.clientId, {
+      type: "queryRangeChunk",
+      requestId: message.requestId,
+      rows: [],
+      totalCount,
+      lastCursor: message.afterCursor,
+      hasMore: false,
+      chunkIndex,
+      done: true
+    });
+  }
+  state.streaming = false;
+  __privateMethod(this, _PartialSyncServerBridge_instances, flushPendingPatches_fn).call(this, state);
+};
+handleQueryByOffset_fn = async function(message) {
+  const state = __privateMethod(this, _PartialSyncServerBridge_instances, getOrCreateClientState_fn).call(this, message.clientId);
+  state.streaming = true;
+  const totalCount = await this.options.store.getTotalCount();
+  const chunkSize = Math.max(1, this.options.queryChunkSize ?? 200);
+  const iterable = this.options.store.queryByOffset({
+    sort: message.sort,
+    limit: message.limit,
+    offset: message.offset,
+    chunkSize
+  });
+  let chunkIndex = 0;
+  let totalDelivered = 0;
+  let emittedAny = false;
+  for await (const rows of iterable) {
+    emittedAny = true;
+    totalDelivered += rows.length;
+    const reachedLimit = totalDelivered >= message.limit;
+    const likelyFinalChunk = rows.length < chunkSize || reachedLimit;
+    const isFinalChunk = likelyFinalChunk;
+    const lastRow = rows[rows.length - 1];
+    const lastCursor = lastRow === void 0 ? null : this.options.store.getSortValue(lastRow, message.sort.column);
+    const hasMoreForClient = isFinalChunk ? totalDelivered === message.limit && message.offset + totalDelivered < totalCount : true;
+    __privateMethod(this, _PartialSyncServerBridge_instances, emit_fn).call(this, message.clientId, {
+      type: "queryRangeChunk",
+      requestId: message.requestId,
+      rows,
+      totalCount,
+      lastCursor,
+      hasMore: hasMoreForClient,
+      chunkIndex,
+      done: isFinalChunk
+    });
+    __privateMethod(this, _PartialSyncServerBridge_instances, trackDeliveredRange_fn).call(this, state, message.sort, null, rows);
+    __privateMethod(this, _PartialSyncServerBridge_instances, trackDeliveredRowIdsFromRows_fn).call(this, state, rows);
+    chunkIndex += 1;
+    if (isFinalChunk) {
+      break;
+    }
+  }
+  if (!emittedAny) {
+    __privateMethod(this, _PartialSyncServerBridge_instances, emit_fn).call(this, message.clientId, {
+      type: "queryRangeChunk",
+      requestId: message.requestId,
+      rows: [],
+      totalCount,
+      lastCursor: null,
+      hasMore: false,
+      chunkIndex,
+      done: true
+    });
+  }
+  state.streaming = false;
+  __privateMethod(this, _PartialSyncServerBridge_instances, flushPendingPatches_fn).call(this, state);
+};
+getOrCreateClientState_fn = function(clientId) {
+  let state = __privateGet(this, _clientStates).get(clientId);
+  if (!state) {
+    state = {
+      clientId,
+      deliveredRanges: [],
+      predicateGroups: [],
+      deliveredRowIds: /* @__PURE__ */ new Set(),
+      pendingPatches: [],
+      streaming: false
+    };
+    __privateGet(this, _clientStates).set(clientId, state);
+  }
+  return state;
+};
+trackDeliveredRange_fn = function(state, sort, afterCursor, rows) {
+  if (rows.length === 0) return;
+  const firstValue = afterCursor ?? this.options.store.getSortValue(rows[0], sort.column);
+  const lastValue = this.options.store.getSortValue(
+    rows[rows.length - 1],
+    sort.column
+  );
+  const range = {
+    sortColumn: sort.column,
+    sortDirection: sort.direction,
+    fromValue: firstValue,
+    toValue: lastValue
+  };
+  state.deliveredRanges.push(range);
+};
+flushPendingPatches_fn = function(state) {
+  if (state.pendingPatches.length === 0) return;
+  for (const patch of state.pendingPatches) {
+    __privateMethod(this, _PartialSyncServerBridge_instances, emit_fn).call(this, state.clientId, {
+      type: "rangePatch",
+      change: patch.change,
+      ...patch.viewTransition !== void 0 ? { viewTransition: patch.viewTransition } : {}
+    });
+    __privateMethod(this, _PartialSyncServerBridge_instances, applyPatchToDeliveredRowIds_fn).call(this, state, patch);
+  }
+  state.pendingPatches.length = 0;
+};
+
+export { PartialSyncServerBridge };
+//# sourceMappingURL=chunk-RDDS7JQW.js.map
+//# sourceMappingURL=chunk-RDDS7JQW.js.map