powersync-bridge 0.0.1-alpha.0

package/dist/index.cjs

@@ -0,0 +1,1601 @@
+'use strict';
+
+// src/clock.ts
+var realClock = {
+  now: () => Date.now(),
+  setTimeout: (fn, ms) => {
+    const h = setTimeout(fn, ms);
+    return () => clearTimeout(h);
+  }
+};
+var TimeoutError = class extends Error {
+  name = "TimeoutError";
+};
+async function withTimeout(clock, p, ms, signal) {
+  const holder = {};
+  const timeout = new Promise((_, reject) => {
+    holder.cancel = clock.setTimeout(() => reject(new TimeoutError(`timed out after ${ms}ms`)), ms);
+    signal?.addEventListener("abort", () => reject(signal.reason ?? new Error("aborted")), { once: true });
+  });
+  try {
+    return await Promise.race([p, timeout]);
+  } finally {
+    holder.cancel?.();
+  }
+}
+
+// src/removal.ts
+var PROBE_CHUNK = 500;
+async function probePresence(driver, table, ids) {
+  const present = /* @__PURE__ */ new Set();
+  for (let i = 0; i < ids.length; i += PROBE_CHUNK) {
+    const chunk = ids.slice(i, i + PROBE_CHUNK);
+    const found = await driver.presentIds(table, chunk);
+    for (const id of found) present.add(id);
+  }
+  return present;
+}
+async function classifyRemovals(ctx, removed) {
+  const out = /* @__PURE__ */ new Map();
+  const ids = Array.from(removed.keys());
+  if (ids.length === 0) return out;
+  const present = await probePresence(ctx.driver, ctx.table, ids);
+  const now = ctx.clock.now();
+  const status = ctx.driver.syncStatus();
+  for (const [id, row] of removed) {
+    if (present.has(id)) {
+      out.set(id, "filtered");
+      continue;
+    }
+    const stream = ctx.provenance(row);
+    if (stream) {
+      const st = status.forStream(stream);
+      const tracked = st !== void 0;
+      const beforeExpiry = st?.active === true || st?.expiresAt === null || st?.expiresAt !== void 0 && st.expiresAt !== null && now < st.expiresAt.getTime();
+      out.set(id, tracked && beforeExpiry ? "delete" : "eviction");
+      continue;
+    }
+    if (ctx.isInWindow) {
+      try {
+        out.set(id, ctx.isInWindow(row) ? "delete" : "eviction");
+      } catch {
+        out.set(id, "retain");
+      }
+      continue;
+    }
+    out.set(id, "delete");
+  }
+  return out;
+}
+
+// src/store.ts
+var SnapshotStore = class {
+  snapshot;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(initial) {
+    this.snapshot = initial;
+  }
+  getSnapshot() {
+    return this.snapshot;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  replace(next) {
+    if (Object.is(next, this.snapshot)) return;
+    this.snapshot = next;
+    for (const l of Array.from(this.listeners)) l();
+  }
+  get listenerCount() {
+    return this.listeners.size;
+  }
+};
+function shallowEqualResult(a, b) {
+  const ka = Object.keys(a);
+  const kb = Object.keys(b);
+  if (ka.length !== kb.length) return false;
+  for (const k of ka) {
+    const va = a[k];
+    const vb = b[k];
+    if (Array.isArray(va) && Array.isArray(vb)) {
+      if (va.length !== vb.length) return false;
+      for (let i = 0; i < va.length; i++) if (!Object.is(va[i], vb[i])) return false;
+      continue;
+    }
+    if (va !== null && typeof va === "object" && vb !== null && typeof vb === "object") {
+      if (!shallowEqualResult(va, vb)) return false;
+      continue;
+    }
+    if (!Object.is(va, vb)) return false;
+  }
+  return true;
+}
+
+// src/flagger.ts
+var AutoSyncFlagStore = class {
+  constructor(driver, clock, config, ids) {
+    this.driver = driver;
+    this.clock = clock;
+    this.config = config;
+    this.ids = ids;
+    this.store.replace({ state: "idle" });
+  }
+  driver;
+  clock;
+  config;
+  ids;
+  store = new SnapshotStore({ status: "idle" });
+  handle = null;
+  unsubStatus = null;
+  cancelTimeout = null;
+  disposed = false;
+  refs = 0;
+  retain() {
+    this.refs += 1;
+    if (this.refs === 1) void this.start();
+  }
+  release() {
+    this.refs -= 1;
+    if (this.refs <= 0) this.dispose();
+  }
+  get isDisposed() {
+    return this.disposed;
+  }
+  swapRoot() {
+    this.store.replace({ state: "idle" });
+    this.disposed = true;
+  }
+  dispose() {
+    this.disposed = true;
+    this.unsubStatus?.();
+    this.cancelTimeout?.();
+    this.handle?.unsubscribe();
+    this.handle = null;
+  }
+  async start() {
+    this.store.replace({ state: "flagging" });
+    try {
+      await this.config.requestFlag(this.ids);
+      if (this.disposed) return;
+      this.handle = await this.driver.syncStream(this.config.stream, null, {});
+      this.store.replace({ state: "syncing" });
+      this.cancelTimeout = this.clock.setTimeout(() => {
+        if (!this.disposed && this.store.getSnapshot().state === "syncing") this.store.replace({ state: "timeout" });
+      }, this.config.timeoutMs ?? 15e3);
+      const check = async () => {
+        if (this.disposed) return;
+        const present = await probePresence(this.driver, this.config.table, this.ids);
+        if (!this.disposed && this.ids.every((id) => present.has(id))) {
+          this.cancelTimeout?.();
+          this.store.replace({ state: "synced" });
+          this.unsubStatus?.();
+        }
+      };
+      this.unsubStatus = this.driver.onStatusChanged(() => void check());
+      await check();
+    } catch (e) {
+      if (!this.disposed) this.store.replace({ state: "error", error: e instanceof Error ? e : new Error(String(e)) });
+    }
+  }
+};
+
+// src/freshness.ts
+function streamKey(desc) {
+  return `${desc.name}:${desc.params ? JSON.stringify(desc.params) : ""}`;
+}
+var FreshnessTracker = class {
+  constructor(driver, clock) {
+    this.driver = driver;
+    this.clock = clock;
+  }
+  driver;
+  clock;
+  sessionConnectAt = null;
+  localFreshAt = Number.NEGATIVE_INFINITY;
+  prevCompletionAt = null;
+  lastDownloadStart = null;
+  lastSeenSyncedAt = null;
+  lastDownloading = false;
+  lastConnected = false;
+  lastHasSynced = void 0;
+  streamFreshAt = /* @__PURE__ */ new Map();
+  streamSeenSyncedAt = /* @__PURE__ */ new Map();
+  completions = [];
+  completionListeners = /* @__PURE__ */ new Set();
+  clearListeners = /* @__PURE__ */ new Set();
+  unsubscribe = null;
+  /** Call once at engine init and again after every identity swap. */
+  start(epochStartedAt) {
+    this.stop();
+    this.reset();
+    const status = this.driver.syncStatus();
+    this.lastConnected = status.connected;
+    this.lastDownloading = status.downloading;
+    this.lastHasSynced = status.hasSynced;
+    this.lastSeenSyncedAt = status.lastSyncedAt?.getTime() ?? null;
+    if (status.connected) this.sessionConnectAt = epochStartedAt;
+    if (status.downloading) {
+      this.prevCompletionAt = Math.max(epochStartedAt, this.lastSeenSyncedAt ?? Number.NEGATIVE_INFINITY);
+    }
+    for (const s of status.syncStreams) {
+      if (s.lastSyncedAt) this.streamSeenSyncedAt.set(streamKey(s), s.lastSyncedAt.getTime());
+    }
+    this.unsubscribe = this.driver.onStatusChanged(() => this.onStatus(this.driver.syncStatus()));
+  }
+  stop() {
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+  }
+  reset() {
+    this.sessionConnectAt = null;
+    this.localFreshAt = Number.NEGATIVE_INFINITY;
+    this.prevCompletionAt = null;
+    this.lastDownloadStart = null;
+    this.lastSeenSyncedAt = null;
+    this.streamFreshAt.clear();
+    this.streamSeenSyncedAt.clear();
+    this.completions.length = 0;
+  }
+  get sessionConnectAtMs() {
+    return this.sessionConnectAt;
+  }
+  get localFreshAtMs() {
+    return this.localFreshAt;
+  }
+  streamFreshAtMs(desc) {
+    return this.streamFreshAt.get(streamKey(desc)) ?? Number.NEGATIVE_INFINITY;
+  }
+  /** Freshness for a list: the owning stream's stamp when declared, else the global stamp. */
+  freshAtFor(stream) {
+    if (!stream) return this.localFreshAt;
+    return Math.max(this.streamFreshAtMs(stream), this.localFreshAt);
+  }
+  /** "Answered" = in-session freshness evidence (R5). */
+  isFresh(stream) {
+    if (this.sessionConnectAt === null) return false;
+    return this.freshAtFor(stream) >= this.sessionConnectAt;
+  }
+  onCompletion(l) {
+    this.completionListeners.add(l);
+    return () => this.completionListeners.delete(l);
+  }
+  onClear(l) {
+    this.clearListeners.add(l);
+    return () => this.clearListeners.delete(l);
+  }
+  onStatus(status) {
+    const now = this.clock();
+    if (status.connected && !this.lastConnected && this.sessionConnectAt === null) {
+      this.sessionConnectAt = now;
+    }
+    this.lastConnected = status.connected;
+    if (status.downloading && !this.lastDownloading) this.lastDownloadStart = now;
+    this.lastDownloading = status.downloading;
+    const syncedAt = status.lastSyncedAt?.getTime() ?? null;
+    if (syncedAt !== null && syncedAt !== this.lastSeenSyncedAt) {
+      this.recordCompletion(now, null);
+    }
+    if (syncedAt !== null) this.lastSeenSyncedAt = syncedAt;
+    for (const s of status.syncStreams) {
+      const key = streamKey(s);
+      const at = s.lastSyncedAt?.getTime() ?? null;
+      if (at !== null && at !== this.streamSeenSyncedAt.get(key)) {
+        this.streamSeenSyncedAt.set(key, at);
+        const stamp = this.stampFor(now);
+        const prev = this.streamFreshAt.get(key) ?? Number.NEGATIVE_INFINITY;
+        this.streamFreshAt.set(key, Math.max(prev, stamp));
+        const c = { stamp: Math.max(prev, stamp), completedAt: now, stream: key };
+        for (const l of this.completionListeners) l(c);
+      }
+    }
+    if (this.lastHasSynced === true && status.hasSynced !== true) {
+      for (const l of this.clearListeners) l();
+    }
+    this.lastHasSynced = status.hasSynced;
+  }
+  stampFor(now) {
+    const candidates = [];
+    if (this.lastDownloadStart !== null && this.lastDownloadStart <= now) candidates.push(this.lastDownloadStart);
+    if (this.prevCompletionAt !== null) candidates.push(this.prevCompletionAt);
+    if (candidates.length === 0 && this.sessionConnectAt !== null) candidates.push(this.sessionConnectAt);
+    if (candidates.length === 0) return Number.NEGATIVE_INFINITY;
+    return Math.max(...candidates);
+  }
+  recordCompletion(now, stream) {
+    const stamp = this.stampFor(now);
+    this.localFreshAt = Math.max(this.localFreshAt, stamp);
+    this.prevCompletionAt = now;
+    this.lastDownloadStart = null;
+    const c = { stamp: this.localFreshAt, completedAt: now, stream };
+    this.completions.push(c);
+    for (const l of this.completionListeners) l(c);
+  }
+};
+
+// src/identity.ts
+var DEFAULT_VOLATILE_CLAIMS = [
+  // OIDC volatile set
+  "exp",
+  "iat",
+  "nbf",
+  "jti",
+  "auth_time",
+  "at_hash",
+  "nonce",
+  "azp",
+  // vendor session claims that rotate on refresh
+  "sid",
+  "session_id",
+  "rat"
+];
+function base64UrlToString(input) {
+  const b64 = input.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = b64 + "=".repeat((4 - b64.length % 4) % 4);
+  if (typeof atob === "function") return decodeURIComponent(escape(atob(padded)));
+  return Buffer.from(padded, "base64").toString("utf8");
+}
+function decodeJwtPayload(token) {
+  const parts = token.split(".");
+  if (parts.length < 2 || !parts[1]) throw new Error("powersync-bridge: token is not a JWT");
+  const parsed = JSON.parse(base64UrlToString(parts[1]));
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("powersync-bridge: JWT payload is not an object");
+  }
+  return parsed;
+}
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const o = value;
+    return `{${Object.keys(o).sort().map((k) => `${JSON.stringify(k)}:${canonical(o[k])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function identityKeyFromClaims(claims, opts = {}) {
+  const deny = new Set(opts.denyList ?? DEFAULT_VOLATILE_CLAIMS);
+  const stable = {};
+  for (const k of Object.keys(claims).sort()) {
+    if (!deny.has(k)) stable[k] = claims[k];
+  }
+  return canonical({ claims: stable, params: opts.connectionParams ?? {} });
+}
+function identityKeyFromToken(token, opts = {}) {
+  return identityKeyFromClaims(decodeJwtPayload(token), opts);
+}
+var IdentityTracker = class {
+  key = null;
+  epochCounter = 0;
+  listeners = /* @__PURE__ */ new Set();
+  get epoch() {
+    return this.epochCounter;
+  }
+  get currentKey() {
+    return this.key;
+  }
+  observe(key) {
+    if (key === this.key) return false;
+    this.key = key;
+    this.epochCounter += 1;
+    for (const l of this.listeners) l(this.epochCounter, key);
+    return true;
+  }
+  /** A clear (hasSynced true → false) is an epoch signal even if the token is unchanged. */
+  signalClear() {
+    this.epochCounter += 1;
+    for (const l of this.listeners) l(this.epochCounter, this.key);
+  }
+  onChange(l) {
+    this.listeners.add(l);
+    return () => this.listeners.delete(l);
+  }
+};
+
+// 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([]),
+  boundary: "more",
+  awaitingSync: false,
+  loading: false,
+  errors: Object.freeze({}),
+  warnings: Object.freeze([])
+});
+function emptyInfiniteResult() {
+  return EMPTY;
+}
+var DEFAULT_TTL = 300;
+var DEFAULT_CAP = 3;
+var DEFAULT_TIMEOUT = 15e3;
+var DEFAULT_KEEP = 3;
+var InfiniteListStore = class {
+  constructor(deps, def, scope) {
+    this.deps = deps;
+    this.def = def;
+    this.scope = scope;
+    this.compare = rowComparator(def.orderKey, def.direction ?? "asc");
+    this.table = def.table ?? def.id;
+  }
+  deps;
+  def;
+  scope;
+  store = new SnapshotStore(emptyInfiniteResult());
+  compare;
+  table;
+  abort = new AbortController();
+  pages = 1;
+  local = /* @__PURE__ */ new Map();
+  lookahead = false;
+  emissionSeen = false;
+  localError;
+  unsubDiffs = null;
+  apiRows = /* @__PURE__ */ new Map();
+  retained = /* @__PURE__ */ new Map();
+  tombstones = /* @__PURE__ */ new Set();
+  subs = /* @__PURE__ */ new Map();
+  lru = [];
+  probeCursor = null;
+  serverFloor = void 0;
+  // undefined = not fetched yet
+  floorRevalidated = false;
+  boundary = "more";
+  reason;
+  awaitingSync = false;
+  loading = false;
+  errors = {};
+  warnings = [];
+  errorCount = 0;
+  nextRetryAt = 0;
+  disposed = false;
+  refs = 0;
+  retain() {
+    this.refs += 1;
+    if (this.refs === 1) this.subscribeLocal();
+  }
+  release() {
+    this.refs -= 1;
+    if (this.refs <= 0) this.dispose();
+  }
+  get isDisposed() {
+    return this.disposed;
+  }
+  swapRoot() {
+    this.store.replace(emptyInfiniteResult());
+    this.disposed = true;
+  }
+  dispose() {
+    this.disposed = true;
+    this.abort.abort(new Error("disposed"));
+    this.unsubDiffs?.();
+    this.unsubDiffs = null;
+    for (const h of this.subs.values()) h.unsubscribe();
+    this.subs.clear();
+    this.lru.length = 0;
+  }
+  // ---------------------------------------------------------------------------
+  subscribeLocal() {
+    this.unsubDiffs?.();
+    const limit = this.pages * this.def.pageSize + 1;
+    const builder = this.def.query({ cursor: this.def.initialCursor, limit }, this.scope);
+    const prepared = this.deps.adapter.prepare(builder);
+    this.unsubDiffs = this.deps.driver.diffs(prepared).subscribe(
+      (diff) => void this.onDiff(diff),
+      (err) => {
+        this.localError = err;
+        this.render();
+      }
+    );
+  }
+  async onDiff(diff) {
+    if (this.disposed) return;
+    const prev = this.local;
+    const next = /* @__PURE__ */ new Map();
+    const window = this.pages * this.def.pageSize;
+    const sorted = [...diff.all].sort(this.compare);
+    this.lookahead = sorted.length > window;
+    for (const row of sorted.slice(0, window)) {
+      const id = idOf(row);
+      next.set(id, row);
+      this.tombstones.delete(id);
+      this.retained.delete(id);
+      this.apiRows.delete(id);
+    }
+    this.local = next;
+    this.emissionSeen = true;
+    const removed = /* @__PURE__ */ new Map();
+    for (const [id, row] of prev) if (!next.has(id)) removed.set(id, row);
+    if (removed.size > 0) await this.applyRemovals(removed);
+    this.render();
+  }
+  provenance(row) {
+    const pol = this.def.escalate;
+    if (pol.kind !== "partition") return void 0;
+    const p = pol.partitionOf(cursorOfRow(row, this.def.orderKey));
+    if (p === null) return void 0;
+    return { name: pol.stream, params: pol.partitionParams(p) };
+  }
+  async applyRemovals(removed) {
+    const classes = await classifyRemovals(
+      { driver: this.deps.driver, clock: this.deps.clock, table: this.table, provenance: (r) => this.provenance(r), isInWindow: this.def.isInWindow },
+      removed
+    );
+    if (this.disposed) return;
+    const evicted = [];
+    for (const [id, cls] of classes) {
+      const row = removed.get(id);
+      if (!row) continue;
+      switch (cls) {
+        case "filtered":
+          break;
+        case "delete":
+          this.tombstones.add(id);
+          break;
+        case "eviction":
+        case "retain":
+          this.retained.set(id, row);
+          evicted.push(id);
+          break;
+      }
+    }
+    if (evicted.length > 0) this.deps.onEvicted?.(evicted);
+  }
+  // ---------------------------------------------------------------------------
+  lastCursor() {
+    const all = this.mergedEntries();
+    const last = all[all.length - 1];
+    if (!last) return this.def.initialCursor;
+    return cursorOfRow(last.row, this.def.orderKey);
+  }
+  /** Explicit user retry clears the backoff (R16). */
+  retry() {
+    this.errorCount = 0;
+    this.nextRetryAt = 0;
+    return this.loadMore();
+  }
+  async loadMore() {
+    if (this.disposed || this.loading || this.boundary === "end") return;
+    if (this.lookahead) {
+      this.pages += 1;
+      this.boundary = "more";
+      this.reason = void 0;
+      this.subscribeLocal();
+      this.render();
+      return;
+    }
+    this.loading = true;
+    this.render();
+    try {
+      const pol = this.def.escalate;
+      if (pol.kind === "partition") await this.escalatePartition(pol);
+      else if (pol.kind === "api") await this.escalateApi(pol.fetchPage);
+      else await this.escalateOffset(pol.fetchPage);
+    } finally {
+      this.loading = false;
+      this.awaitingSync = false;
+      if (!this.disposed) this.render();
+    }
+  }
+  setUnknown(reason, err) {
+    this.boundary = "unknown";
+    this.reason = reason;
+    if (err) this.errors = { ...this.errors, stream: err };
+  }
+  async escalatePartition(pol) {
+    if (!this.deps.driver.syncStatus().connected) return this.setUnknown("offline");
+    const isBefore = pol.isBefore ?? ((a, b) => a < b);
+    if (this.serverFloor === void 0 && pol.serverFloor) {
+      try {
+        this.serverFloor = await pol.serverFloor();
+      } catch {
+        this.serverFloor = null;
+      }
+    }
+    const floor = this.serverFloor ?? pol.floor;
+    const cap = pol.partitionCap ?? DEFAULT_CAP;
+    const timeoutMs = pol.timeoutMs ?? DEFAULT_TIMEOUT;
+    const cursor = this.lastCursor();
+    let p;
+    if (this.probeCursor !== null) {
+      p = pol.nextPartition(this.probeCursor);
+      if (p === null) return this.finishEnd(pol);
+    } else {
+      p = pol.partitionOf(cursor);
+    }
+    for (let probes = 0; ; probes++) {
+      if (p === null || isBefore(p, floor)) return this.finishEnd(pol);
+      if (probes === cap) return this.setUnknown("partition-cap");
+      const params = pol.partitionParams(p);
+      const key = streamKey({ name: pol.stream, params });
+      let handle = this.subs.get(key);
+      if (!handle) {
+        handle = await this.deps.driver.syncStream(pol.stream, params, { ttl: pol.ttl ?? DEFAULT_TTL });
+        this.track(key, handle);
+      }
+      this.awaitingSync = true;
+      this.render();
+      try {
+        await withTimeout(this.deps.clock, handle.waitForFirstSync(this.abort.signal), timeoutMs, this.abort.signal);
+      } catch (e) {
+        if (this.disposed) return;
+        this.untrack(key);
+        return this.setUnknown(e instanceof TimeoutError ? "timeout" : "error", e instanceof Error ? e : void 0);
+      }
+      if (this.disposed) return;
+      const builder = this.def.query({ cursor, limit: this.def.pageSize + 1 }, this.scope);
+      const rows = await this.deps.driver.query(this.deps.adapter.prepare(builder), this.abort.signal);
+      if (rows.length > 0) {
+        this.probeCursor = null;
+        this.pages += 1;
+        this.boundary = "more";
+        this.reason = void 0;
+        this.subscribeLocal();
+        return;
+      }
+      this.probeCursor = p;
+      this.untrack(key);
+      p = pol.nextPartition(p);
+    }
+  }
+  async finishEnd(pol) {
+    if (!this.floorRevalidated && pol.serverFloor) {
+      this.floorRevalidated = true;
+      try {
+        const fresh = await pol.serverFloor();
+        if (fresh !== null && fresh !== this.serverFloor) {
+          this.serverFloor = fresh;
+          this.probeCursor = null;
+          return this.escalatePartition(pol);
+        }
+      } catch {
+      }
+    }
+    this.boundary = "end";
+    this.reason = void 0;
+  }
+  track(key, handle) {
+    this.subs.set(key, handle);
+    this.lru.push(key);
+    const keep = this.def.keepPagesAlive ?? DEFAULT_KEEP;
+    while (this.lru.length > keep) {
+      const old = this.lru.shift();
+      if (old && old !== key) this.untrack(old);
+    }
+  }
+  untrack(key) {
+    const h = this.subs.get(key);
+    if (h) h.unsubscribe();
+    this.subs.delete(key);
+    const i = this.lru.indexOf(key);
+    if (i >= 0) this.lru.splice(i, 1);
+  }
+  apiGate() {
+    const now = this.deps.clock.now();
+    if (now < this.nextRetryAt) {
+      this.setUnknown("offline");
+      return false;
+    }
+    return true;
+  }
+  apiFailure(err) {
+    this.errorCount += 1;
+    const backoff = Math.min(3e4, 1e3 * 2 ** (this.errorCount - 1));
+    this.nextRetryAt = this.deps.clock.now() + backoff;
+    const e = err instanceof Error ? err : new Error(String(err));
+    this.errors = { ...this.errors, api: e };
+    this.setUnknown(this.deps.driver.onlineHint() === false ? "offline" : "error");
+  }
+  async escalateApi(fetchPage) {
+    if (!this.apiGate()) return;
+    try {
+      const rows = await withTimeout(this.deps.clock, fetchPage(this.lastCursor(), this.abort.signal), this.deps.driver.onlineHint() === false ? 3e3 : 3e4, this.abort.signal);
+      this.absorbApi(rows);
+    } catch (e) {
+      if (!this.disposed) this.apiFailure(e);
+    }
+  }
+  async escalateOffset(fetchPage) {
+    if (!this.apiGate()) return;
+    const offset = this.mergedEntries().length;
+    try {
+      const rows = await withTimeout(this.deps.clock, fetchPage(offset, this.abort.signal), 3e4, this.abort.signal);
+      const cursor = this.lastCursor();
+      const shifted = rows.some(
+        (r) => this.local.has(idOf(r)) || this.apiRows.has(idOf(r)) || cursor !== void 0 && !isAfterCursor(r, cursor, this.def.orderKey, this.def.direction ?? "asc")
+      );
+      if (shifted && !this.warnings.includes("offset-shift")) this.warnings = [...this.warnings, "offset-shift"];
+      this.absorbApi(rows);
+    } catch (e) {
+      if (!this.disposed) this.apiFailure(e);
+    }
+  }
+  absorbApi(rows) {
+    this.errorCount = 0;
+    this.nextRetryAt = 0;
+    for (const row of rows) {
+      const id = idOf(row);
+      if (this.local.has(id) || this.apiRows.has(id) || this.tombstones.has(id)) continue;
+      this.apiRows.set(id, row);
+    }
+    if (rows.length === 0) {
+      this.boundary = "end";
+      this.reason = void 0;
+    } else {
+      this.boundary = "more";
+      this.reason = void 0;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  mergedEntries() {
+    const entries = [];
+    for (const row of this.local.values()) entries.push({ row, origin: "local", presentLocally: true });
+    for (const [id, row] of this.retained) if (!this.local.has(id)) entries.push({ row, origin: "local", presentLocally: false });
+    for (const [id, row] of this.apiRows) if (!this.local.has(id) && !this.retained.has(id)) entries.push({ row, origin: "api", presentLocally: false });
+    entries.sort((a, b) => this.compare(a.row, b.row));
+    return entries;
+  }
+  render() {
+    if (this.disposed) return;
+    const items = this.mergedEntries().map((e) => ({ row: e.row, origin: e.origin, presentLocally: e.presentLocally }));
+    const errors = { ...this.errors };
+    if (this.localError) errors.local = this.localError;
+    const result = {
+      items,
+      boundary: this.boundary,
+      ...this.reason !== void 0 ? { boundaryReason: this.reason } : {},
+      awaitingSync: this.awaitingSync,
+      loading: this.loading,
+      errors,
+      warnings: this.warnings
+    };
+    const prev = this.store.getSnapshot();
+    if (shallowEqualResult(prev, result)) return;
+    this.store.replace(result);
+  }
+};
+
+// src/ondemand.ts
+var OnDemandStreamStore = class {
+  constructor(driver, clock, name, params, opts) {
+    this.driver = driver;
+    this.clock = clock;
+    this.name = name;
+    this.params = params;
+    this.opts = opts;
+  }
+  driver;
+  clock;
+  name;
+  params;
+  opts;
+  store = new SnapshotStore({ status: "subscribing" });
+  handle = null;
+  abort = new AbortController();
+  refs = 0;
+  disposed = false;
+  retain() {
+    this.refs += 1;
+    if (this.refs === 1) void this.start();
+  }
+  release() {
+    this.refs -= 1;
+    if (this.refs <= 0) this.dispose();
+  }
+  get isDisposed() {
+    return this.disposed;
+  }
+  swapRoot() {
+    this.store.replace({ status: "subscribing" });
+    this.disposed = true;
+  }
+  dispose() {
+    this.disposed = true;
+    this.abort.abort(new Error("disposed"));
+    this.handle?.unsubscribe();
+    this.handle = null;
+  }
+  async start() {
+    if (!this.driver.syncStatus().connected) {
+      this.store.replace({ status: "offline" });
+    }
+    try {
+      const opts = {};
+      if (this.opts.ttl !== void 0) opts.ttl = this.opts.ttl;
+      if (this.opts.priority !== void 0) opts.priority = this.opts.priority;
+      this.handle = await this.driver.syncStream(this.name, this.params, opts);
+      if (this.disposed) {
+        this.handle.unsubscribe();
+        return;
+      }
+      if (this.driver.syncStatus().connected) this.store.replace({ status: "syncing" });
+      await withTimeout(this.clock, this.handle.waitForFirstSync(this.abort.signal), this.opts.timeoutMs ?? 15e3, this.abort.signal);
+      if (!this.disposed) this.store.replace({ status: "synced" });
+    } catch (e) {
+      if (this.disposed) return;
+      if (e instanceof TimeoutError) this.store.replace({ status: this.driver.syncStatus().connected ? "timeout" : "offline" });
+      else this.store.replace({ status: "error", error: e instanceof Error ? e : new Error(String(e)) });
+    }
+  }
+};
+
+// src/pending.ts
+function refKey(table, id) {
+  return `${table}\0${id}`;
+}
+var PendingWindow = class {
+  refs = /* @__PURE__ */ new Map();
+  open = true;
+  constructor(seed) {
+    for (const r of seed) this.refs.set(refKey(r.table, r.id), r);
+  }
+  observe(delta) {
+    if (!this.open) return;
+    for (const r of delta.added) this.refs.set(refKey(r.table, r.id), r);
+    for (const r of delta.completed) this.refs.set(refKey(r.table, r.id), r);
+  }
+  get(table, id) {
+    return this.refs.get(refKey(table, id));
+  }
+  close() {
+    this.open = false;
+    this.refs.clear();
+  }
+};
+var CrudMirror = class {
+  constructor(driver, freshness, clock) {
+    this.driver = driver;
+    this.freshness = freshness;
+    this.clock = clock;
+  }
+  driver;
+  freshness;
+  clock;
+  live = /* @__PURE__ */ new Map();
+  recentlyAcked = /* @__PURE__ */ new Map();
+  windows = /* @__PURE__ */ new Set();
+  listeners = /* @__PURE__ */ new Set();
+  unsubCrud = null;
+  unsubCompletion = null;
+  seeded = null;
+  start() {
+    this.stop();
+    this.live.clear();
+    this.recentlyAcked.clear();
+    for (const w of this.windows) w.close();
+    this.windows.clear();
+    this.unsubCrud = this.driver.onCrudChange((delta) => this.apply(delta));
+    this.unsubCompletion = this.freshness.onCompletion((c) => this.retireAcked(c));
+    this.seeded = this.resync();
+  }
+  stop() {
+    this.unsubCrud?.();
+    this.unsubCompletion?.();
+    this.unsubCrud = null;
+    this.unsubCompletion = null;
+  }
+  /** Resolves once the initial live set has been read. */
+  ready() {
+    return this.seeded ?? Promise.resolve();
+  }
+  /** Re-read the queue and apply the difference as a delta (fallback trigger: every local diff emission). */
+  async resync() {
+    const refs = await this.driver.pendingUploadIds();
+    const next = /* @__PURE__ */ new Map();
+    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 this.live) if (!next.has(k)) completed.push(r);
+    if (added.length || completed.length) this.apply({ added, completed });
+  }
+  apply(delta) {
+    const now = this.clock();
+    for (const r of delta.added) this.live.set(refKey(r.table, r.id), r);
+    for (const r of delta.completed) {
+      const k = refKey(r.table, r.id);
+      this.live.delete(k);
+      this.recentlyAcked.set(k, { ref: r, ackedAt: now });
+    }
+    for (const w of this.windows) w.observe(delta);
+    for (const l of this.listeners) l();
+  }
+  /** A ref retires only when a checkpoint whose STAMP ≥ ackTime completes (F5-001). */
+  retireAcked(c) {
+    if (c.stream !== null) return;
+    let changed = false;
+    for (const [k, v] of this.recentlyAcked) {
+      if (c.stamp >= v.ackedAt) {
+        this.recentlyAcked.delete(k);
+        changed = true;
+      }
+    }
+    if (changed) for (const l of this.listeners) l();
+  }
+  openWindow() {
+    const w = new PendingWindow(this.live.values());
+    this.windows.add(w);
+    return w;
+  }
+  closeWindow(w) {
+    w.close();
+    this.windows.delete(w);
+  }
+  /** The three-set union (R1). */
+  pendingOp(table, id, window) {
+    const k = refKey(table, id);
+    return this.live.get(k) ?? window?.get(table, id) ?? this.recentlyAcked.get(k)?.ref;
+  }
+  isLivePending(table, id) {
+    return this.live.has(refKey(table, id));
+  }
+  onChange(l) {
+    this.listeners.add(l);
+    return () => this.listeners.delete(l);
+  }
+};
+
+// src/raced.ts
+var EMPTY_RESULT = Object.freeze({
+  items: Object.freeze([]),
+  state: "pending",
+  awaiting: Object.freeze({ local: true, api: true }),
+  errors: Object.freeze({})
+});
+function emptyRacedResult() {
+  return EMPTY_RESULT;
+}
+var RacedListStore = class {
+  constructor(deps, def, scope, scopeKey) {
+    this.deps = deps;
+    this.def = def;
+    this.scope = scope;
+    this.scopeKey = scopeKey;
+    this.compare = rowComparator(def.orderKey, def.direction ?? "asc");
+    this.table = def.table ?? def.id;
+    this.startedAt = deps.clock.now();
+  }
+  deps;
+  def;
+  scope;
+  scopeKey;
+  store = new SnapshotStore(emptyRacedResult());
+  compare;
+  table;
+  abort = new AbortController();
+  startedAt;
+  snap = null;
+  snapPending = false;
+  snapError;
+  snapWindow = null;
+  local = null;
+  localError;
+  emissionSeen = false;
+  inSession = /* @__PURE__ */ new Set();
+  unsubDiffs = null;
+  unsubCrud = null;
+  unsubFresh = null;
+  prepared = null;
+  owned = false;
+  overlay = /* @__PURE__ */ new Map();
+  tombstones = /* @__PURE__ */ new Set();
+  disposed = false;
+  refs = 0;
+  measured = false;
+  localMs = null;
+  apiMs = null;
+  retain() {
+    this.refs += 1;
+    if (this.refs === 1) this.start();
+  }
+  release() {
+    this.refs -= 1;
+    if (this.refs <= 0) this.dispose();
+  }
+  get isDisposed() {
+    return this.disposed;
+  }
+  /** Synchronous part of an identity swap: the snapshot becomes empty 'pending' at once (R15). */
+  swapRoot() {
+    this.store.replace(emptyRacedResult());
+    this.disposed = true;
+  }
+  dispose() {
+    this.disposed = true;
+    this.abort.abort(new Error("disposed"));
+    this.unsubDiffs?.();
+    this.unsubCrud?.();
+    this.unsubFresh?.();
+    if (this.snapWindow) this.deps.crud.closeWindow(this.snapWindow);
+    this.snapWindow = null;
+  }
+  // ---------------------------------------------------------------------------
+  start() {
+    const { driver, adapter, crud, freshness } = this.deps;
+    const prepared = adapter.prepare(this.def.query(this.scope));
+    this.prepared = prepared;
+    this.unsubDiffs = driver.diffs(prepared).subscribe(
+      (diff) => void this.onDiff(diff),
+      (err) => {
+        this.localError = err;
+        this.reconcile();
+      }
+    );
+    this.unsubCrud = crud.onChange(() => this.reconcile());
+    this.unsubFresh = freshness.onCompletion(() => void this.onCompletion());
+    if (this.deps.apiLegEnabled) this.startApiLeg();
+    this.reconcile();
+  }
+  startApiLeg() {
+    const { snapshots, crud } = this.deps;
+    const staleTime = this.def.staleTime ?? 10 * 6e4;
+    this.snapPending = true;
+    const window = crud.openWindow();
+    this.snapWindow = window;
+    const key = ["powersync-bridge", this.deps.identityKey, this.deps.epoch, this.def.id, this.scopeKey];
+    snapshots.fetch(key, staleTime, (signal) => {
+      const combined = new AbortController();
+      const onAbort = () => combined.abort();
+      signal.addEventListener("abort", onAbort, { once: true });
+      this.abort.signal.addEventListener("abort", onAbort, { once: true });
+      return this.def.fetchSnapshot(this.scope, combined.signal);
+    }).then(
+      (record) => {
+        if (this.disposed) return;
+        this.snapPending = false;
+        this.apiMs = this.deps.clock.now() - this.startedAt;
+        const rows = /* @__PURE__ */ new Map();
+        for (const raw of record.rows) {
+          const item = this.def.mapApi(raw);
+          rows.set(idOf(item), item);
+        }
+        this.snap = { rows, record, window };
+        this.reconcile();
+      },
+      (err) => {
+        if (this.disposed) return;
+        this.snapPending = false;
+        this.snapError = err instanceof Error ? err : new Error(String(err));
+        crud.closeWindow(window);
+        this.snapWindow = null;
+        this.reconcile();
+      }
+    );
+  }
+  /**
+   * A checkpoint completed. Status events and diff emissions are separate SDK events with no
+   * ordering guarantee; taking ownership on the stale local map would render the pre-checkpoint
+   * value for one frame (fresh→old→fresh). Pre-ownership we re-query once, then reconcile.
+   */
+  async onCompletion() {
+    if (this.disposed || this.owned || !this.prepared || !this.emissionSeen) {
+      this.reconcile();
+      return;
+    }
+    try {
+      const rows = await this.deps.driver.query(this.prepared, this.abort.signal);
+      if (this.disposed) return;
+      const prev = this.local ?? /* @__PURE__ */ new Map();
+      const next = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        const id = idOf(row);
+        next.set(id, row);
+        const before = prev.get(id);
+        if ((before === void 0 || JSON.stringify(before) !== JSON.stringify(row)) && !this.deps.crud.isLivePending(this.table, id)) {
+          this.inSession.add(id);
+          this.tombstones.delete(id);
+        }
+      }
+      this.local = next;
+    } catch {
+    }
+    this.reconcile();
+  }
+  async onDiff(diff) {
+    if (this.disposed) return;
+    const { crud } = this.deps;
+    const prev = this.local;
+    const next = /* @__PURE__ */ new Map();
+    for (const row of diff.all) next.set(idOf(row), row);
+    if (this.emissionSeen) {
+      for (const row of [...diff.added, ...diff.updated]) {
+        const id = idOf(row);
+        if (!crud.isLivePending(this.table, id)) this.inSession.add(id);
+        this.tombstones.delete(id);
+      }
+    }
+    this.local = next;
+    if (!this.emissionSeen) {
+      this.emissionSeen = true;
+      this.localMs = this.deps.clock.now() - this.startedAt;
+    }
+    void crud.resync();
+    if (this.owned && prev) {
+      const removed = /* @__PURE__ */ new Map();
+      for (const id of diff.removed) {
+        const row = prev.get(id);
+        if (row) removed.set(id, row);
+      }
+      if (removed.size > 0) await this.applyRemovals(removed);
+    }
+    this.reconcile();
+  }
+  async applyRemovals(removed) {
+    const classes = await classifyRemovals(
+      {
+        driver: this.deps.driver,
+        clock: this.deps.clock,
+        table: this.table,
+        provenance: () => this.def.stream,
+        isInWindow: this.def.isInWindow
+      },
+      removed
+    );
+    if (this.disposed) return;
+    for (const [id, cls] of classes) {
+      const entry = this.overlay.get(id);
+      switch (cls) {
+        case "filtered":
+          this.overlay.delete(id);
+          break;
+        case "delete":
+          this.overlay.delete(id);
+          this.tombstones.add(id);
+          break;
+        case "eviction":
+        case "retain":
+          if (entry) this.overlay.set(id, { ...entry, presentLocally: false });
+          break;
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  reconcile() {
+    if (this.disposed) return;
+    const result = this.owned ? this.renderOwned() : this.renderRace();
+    const prev = this.store.getSnapshot();
+    if (shallowEqualResult(prev, result)) return;
+    this.store.replace(result);
+    this.report(result);
+  }
+  freshAt() {
+    return this.deps.freshness.freshAtFor(this.def.stream);
+  }
+  localFresh() {
+    return this.emissionSeen && this.deps.freshness.isFresh(this.def.stream);
+  }
+  tryTakeOwnership() {
+    if (this.owned) return true;
+    const apiFreshAt = this.snap?.record.fetchedAt ?? Number.NEGATIVE_INFINITY;
+    if (!(this.localFresh() && this.freshAt() > apiFreshAt)) return false;
+    this.owned = true;
+    const local = this.local ?? /* @__PURE__ */ new Map();
+    const overlay = /* @__PURE__ */ new Map();
+    for (const [id, row] of local) overlay.set(id, { row, origin: "local", presentLocally: true });
+    if (this.snap) {
+      if (this.def.apiScopeSupersetOfLocal) {
+        for (const [id, row] of this.snap.rows) {
+          if (!overlay.has(id) && !this.tombstones.has(id)) overlay.set(id, { row, origin: "api", presentLocally: false });
+        }
+      }
+      this.deps.crud.closeWindow(this.snap.window);
+      this.snapWindow = null;
+      this.snap = null;
+    }
+    this.overlay = overlay;
+    return true;
+  }
+  renderOwned() {
+    const local = this.local ?? /* @__PURE__ */ new Map();
+    for (const [id, row] of local) {
+      const e = this.overlay.get(id);
+      if (e) {
+        e.row = row;
+        e.origin = "local";
+        e.presentLocally = true;
+      } else if (!this.tombstones.has(id)) {
+        this.overlay.set(id, { row, origin: "local", presentLocally: true });
+      }
+    }
+    const items = this.finalize(Array.from(this.overlay.values()));
+    return this.build(items, "converged", { local: false, api: false });
+  }
+  renderRace() {
+    if (this.tryTakeOwnership()) return this.renderOwned();
+    const { crud } = this.deps;
+    const S = this.snap;
+    const local = this.local;
+    const apiFreshAt = S?.record.fetchedAt ?? Number.NEGATIVE_INFINITY;
+    const localFreshAt = this.freshAt();
+    const apiFresher = apiFreshAt > localFreshAt;
+    if (!S && !local) {
+      return this.build([], "pending", { local: !this.emissionSeen, api: this.snapPending });
+    }
+    if (!S && local && this.def.holdPending === "pending" && this.snapPending) {
+      return this.build([], "pending", { local: false, api: true });
+    }
+    const entries = [];
+    const stale = !S;
+    const ids = /* @__PURE__ */ new Set([...S?.rows.keys() ?? [], ...local?.keys() ?? []]);
+    for (const id of ids) {
+      const inLocal = local?.get(id);
+      const inS = S?.rows.get(id);
+      const pending = crud.pendingOp(this.table, id, S?.window);
+      if (pending) {
+        if (inLocal !== void 0) entries.push({ row: inLocal, origin: "local", presentLocally: true });
+        continue;
+      }
+      if (inLocal !== void 0 && inS !== void 0) {
+        entries.push(apiFresher ? { row: inS, origin: "api", presentLocally: true } : { row: inLocal, origin: "local", presentLocally: true });
+        continue;
+      }
+      if (inLocal !== void 0) {
+        if (!S) {
+          entries.push({ row: inLocal, origin: "local", presentLocally: true });
+        } else if (this.inSession.has(id)) {
+          entries.push({ row: inLocal, origin: "local", presentLocally: true });
+        } else if (apiFresher) ; else {
+          entries.push({ row: inLocal, origin: "local", presentLocally: true });
+        }
+        continue;
+      }
+      if (inS !== void 0 && !this.tombstones.has(id)) {
+        entries.push({ row: inS, origin: "api", presentLocally: false });
+      }
+    }
+    const items = this.finalize(entries, stale);
+    const state = !S ? "local" : !local ? "api" : apiFresher ? "api" : "local";
+    return this.build(items, state, { local: !this.emissionSeen, api: this.snapPending });
+  }
+  finalize(entries, stale = false) {
+    entries.sort((a, b) => this.compare(a.row, b.row));
+    const limited = entries.slice(0, this.def.limit);
+    return limited.map((e) => stale ? { row: e.row, origin: e.origin, presentLocally: e.presentLocally, stale: true } : { row: e.row, origin: e.origin, presentLocally: e.presentLocally });
+  }
+  build(items, state, awaiting) {
+    const errors = {};
+    if (this.localError) errors.local = this.localError;
+    if (this.snapError) errors.api = this.snapError;
+    return { items, state, awaiting, errors };
+  }
+  report(result) {
+    const sink = this.deps.measure;
+    if (!sink) return;
+    if (this.measured && result.state !== "converged") return;
+    if (result.state === "pending") return;
+    this.measured = true;
+    const connectAt = this.deps.freshness.sessionConnectAtMs;
+    const freshAt = this.deps.freshness.freshAtFor(this.def.stream);
+    const m = {
+      list: this.def.id,
+      winner: this.localMs !== null && (this.apiMs === null || this.localMs <= this.apiMs) ? "local" : this.apiMs !== null ? "api" : "none",
+      localMs: this.localMs,
+      apiMs: this.apiMs,
+      sessionFreshnessMs: connectAt !== null && Number.isFinite(freshAt) && freshAt >= connectAt ? this.deps.clock.now() - connectAt : null,
+      rowsRendered: result.items.length,
+      source: result.state
+    };
+    sink(m);
+  }
+  /** The cursor of the last rendered row — used by raced × infinite composition (R13). */
+  lastCursor() {
+    const items = this.store.getSnapshot().items;
+    const last = items[items.length - 1];
+    return last ? cursorOfRow(last.row, this.def.orderKey) : void 0;
+  }
+};
+
+// src/snapshots.ts
+var SnapshotCache = class {
+  constructor(clock, queryClient) {
+    this.clock = clock;
+    this.queryClient = queryClient;
+  }
+  clock;
+  queryClient;
+  entries = /* @__PURE__ */ new Map();
+  fetch(key, staleTime, fetcher) {
+    const k = JSON.stringify(key);
+    const now = this.clock.now();
+    const existing = this.entries.get(k);
+    if (existing && (existing.result === null || now - existing.result.fetchedAt < staleTime)) {
+      return existing.promise;
+    }
+    const controller = new AbortController();
+    const run = async (signal) => {
+      const res = await fetcher(signal);
+      return { rows: res.rows, asOf: res.asOf, requestedAt: now, fetchedAt: this.clock.now() };
+    };
+    const promise = this.queryClient ? this.queryClient.fetchQuery({ queryKey: key, queryFn: ({ signal }) => run(signal), staleTime }) : run(controller.signal);
+    const entry = { requestedAt: now, promise, result: null, controller };
+    this.entries.set(k, entry);
+    promise.then(
+      (r) => {
+        entry.result = r;
+      },
+      () => {
+        if (this.entries.get(k) === entry) this.entries.delete(k);
+      }
+    );
+    return promise;
+  }
+  /** 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) {
+      if (k.startsWith(p)) {
+        e.controller.abort(new Error("identity changed"));
+        this.entries.delete(k);
+      }
+    }
+  }
+  clear() {
+    for (const e of this.entries.values()) e.controller.abort(new Error("cleared"));
+    this.entries.clear();
+  }
+};
+
+// src/bridge.ts
+function detectPlatform() {
+  const nav = globalThis.navigator;
+  return nav?.product === "ReactNative" ? "native" : "web";
+}
+function scopeKeyOf(scope) {
+  return JSON.stringify(scope ?? null);
+}
+var Bridge = class {
+  driver;
+  adapter;
+  platform;
+  clock;
+  /** Increments on every identity swap; hooks subscribe to re-acquire their stores. */
+  epochStore;
+  identity = new IdentityTracker();
+  freshness;
+  crud;
+  snapshots;
+  epochSnapshot;
+  stores = /* @__PURE__ */ new Map();
+  gates;
+  measure;
+  identityOpts;
+  onEvicted;
+  disposed = false;
+  constructor(opts) {
+    this.driver = opts.driver;
+    this.adapter = opts.adapter;
+    this.clock = opts.clock ?? realClock;
+    this.platform = opts.platform ?? detectPlatform();
+    this.gates = { native: opts.platformGates?.native ?? "local-first", web: opts.platformGates?.web ?? "race" };
+    this.measure = opts.measure?.sink;
+    this.identityOpts = opts.identity ?? {};
+    this.onEvicted = opts.onEvicted;
+    this.epochSnapshot = new SnapshotStore(0);
+    this.epochStore = this.epochSnapshot;
+    this.freshness = new FreshnessTracker(this.driver, () => this.clock.now());
+    this.crud = new CrudMirror(this.driver, this.freshness, () => this.clock.now());
+    this.snapshots = new SnapshotCache(this.clock, opts.queryClient);
+    this.freshness.start(this.clock.now());
+    this.crud.start();
+    this.freshness.onClear(() => this.identity.signalClear());
+    this.identity.onChange(() => this.swapEpoch());
+  }
+  get epoch() {
+    return this.identity.epoch;
+  }
+  get identityKey() {
+    return this.identity.currentKey;
+  }
+  /** Resolves once the initial upload-queue read has landed (tests). */
+  ready() {
+    return this.crud.ready();
+  }
+  // ---------------------------------------------------------------------------
+  // Identity (R15, [DX])
+  // ---------------------------------------------------------------------------
+  /** Connect THROUGH the bridge so identity is derived from every token the connector produces. */
+  wrapConnector(connector) {
+    const wrapped = Object.create(connector);
+    Object.defineProperty(wrapped, "fetchCredentials", {
+      value: async () => {
+        const creds = await connector.fetchCredentials();
+        if (creds?.token) this.identity.observe(identityKeyFromToken(creds.token, this.identityOpts));
+        return creds;
+      },
+      configurable: true,
+      writable: true
+    });
+    Object.defineProperty(wrapped, "uploadData", {
+      value: (db) => connector.uploadData(db),
+      configurable: true,
+      writable: true
+    });
+    return wrapped;
+  }
+  /** Escape hatch for scope that is not in the token. */
+  setIdentity(scope) {
+    this.identity.observe(scope === null ? null : identityKeyFromClaims(scope, this.identityOpts));
+  }
+  /**
+   * Identity swap (R15): bump the epoch AND swap every store's root to empty 'pending' in ONE
+   * synchronous operation, then tear the rest down asynchronously.
+   */
+  swapEpoch() {
+    const outgoing = Array.from(this.stores.values());
+    this.stores.clear();
+    for (const s of outgoing) s.swapRoot();
+    this.epochSnapshot.replace(this.identity.epoch);
+    queueMicrotask(() => {
+      this.snapshots.clear();
+      for (const s of outgoing) s.dispose();
+      this.freshness.start(this.clock.now());
+      this.crud.start();
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Store acquisition (ref-counted; shared across components with the same key)
+  // ---------------------------------------------------------------------------
+  acquire(key, make) {
+    const existing = this.stores.get(key);
+    if (existing && !existing.isDisposed) return existing;
+    const s = make();
+    this.stores.set(key, s);
+    return s;
+  }
+  apiLegEnabled() {
+    return this.gates[this.platform] === "race";
+  }
+  raced(def, scope) {
+    const scopeKey = scopeKeyOf(scope);
+    const key = `raced:${this.epoch}:${def.id}:${scopeKey}`;
+    return this.acquire(
+      key,
+      () => new RacedListStore(
+        {
+          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: this.apiLegEnabled(),
+          measure: this.measure
+        },
+        def,
+        scope,
+        scopeKey
+      )
+    );
+  }
+  infinite(def, scope) {
+    const key = `infinite:${this.epoch}:${def.id}:${scopeKeyOf(scope)}`;
+    return this.acquire(
+      key,
+      () => new InfiniteListStore(
+        {
+          driver: this.driver,
+          adapter: this.adapter,
+          clock: this.clock,
+          onEvicted: this.onEvicted ? (ids) => this.onEvicted?.(def.id, ids) : void 0
+        },
+        def,
+        scope
+      )
+    );
+  }
+  onDemand(name, params, opts = {}) {
+    const key = `ondemand:${this.epoch}:${name}:${JSON.stringify(params)}`;
+    return this.acquire(key, () => new OnDemandStreamStore(this.driver, this.clock, name, params, opts));
+  }
+  autoSync(config, ids) {
+    const key = `flag:${this.epoch}:${config.stream}:${JSON.stringify([...ids].sort())}`;
+    return this.acquire(key, () => new AutoSyncFlagStore(this.driver, this.clock, config, ids));
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    for (const s of this.stores.values()) s.dispose();
+    this.stores.clear();
+    this.snapshots.clear();
+    this.freshness.stop();
+    this.crud.stop();
+  }
+};
+function createBridge(opts) {
+  return new Bridge(opts);
+}
+
+// src/define.ts
+function defineRacedList(input) {
+  return { kind: "raced", ...input };
+}
+function defineInfiniteList(input) {
+  return { kind: "infinite", ...input };
+}
+
+exports.AutoSyncFlagStore = AutoSyncFlagStore;
+exports.Bridge = Bridge;
+exports.DEFAULT_VOLATILE_CLAIMS = DEFAULT_VOLATILE_CLAIMS;
+exports.InfiniteListStore = InfiniteListStore;
+exports.OnDemandStreamStore = OnDemandStreamStore;
+exports.RacedListStore = RacedListStore;
+exports.SnapshotStore = SnapshotStore;
+exports.classifyRemovals = classifyRemovals;
+exports.createBridge = createBridge;
+exports.cursorOfRow = cursorOfRow;
+exports.decodeCursor = decodeCursor;
+exports.decodeJwtPayload = decodeJwtPayload;
+exports.defineInfiniteList = defineInfiniteList;
+exports.defineRacedList = defineRacedList;
+exports.emptyInfiniteResult = emptyInfiniteResult;
+exports.emptyRacedResult = emptyRacedResult;
+exports.encodeCursor = encodeCursor;
+exports.identityKeyFromClaims = identityKeyFromClaims;
+exports.identityKeyFromToken = identityKeyFromToken;
+exports.keyColumns = keyColumns;
+exports.probePresence = probePresence;
+exports.realClock = realClock;
+exports.rowComparator = rowComparator;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map