powersync-bridge 0.0.1-alpha.0 → 0.0.1-alpha.1

package/dist/index.cjs

@@ -24,6 +24,68 @@ async function withTimeout(clock, p, ms, signal) {
   }
 }
 
+// src/keyset.ts
+function keyColumns(orderKey) {
+  if (typeof orderKey === "string") return [orderKey, "id"];
+  return [orderKey[0], orderKey[1]];
+}
+function idOf(row) {
+  const r = row;
+  if (r == null || r.id === void 0 || r.id === null) {
+    throw new Error("powersync-bridge: every row must have an `id`");
+  }
+  return String(r.id);
+}
+function compareValues(a, b) {
+  if (a === b) return 0;
+  if (a === null || a === void 0) return 1;
+  if (b === null || b === void 0) return -1;
+  if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (typeof a === "boolean" && typeof b === "boolean") return Number(a) - Number(b);
+  const sa = String(a);
+  const sb = String(b);
+  return sa < sb ? -1 : sa > sb ? 1 : 0;
+}
+function rowComparator(orderKey, direction = "asc") {
+  const [k1, k2] = keyColumns(orderKey);
+  const sign = direction === "desc" ? -1 : 1;
+  return (a, b) => {
+    const c1 = compareValues(a[k1], b[k1]);
+    if (c1 !== 0) return c1 * sign;
+    return compareValues(a[k2], b[k2]) * sign;
+  };
+}
+function cursorOfRow(row, orderKey) {
+  const r = row;
+  if (typeof orderKey === "string") return r[orderKey];
+  return [r[orderKey[0]], r[orderKey[1]]];
+}
+function isAfterCursor(row, cursor, orderKey, direction = "asc") {
+  const [k1, k2] = keyColumns(orderKey);
+  const r = row;
+  const sign = direction === "desc" ? -1 : 1;
+  const [c1, c2] = typeof orderKey === "string" ? [cursor, void 0] : cursor;
+  const d1 = compareValues(r[k1], c1) * sign;
+  if (d1 !== 0) return d1 > 0;
+  if (c2 === void 0) return false;
+  return compareValues(r[k2], c2) * sign > 0;
+}
+function toBase64(s) {
+  if (typeof btoa === "function") return btoa(unescape(encodeURIComponent(s)));
+  return Buffer.from(s, "utf8").toString("base64");
+}
+function fromBase64(s) {
+  if (typeof atob === "function") return decodeURIComponent(escape(atob(s)));
+  return Buffer.from(s, "base64").toString("utf8");
+}
+function encodeCursor(cursor) {
+  return toBase64(JSON.stringify(cursor));
+}
+function decodeCursor(opaque) {
+  return JSON.parse(fromBase64(opaque));
+}
+
 // src/removal.ts
 var PROBE_CHUNK = 500;
 async function probePresence(driver, table, ids) {
@@ -75,13 +137,14 @@ var SnapshotStore = class {
   constructor(initial) {
     this.snapshot = initial;
   }
-  getSnapshot() {
+  // React invokes external-store callbacks as standalone functions.
+  getSnapshot = () => {
     return this.snapshot;
-  }
-  subscribe(listener) {
+  };
+  subscribe = (listener) => {
     this.listeners.add(listener);
     return () => this.listeners.delete(listener);
-  }
+  };
   replace(next) {
     if (Object.is(next, this.snapshot)) return;
     this.snapshot = next;
@@ -112,6 +175,496 @@ function shallowEqualResult(a, b) {
   return true;
 }
 
+// src/query.ts
+var infiniteQueryKey = (options) => JSON.stringify([
+  options.queryKey,
+  options.orderBy,
+  options.direction ?? "desc",
+  options.pageSize ?? 25,
+  options.maxRows ?? 500,
+  options.enabled !== false
+]);
+var OfflineError = class extends Error {
+  name = "OfflineError";
+  constructor() {
+    super("Additional records require a connection.");
+  }
+};
+var InfiniteQueryStore = class {
+  constructor(deps, options) {
+    this.deps = deps;
+    this.options = options;
+    this.pageSize = options.pageSize ?? 25;
+    this.maxRows = options.maxRows ?? 500;
+    if (!Number.isInteger(this.pageSize) || this.pageSize < 1 || !Number.isInteger(this.maxRows) || this.maxRows < this.pageSize)
+      throw new Error("powersync-bridge: pageSize must be positive and maxRows must be at least pageSize");
+    this.target = this.pageSize;
+    this.compare = rowComparator(options.orderBy, options.direction ?? "desc");
+    this.table = options.table;
+    this.offline = this.readOffline();
+    this.store = new SnapshotStore(this.result());
+  }
+  deps;
+  options;
+  store;
+  pageSize;
+  maxRows;
+  compare;
+  table;
+  target;
+  anchor;
+  revision = 0;
+  local = /* @__PURE__ */ new Map();
+  retained = /* @__PURE__ */ new Map();
+  tombstones = /* @__PURE__ */ new Set();
+  filtered = /* @__PURE__ */ new Set();
+  inSession = /* @__PURE__ */ new Set();
+  pages = [];
+  localPending = true;
+  localStamp = Number.NEGATIVE_INFINITY;
+  localError;
+  apiError;
+  apiPending = false;
+  apiFailed = false;
+  offline;
+  generation = 0;
+  watchGeneration = 0;
+  lastLocalWatch = 0;
+  refs = 0;
+  ready = false;
+  disposed = false;
+  unwatch;
+  stops = [];
+  request;
+  requestKey;
+  get isDisposed() {
+    return this.disposed || this.refs <= 0 && this.unwatch !== void 0;
+  }
+  retain() {
+    this.refs += 1;
+    if (this.refs !== 1 || this.unwatch || this.options.enabled === false) return;
+    this.stops = [
+      this.deps.crud.onChange(() => this.render()),
+      this.deps.freshness.onCompletion(() => void this.checkpoint()),
+      this.deps.driver.onStatusChanged(() => this.networkChanged()),
+      this.deps.connectivity.subscribe(() => this.networkChanged())
+    ];
+    this.watch();
+    void this.deps.crud.ready().then(() => {
+      this.ready = true;
+      this.pump();
+    }).catch((error) => {
+      if (this.disposed) return;
+      this.localPending = false;
+      this.localError = error instanceof Error ? error : new Error(String(error));
+      this.render();
+    });
+  }
+  release() {
+    this.refs -= 1;
+    if (this.refs <= 0)
+      queueMicrotask(() => {
+        if (this.refs <= 0) this.dispose();
+      });
+  }
+  swapRoot() {
+    this.disposed = true;
+    this.local.clear();
+    this.retained.clear();
+    this.clearPages();
+    this.render(true);
+  }
+  dispose() {
+    this.disposed = true;
+    this.generation += 1;
+    this.watchGeneration += 1;
+    this.cancelRequest();
+    this.unwatch?.();
+    this.unwatch = void 0;
+    for (const stop of this.stops) stop();
+    this.stops = [];
+    this.clearPages();
+    this.local.clear();
+    this.retained.clear();
+    this.tombstones.clear();
+    this.filtered.clear();
+    this.inSession.clear();
+    this.render(true);
+  }
+  readOffline() {
+    return (this.deps.connectivity.getSnapshot() ?? this.deps.driver.onlineHint()) === false;
+  }
+  cancelRequest() {
+    this.request?.abort();
+    if (this.requestKey) this.deps.snapshots.invalidate(this.requestKey);
+    this.requestKey = void 0;
+  }
+  networkChanged() {
+    if (this.disposed) return;
+    const offline = this.readOffline();
+    const reconnect = this.offline && !offline;
+    this.offline = offline;
+    if (offline && this.request) {
+      this.cancelRequest();
+      this.generation += 1;
+      this.apiPending = false;
+      this.request = void 0;
+    }
+    if (reconnect) {
+      this.apiFailed = false;
+      this.apiError = void 0;
+      this.pump();
+    }
+    this.render();
+  }
+  identity(row) {
+    if (this.options.getRowIdentity) return this.options.getRowIdentity(row);
+    if (!this.table)
+      throw new Error(
+        "powersync-bridge: provide table or getRowIdentity when the adapter cannot infer the business table"
+      );
+    return { table: this.table, id: idOf(row) };
+  }
+  pending(row) {
+    const { table, id } = this.identity(row);
+    return Boolean(
+      this.deps.crud.pendingOp(table, id) || this.pages.some((page) => this.deps.crud.pendingOp(table, id, page.window))
+    );
+  }
+  localBuilder() {
+    return this.options.query({ cursor: this.anchor, limit: this.target + 1 });
+  }
+  watch() {
+    this.unwatch?.();
+    const token = ++this.watchGeneration;
+    const generation = this.generation;
+    this.localPending = true;
+    let prepared;
+    try {
+      prepared = this.deps.adapter.prepare(this.localBuilder());
+      if (!this.table && prepared.tables.length === 1) this.table = prepared.tables[0];
+      if (!this.table && !this.options.getRowIdentity)
+        throw new Error(
+          "powersync-bridge: provide table or getRowIdentity when the adapter cannot infer the business table"
+        );
+    } catch (error) {
+      this.localPending = false;
+      this.localError = error instanceof Error ? error : new Error(String(error));
+      this.render();
+      return;
+    }
+    this.unwatch = this.deps.driver.diffs(prepared).subscribe(
+      (diff) => {
+        void this.acceptLocal(diff.all, token, generation).catch((error) => {
+          if (token !== this.watchGeneration || generation !== this.generation || this.disposed) return;
+          this.localPending = false;
+          this.localError = error instanceof Error ? error : new Error(String(error));
+          this.render();
+        });
+      },
+      (error) => {
+        if (token !== this.watchGeneration || generation !== this.generation || this.disposed) return;
+        this.localPending = false;
+        this.localError = error;
+        this.render();
+      }
+    );
+    this.render();
+  }
+  async acceptLocal(rows, token, generation) {
+    await this.deps.crud.resync();
+    if (token !== this.watchGeneration || generation !== this.generation || this.disposed) return;
+    const previous = this.local;
+    const firstEmission = this.lastLocalWatch !== token;
+    this.lastLocalWatch = token;
+    const next = new Map(rows.map((row) => [idOf(row), row]));
+    const removed = /* @__PURE__ */ new Map();
+    for (const [id, row] of previous)
+      if (!next.has(id)) {
+        removed.set(id, row);
+        this.tombstones.add(id);
+      }
+    for (const [id, row] of next) {
+      if (previous.size && (!firstEmission || previous.has(id)) && JSON.stringify(previous.get(id)) !== JSON.stringify(row) && !this.pending(row))
+        this.inSession.add(id);
+      this.tombstones.delete(id);
+      this.filtered.delete(id);
+      this.retained.delete(id);
+    }
+    this.local = next;
+    this.localPending = false;
+    this.localError = void 0;
+    this.localStamp = this.deps.freshness.freshAtFor(void 0);
+    this.render();
+    const groups = /* @__PURE__ */ new Map();
+    for (const row of removed.values()) {
+      const identity = this.identity(row);
+      const group = groups.get(identity.table) ?? /* @__PURE__ */ new Map();
+      group.set(identity.id, row);
+      groups.set(identity.table, group);
+    }
+    try {
+      for (const [table, group] of groups) {
+        const classes = await classifyRemovals(
+          {
+            driver: this.deps.driver,
+            clock: this.deps.clock,
+            table,
+            provenance: () => void 0,
+            isInWindow: this.options.isInWindow
+          },
+          group
+        );
+        if (token !== this.watchGeneration || generation !== this.generation || this.disposed) return;
+        for (const row of removed.values()) {
+          const identity = this.identity(row);
+          if (identity.table !== table || this.local.has(row.id)) continue;
+          const classification = classes.get(identity.id);
+          if (!classification) continue;
+          if (classification === "delete") this.tombstones.add(row.id);
+          else if (classification === "filtered") {
+            this.tombstones.delete(row.id);
+            this.filtered.add(row.id);
+          } else {
+            this.tombstones.delete(row.id);
+            this.retained.set(row.id, row);
+          }
+        }
+      }
+    } catch (error) {
+      if (token !== this.watchGeneration || generation !== this.generation || this.disposed) return;
+      this.localError = error instanceof Error ? error : new Error(String(error));
+    }
+    const retained = [...this.retained.values()].sort(this.compare).slice(0, this.maxRows);
+    this.retained.clear();
+    for (const row of retained) this.retained.set(row.id, row);
+    const known = /* @__PURE__ */ new Set([
+      ...this.local.keys(),
+      ...this.retained.keys(),
+      ...this.pages.flatMap((page) => page.rows.map((row) => row.id))
+    ]);
+    for (const set of [this.inSession, this.tombstones, this.filtered]) {
+      if (set.size > this.maxRows * 4) {
+        for (const id of set) if (!known.has(id)) set.delete(id);
+      }
+    }
+    this.render();
+  }
+  async checkpoint() {
+    if (this.disposed || !this.unwatch) return;
+    const token = this.watchGeneration;
+    const generation = this.generation;
+    try {
+      const rows = await this.deps.driver.query(this.deps.adapter.prepare(this.localBuilder()));
+      await this.acceptLocal(rows, token, generation);
+    } catch (error) {
+      if (token !== this.watchGeneration || generation !== this.generation || this.disposed) return;
+      this.localError = error instanceof Error ? error : new Error(String(error));
+      this.render();
+    }
+  }
+  clearPages() {
+    for (const page of this.pages) this.deps.crud.closeWindow(page.window);
+    this.pages = [];
+  }
+  apiEnd() {
+    return this.pages.at(-1)?.end === true;
+  }
+  apiCount() {
+    return this.pages.reduce((count, page) => count + page.rows.length, 0);
+  }
+  apiCursor() {
+    const last = this.pages.at(-1)?.rows.at(-1);
+    return last ? last : this.anchor;
+  }
+  cursorKey(row) {
+    if (!row) return void 0;
+    const [first, second] = keyColumns(this.options.orderBy);
+    return [row[first], row[second]];
+  }
+  pump() {
+    if (!this.ready || this.disposed || this.options.enabled === false || this.offline || this.apiPending || this.apiFailed || this.apiEnd())
+      return;
+    if (!this.table && !this.options.getRowIdentity) return;
+    if (this.pages.length >= Math.ceil(this.maxRows / this.pageSize) + 1) return;
+    if (this.apiCount() >= this.target && this.entries().length >= this.target) return;
+    const cursor = this.apiCursor();
+    const generation = this.generation;
+    const request = new AbortController();
+    this.request = request;
+    const window = this.deps.crud.openWindow();
+    this.apiPending = true;
+    this.render();
+    const key = [
+      "powersync-bridge.query",
+      this.deps.identityKey,
+      this.deps.epoch,
+      infiniteQueryKey(this.options),
+      this.cursorKey(this.anchor),
+      this.revision,
+      generation,
+      this.cursorKey(cursor)
+    ];
+    this.requestKey = key;
+    void this.deps.snapshots.fetch(key, this.options.staleTime ?? 6e4, async (signal) => {
+      const abort = () => request.abort();
+      signal.addEventListener("abort", abort, { once: true });
+      try {
+        return await withTimeout(
+          this.deps.clock,
+          this.options.fetchPage({ cursor, limit: this.pageSize + 1, signal: request.signal }).then((rows) => ({ rows })),
+          3e4,
+          request.signal
+        );
+      } finally {
+        signal.removeEventListener("abort", abort);
+      }
+    }).then((record) => {
+      if (this.disposed || generation !== this.generation || request.signal.aborted) {
+        this.deps.crud.closeWindow(window);
+        return;
+      }
+      const rows = [...record.rows];
+      for (let index = 1; index < rows.length; index++) {
+        const before = rows[index - 1];
+        const row = rows[index];
+        if (before && row && this.compare(before, row) >= 0)
+          throw new Error("powersync-bridge: API rows must use a strict, stable order with an id tiebreaker");
+      }
+      if (cursor !== void 0 && rows.some((row) => this.compare(row, cursor) <= 0))
+        throw new Error("powersync-bridge: API page must advance beyond the supplied cursor");
+      this.pages.push({
+        cursor,
+        rows: rows.slice(0, this.pageSize),
+        end: rows.length <= this.pageSize,
+        fetchedAt: record.fetchedAt,
+        window
+      });
+      this.apiError = void 0;
+    }).catch((error) => {
+      this.deps.crud.closeWindow(window);
+      if (this.disposed || generation !== this.generation || request.signal.aborted) return;
+      this.apiFailed = true;
+      this.apiError = error instanceof Error ? error : new Error(String(error));
+      request.abort();
+    }).finally(() => {
+      if (generation !== this.generation || this.disposed) return;
+      this.apiPending = false;
+      this.request = void 0;
+      this.requestKey = void 0;
+      this.render();
+      this.pump();
+    });
+  }
+  entries() {
+    const api = /* @__PURE__ */ new Map();
+    for (const page of this.pages) for (const row of page.rows) api.set(row.id, { row, page });
+    const ids = /* @__PURE__ */ new Set([...this.local.keys(), ...this.retained.keys(), ...api.keys()]);
+    const entries = [];
+    for (const id of ids) {
+      if (this.tombstones.has(id) || this.filtered.has(id)) continue;
+      const local = this.local.get(id);
+      const remote = api.get(id);
+      const row = local ?? remote?.row ?? this.retained.get(id);
+      if (!row) continue;
+      if (this.pending(row)) {
+        if (local) entries.push({ row: local, origin: "local", presentLocally: true });
+        continue;
+      }
+      if (remote) {
+        entries.push(
+          local && this.localStamp > remote.page.fetchedAt ? { row: local, origin: "local", presentLocally: true } : { row: remote.row, origin: "api", presentLocally: Boolean(local) }
+        );
+      } else if (local) {
+        const covering = this.pages.find((page) => {
+          if (page.cursor !== void 0 && this.compare(local, page.cursor) <= 0) return false;
+          const last = page.rows.at(-1);
+          return page.end || Boolean(last && this.compare(local, last) <= 0);
+        });
+        if (!covering || this.inSession.has(id) || this.localStamp > covering.fetchedAt)
+          entries.push({ row: local, origin: "local", presentLocally: true });
+      } else entries.push({ row, origin: "local", presentLocally: false });
+    }
+    return entries.sort((a, b) => this.compare(a.row, b.row));
+  }
+  result(empty = false) {
+    const enabled = !empty && this.options.enabled !== false;
+    const entries = enabled ? this.entries() : [];
+    const items = entries.slice(0, this.target);
+    const more = entries.length > this.target || !this.apiEnd();
+    const missing = items.length < this.target;
+    const errors = {};
+    if (this.localError) errors.local = this.localError;
+    if (this.apiError) errors.api = this.apiError;
+    const offlineError = this.offline && missing && !this.localPending ? new OfflineError() : void 0;
+    const error = enabled && missing && !this.localPending && !this.apiPending ? this.localError ?? this.apiError ?? offlineError : void 0;
+    return {
+      data: items.map((item) => item.row),
+      items,
+      isLoading: enabled && items.length === 0 && !error && (this.localPending || this.apiPending),
+      isFetching: enabled && (this.localPending || this.apiPending),
+      isFetchingNextPage: enabled && this.target > this.pageSize && (this.localPending || this.apiPending),
+      hasNextPage: enabled && this.target < this.maxRows && more,
+      needsOlderWindow: enabled && items.length >= this.maxRows && more,
+      error,
+      errors,
+      isError: Boolean(error),
+      windowRevision: this.revision
+    };
+  }
+  render(empty = false) {
+    if (this.disposed && !empty) return;
+    const result = this.result(empty);
+    if (!shallowEqualResult(
+      this.store.getSnapshot(),
+      result
+    ))
+      this.store.replace(result);
+  }
+  fetchNextPage = () => {
+    if (this.disposed || this.options.enabled === false || this.target >= this.maxRows) return;
+    if (!this.store.getSnapshot().hasNextPage) return;
+    this.target = Math.min(this.target + this.pageSize, this.maxRows);
+    this.watch();
+    this.pump();
+  };
+  retry = () => {
+    if (this.disposed || this.options.enabled === false) return;
+    this.apiFailed = false;
+    this.apiError = void 0;
+    this.watch();
+    this.pump();
+  };
+  refresh = () => {
+    this.reset(this.anchor);
+  };
+  continueOlder = () => {
+    const last = this.store.getSnapshot().data.at(-1);
+    if (last) this.reset(last);
+  };
+  reset(anchor) {
+    if (this.disposed || this.options.enabled === false) return;
+    this.generation += 1;
+    this.cancelRequest();
+    this.request = void 0;
+    this.apiPending = false;
+    this.apiFailed = false;
+    this.apiError = void 0;
+    this.localError = void 0;
+    this.clearPages();
+    this.local.clear();
+    this.retained.clear();
+    this.inSession.clear();
+    this.tombstones.clear();
+    this.filtered.clear();
+    this.target = this.pageSize;
+    this.anchor = anchor;
+    this.revision += 1;
+    this.watch();
+    this.pump();
+  }
+};
+
 // src/flagger.ts
 var AutoSyncFlagStore = class {
   constructor(driver, clock, config, ids) {
@@ -391,68 +944,6 @@ var IdentityTracker = class {
   }
 };
 
-// src/keyset.ts
-function keyColumns(orderKey) {
-  if (typeof orderKey === "string") return [orderKey, "id"];
-  return [orderKey[0], orderKey[1]];
-}
-function idOf(row) {
-  const r = row;
-  if (r == null || r.id === void 0 || r.id === null) {
-    throw new Error("powersync-bridge: every row must have an `id`");
-  }
-  return String(r.id);
-}
-function compareValues(a, b) {
-  if (a === b) return 0;
-  if (a === null || a === void 0) return 1;
-  if (b === null || b === void 0) return -1;
-  if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();
-  if (typeof a === "number" && typeof b === "number") return a - b;
-  if (typeof a === "boolean" && typeof b === "boolean") return Number(a) - Number(b);
-  const sa = String(a);
-  const sb = String(b);
-  return sa < sb ? -1 : sa > sb ? 1 : 0;
-}
-function rowComparator(orderKey, direction = "asc") {
-  const [k1, k2] = keyColumns(orderKey);
-  const sign = direction === "desc" ? -1 : 1;
-  return (a, b) => {
-    const c1 = compareValues(a[k1], b[k1]);
-    if (c1 !== 0) return c1 * sign;
-    return compareValues(a[k2], b[k2]) * sign;
-  };
-}
-function cursorOfRow(row, orderKey) {
-  const r = row;
-  if (typeof orderKey === "string") return r[orderKey];
-  return [r[orderKey[0]], r[orderKey[1]]];
-}
-function isAfterCursor(row, cursor, orderKey, direction = "asc") {
-  const [k1, k2] = keyColumns(orderKey);
-  const r = row;
-  const sign = direction === "desc" ? -1 : 1;
-  const [c1, c2] = typeof orderKey === "string" ? [cursor, void 0] : cursor;
-  const d1 = compareValues(r[k1], c1) * sign;
-  if (d1 !== 0) return d1 > 0;
-  if (c2 === void 0) return false;
-  return compareValues(r[k2], c2) * sign > 0;
-}
-function toBase64(s) {
-  if (typeof btoa === "function") return btoa(unescape(encodeURIComponent(s)));
-  return Buffer.from(s, "utf8").toString("base64");
-}
-function fromBase64(s) {
-  if (typeof atob === "function") return decodeURIComponent(escape(atob(s)));
-  return Buffer.from(s, "base64").toString("utf8");
-}
-function encodeCursor(cursor) {
-  return toBase64(JSON.stringify(cursor));
-}
-function decodeCursor(opaque) {
-  return JSON.parse(fromBase64(opaque));
-}
-
 // src/infinite.ts
 var EMPTY = Object.freeze({
   items: Object.freeze([]),
@@ -503,6 +994,7 @@ var InfiniteListStore = class {
   reason;
   awaitingSync = false;
   loading = false;
+  localPagePending = false;
   errors = {};
   warnings = [];
   errorCount = 0;
@@ -511,14 +1003,16 @@ var InfiniteListStore = class {
   refs = 0;
   retain() {
     this.refs += 1;
-    if (this.refs === 1) this.subscribeLocal();
+    if (this.refs === 1 && this.unsubDiffs === null) this.subscribeLocal();
   }
   release() {
     this.refs -= 1;
-    if (this.refs <= 0) this.dispose();
+    if (this.refs <= 0) queueMicrotask(() => {
+      if (this.refs <= 0) this.dispose();
+    });
   }
   get isDisposed() {
-    return this.disposed;
+    return this.disposed || this.refs <= 0 && this.unsubDiffs !== null;
   }
   swapRoot() {
     this.store.replace(emptyInfiniteResult());
@@ -532,6 +1026,11 @@ var InfiniteListStore = class {
     for (const h of this.subs.values()) h.unsubscribe();
     this.subs.clear();
     this.lru.length = 0;
+    this.local.clear();
+    this.apiRows.clear();
+    this.retained.clear();
+    this.tombstones.clear();
+    this.store.replace(emptyInfiniteResult());
   }
   // ---------------------------------------------------------------------------
   subscribeLocal() {
@@ -543,6 +1042,10 @@ var InfiniteListStore = class {
       (diff) => void this.onDiff(diff),
       (err) => {
         this.localError = err;
+        if (this.localPagePending) {
+          this.localPagePending = false;
+          this.loading = false;
+        }
         this.render();
       }
     );
@@ -562,6 +1065,11 @@ var InfiniteListStore = class {
       this.apiRows.delete(id);
     }
     this.local = next;
+    this.localError = void 0;
+    if (this.localPagePending) {
+      this.localPagePending = false;
+      this.loading = false;
+    }
     this.emissionSeen = true;
     const removed = /* @__PURE__ */ new Map();
     for (const [id, row] of prev) if (!next.has(id)) removed.set(id, row);
@@ -616,6 +1124,8 @@ var InfiniteListStore = class {
   async loadMore() {
     if (this.disposed || this.loading || this.boundary === "end") return;
     if (this.lookahead) {
+      this.localPagePending = true;
+      this.loading = true;
       this.pages += 1;
       this.boundary = "more";
       this.reason = void 0;
@@ -770,6 +1280,8 @@ var InfiniteListStore = class {
     }
   }
   absorbApi(rows) {
+    const { api: _previousApiError, ...remainingErrors } = this.errors;
+    this.errors = remainingErrors;
     this.errorCount = 0;
     this.nextRetryAt = 0;
     for (const row of rows) {
@@ -777,6 +1289,11 @@ var InfiniteListStore = class {
       if (this.local.has(id) || this.apiRows.has(id) || this.tombstones.has(id)) continue;
       this.apiRows.set(id, row);
     }
+    const loadedPages = Math.max(this.pages, Math.ceil(this.mergedEntries().length / this.def.pageSize));
+    if (loadedPages > this.pages) {
+      this.pages = loadedPages;
+      this.subscribeLocal();
+    }
     if (rows.length === 0) {
       this.boundary = "end";
       this.reason = void 0;
@@ -944,7 +1461,7 @@ var CrudMirror = class {
     for (const r of refs) next.set(refKey(r.table, r.id), r);
     const added = [];
     const completed = [];
-    for (const [k, r] of next) if (!this.live.has(k)) added.push(r);
+    for (const [k, r] of next) if (this.live.get(k)?.op !== r.op) added.push(r);
     for (const [k, r] of this.live) if (!next.has(k)) completed.push(r);
     if (added.length || completed.length) this.apply({ added, completed });
   }
@@ -1045,14 +1562,16 @@ var RacedListStore = class {
   apiMs = null;
   retain() {
     this.refs += 1;
-    if (this.refs === 1) this.start();
+    if (this.refs === 1 && this.unsubDiffs === null) this.start();
   }
   release() {
     this.refs -= 1;
-    if (this.refs <= 0) this.dispose();
+    if (this.refs <= 0) queueMicrotask(() => {
+      if (this.refs <= 0) this.dispose();
+    });
   }
   get isDisposed() {
-    return this.disposed;
+    return this.disposed || this.refs <= 0 && this.unsubDiffs !== null;
   }
   /** Synchronous part of an identity swap: the snapshot becomes empty 'pending' at once (R15). */
   swapRoot() {
@@ -1067,6 +1586,14 @@ var RacedListStore = class {
     this.unsubFresh?.();
     if (this.snapWindow) this.deps.crud.closeWindow(this.snapWindow);
     this.snapWindow = null;
+    this.local?.clear();
+    this.local = null;
+    this.snap = null;
+    this.prepared = null;
+    this.overlay.clear();
+    this.inSession.clear();
+    this.tombstones.clear();
+    this.store.replace(emptyRacedResult());
   }
   // ---------------------------------------------------------------------------
   start() {
@@ -1360,6 +1887,17 @@ var SnapshotCache = class {
     if (existing && (existing.result === null || now - existing.result.fetchedAt < staleTime)) {
       return existing.promise;
     }
+    for (const [entryKey, entry2] of this.entries) {
+      if (entry2.result && now - entry2.result.fetchedAt >= staleTime) this.entries.delete(entryKey);
+    }
+    if (this.entries.size >= 64) {
+      for (const [entryKey, entry2] of this.entries) {
+        if (entry2.result) {
+          this.entries.delete(entryKey);
+          break;
+        }
+      }
+    }
     const controller = new AbortController();
     const run = async (signal) => {
       const res = await fetcher(signal);
@@ -1379,6 +1917,12 @@ var SnapshotCache = class {
     return promise;
   }
   /** Cancel every in-flight fetch under a key prefix (identity swap). */
+  invalidate(key) {
+    const encoded = JSON.stringify(key);
+    this.entries.get(encoded)?.controller.abort(new Error("invalidated"));
+    this.entries.delete(encoded);
+  }
+  /** Cancel every in-flight fetch under a key prefix (identity swap). */
   abortAll(prefix) {
     const p = JSON.stringify(prefix).slice(0, -1);
     for (const [k, e] of this.entries) {
@@ -1409,6 +1953,7 @@ var Bridge = class {
   clock;
   /** Increments on every identity swap; hooks subscribe to re-acquire their stores. */
   epochStore;
+  connectivity = new SnapshotStore(void 0);
   identity = new IdentityTracker();
   freshness;
   crud;
@@ -1420,6 +1965,7 @@ var Bridge = class {
   identityOpts;
   onEvicted;
   disposed = false;
+  onNetwork = () => this.setOnline(globalThis.navigator?.onLine);
   constructor(opts) {
     this.driver = opts.driver;
     this.adapter = opts.adapter;
@@ -1438,6 +1984,8 @@ var Bridge = class {
     this.crud.start();
     this.freshness.onClear(() => this.identity.signalClear());
     this.identity.onChange(() => this.swapEpoch());
+    globalThis.addEventListener?.("online", this.onNetwork);
+    globalThis.addEventListener?.("offline", this.onNetwork);
   }
   get epoch() {
     return this.identity.epoch;
@@ -1445,6 +1993,25 @@ var Bridge = class {
   get identityKey() {
     return this.identity.currentKey;
   }
+  setOnline(online) {
+    this.connectivity.replace(online);
+  }
+  query(options) {
+    const key = `query:${this.epoch}:${infiniteQueryKey(options)}`;
+    return this.acquire(key, () => new InfiniteQueryStore({
+      driver: this.driver,
+      adapter: this.adapter,
+      crud: this.crud,
+      freshness: this.freshness,
+      snapshots: this.snapshots,
+      clock: this.clock,
+      epoch: this.epoch,
+      identityKey: this.identityKey,
+      apiLegEnabled: true,
+      measure: this.measure,
+      connectivity: this.connectivity
+    }, options));
+  }
   /** Resolves once the initial upload-queue read has landed (tests). */
   ready() {
     return this.crud.ready();
@@ -1555,6 +2122,8 @@ var Bridge = class {
   dispose() {
     if (this.disposed) return;
     this.disposed = true;
+    globalThis.removeEventListener?.("online", this.onNetwork);
+    globalThis.removeEventListener?.("offline", this.onNetwork);
     for (const s of this.stores.values()) s.dispose();
     this.stores.clear();
     this.snapshots.clear();
@@ -1578,6 +2147,8 @@ exports.AutoSyncFlagStore = AutoSyncFlagStore;
 exports.Bridge = Bridge;
 exports.DEFAULT_VOLATILE_CLAIMS = DEFAULT_VOLATILE_CLAIMS;
 exports.InfiniteListStore = InfiniteListStore;
+exports.InfiniteQueryStore = InfiniteQueryStore;
+exports.OfflineError = OfflineError;
 exports.OnDemandStreamStore = OnDemandStreamStore;
 exports.RacedListStore = RacedListStore;
 exports.SnapshotStore = SnapshotStore;
@@ -1593,6 +2164,7 @@ exports.emptyRacedResult = emptyRacedResult;
 exports.encodeCursor = encodeCursor;
 exports.identityKeyFromClaims = identityKeyFromClaims;
 exports.identityKeyFromToken = identityKeyFromToken;
+exports.infiniteQueryKey = infiniteQueryKey;
 exports.keyColumns = keyColumns;
 exports.probePresence = probePresence;
 exports.realClock = realClock;