@rocicorp/zero 0.25.0-canary.3 → 0.25.0-canary.4

package/out/{chunk-IWL6EEA6.js → chunk-HE4M4K7Q.js}

@@ -1,16 +1,9 @@
 import {
-  IDBDatabasesStore,
-  IDBStore,
-  MemStore,
-  dropIDBStoreWithMemFallback,
-  dropMemStore,
-  getBrowserGlobal,
-  getBrowserGlobalMethod,
-  localNavigator,
-  mustGetBrowserGlobal,
-  newIDBStoreWithMemFallback,
-  promiseVoid
-} from "./chunk-HYS7YLNL.js";
+  maybeTransactionIsClosedRejection,
+  storeIsClosedRejection,
+  throwIfStoreClosed,
+  transactionIsClosedRejection
+} from "./chunk-ASRS2LFV.js";
 import {
   BTreeRead,
   Chunk,
@@ -87,6 +80,7 @@ import {
   localMutations,
   localMutationsDD31,
   localMutationsGreaterThan,
+  makeClientID,
   mapAST,
   mapAllEntries,
   mapEntries,
@@ -124,26 +118,27 @@ import {
   toMutationResponseKey,
   toPrimaryKeyString,
   toStaticParam,
+  using,
   valita_exports,
+  withRead,
+  withWrite,
+  withWriteNoImplicitCommit,
   wrapIterable
-} from "./chunk-JKP7HDC6.js";
+} from "./chunk-TAUDS4QP.js";
 import {
   assert,
   assertArray,
   assertBoolean,
+  assertNotNull,
   assertNumber,
   assertObject,
   assertString,
   deepFreeze,
+  deepFreezeAllowUndefined,
   hasOwn,
   isProd,
-  makeClientID,
-  unreachable,
-  using,
-  withRead,
-  withWrite,
-  withWriteNoImplicitCommit
-} from "./chunk-U2KJIWVC.js";
+  unreachable
+} from "./chunk-EZM3XBAB.js";
 import {
   __export
 } from "./chunk-424PT5DM.js";
@@ -303,6 +298,262 @@ function assertPullerResultV1(v) {
   }
 }
 
+// ../replicache/src/kv/idb-store.ts
+import { resolver } from "@rocicorp/resolver";
+
+// ../shared/src/browser-env.ts
+var overrides = /* @__PURE__ */ new Map();
+function getBrowserGlobal(name) {
+  if (overrides.has(name)) {
+    return overrides.get(name);
+  }
+  return globalThis[name];
+}
+function getBrowserGlobalMethod(name) {
+  return getBrowserGlobal(name)?.bind(globalThis);
+}
+function mustGetBrowserGlobal(name) {
+  const r = getBrowserGlobal(name);
+  if (r === void 0) {
+    throw new Error(
+      `Unsupported JavaScript environment: Could not find ${name}.`
+    );
+  }
+  return r;
+}
+
+// ../shared/src/resolved-promises.ts
+var promiseTrue = Promise.resolve(true);
+var promiseFalse = Promise.resolve(false);
+var promiseUndefined = Promise.resolve(void 0);
+var promiseVoid = Promise.resolve();
+var promiseNever = new Promise(() => {
+});
+
+// ../replicache/src/kv/write-impl-base.ts
+var deleteSentinel = Symbol();
+var WriteImplBase = class {
+  _pending = /* @__PURE__ */ new Map();
+  #read;
+  constructor(read) {
+    this.#read = read;
+  }
+  has(key) {
+    if (this.#read.closed) {
+      return transactionIsClosedRejection();
+    }
+    switch (this._pending.get(key)) {
+      case void 0:
+        return this.#read.has(key);
+      case deleteSentinel:
+        return promiseFalse;
+      default:
+        return promiseTrue;
+    }
+  }
+  async get(key) {
+    if (this.#read.closed) {
+      return transactionIsClosedRejection();
+    }
+    const v = this._pending.get(key);
+    switch (v) {
+      case deleteSentinel:
+        return void 0;
+      case void 0: {
+        const v2 = await this.#read.get(key);
+        return deepFreezeAllowUndefined(v2);
+      }
+      default:
+        return v;
+    }
+  }
+  put(key, value) {
+    return maybeTransactionIsClosedRejection(this.#read) ?? (this._pending.set(key, deepFreeze(value)), promiseVoid);
+  }
+  del(key) {
+    return maybeTransactionIsClosedRejection(this.#read) ?? (this._pending.set(key, deleteSentinel), promiseVoid);
+  }
+  release() {
+    this.#read.release();
+  }
+  get closed() {
+    return this.#read.closed;
+  }
+};
+
+// ../replicache/src/kv/idb-store.ts
+var RELAXED = { durability: "relaxed" };
+var OBJECT_STORE = "chunks";
+var IDBStore = class {
+  #db;
+  #closed = false;
+  #idbDeleted = false;
+  constructor(name) {
+    this.#db = openDatabase(name);
+  }
+  read() {
+    if (this.#closed) {
+      return storeIsClosedRejection();
+    }
+    return this.#withReopen(readImpl);
+  }
+  write() {
+    if (this.#closed) {
+      return storeIsClosedRejection();
+    }
+    return this.#withReopen(writeImpl);
+  }
+  async close() {
+    if (!this.#idbDeleted) {
+      const db = await this.#db;
+      db.close();
+    }
+    this.#closed = true;
+  }
+  get closed() {
+    return this.#closed;
+  }
+  async #withReopen(fn) {
+    const reopenExistingDB = async (name) => {
+      const { promise, resolve, reject } = resolver();
+      const req = indexedDB.open(name);
+      req.onupgradeneeded = () => {
+        const tx = req.transaction;
+        assertNotNull(tx);
+        tx.abort();
+        this.#idbDeleted = true;
+        reject(
+          new IDBNotFoundError(
+            `Expected IndexedDB not found: ${name}. This likely means that the user deleted IndexedDB instances while the app was running. This is non-fatal. The app will continue running in memory until reload.`
+          )
+        );
+      };
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => reject(req.error);
+      const db2 = await promise;
+      db2.onversionchange = () => db2.close();
+      return db2;
+    };
+    const db = await this.#db;
+    try {
+      return fn(db);
+    } catch (e) {
+      if (!this.#closed && e instanceof DOMException) {
+        if (e.name === "InvalidStateError") {
+          this.#db = reopenExistingDB(db.name);
+          const reopened = await this.#db;
+          return fn(reopened);
+        } else if (e.name === "NotFoundError") {
+          this.#idbDeleted = true;
+          mustGetBrowserGlobal("indexedDB").deleteDatabase(db.name);
+          throw new IDBNotFoundError(
+            `Expected IndexedDB ${db.name} missing object store. Deleting db. This is non-fatal, the app will continue working in memory until it is reloaded.`
+          );
+        }
+      }
+      throw e;
+    }
+  }
+};
+var ReadImpl = class {
+  #tx;
+  #closed = false;
+  constructor(tx) {
+    this.#tx = tx;
+  }
+  has(key) {
+    if (this.#closed) {
+      return transactionIsClosedRejection();
+    }
+    return new Promise((resolve, reject) => {
+      const req = objectStore(this.#tx).count(key);
+      req.onsuccess = () => resolve(req.result > 0);
+      req.onerror = () => reject(req.error);
+    });
+  }
+  get(key) {
+    if (this.#closed) {
+      return transactionIsClosedRejection();
+    }
+    return new Promise((resolve, reject) => {
+      const req = objectStore(this.#tx).get(key);
+      req.onsuccess = () => resolve(deepFreezeAllowUndefined(req.result));
+      req.onerror = () => reject(req.error);
+    });
+  }
+  release() {
+    this.#closed = true;
+  }
+  get closed() {
+    return this.#closed;
+  }
+};
+var WriteImpl = class extends WriteImplBase {
+  #tx;
+  #closed = false;
+  constructor(tx) {
+    super(new ReadImpl(tx));
+    this.#tx = tx;
+  }
+  commit() {
+    if (this.#closed) {
+      return transactionIsClosedRejection();
+    }
+    if (this._pending.size === 0) {
+      return promiseVoid;
+    }
+    return new Promise((resolve, reject) => {
+      const tx = this.#tx;
+      const store = objectStore(tx);
+      for (const [key, val] of this._pending) {
+        if (val === deleteSentinel) {
+          store.delete(key);
+        } else {
+          store.put(val, key);
+        }
+      }
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  release() {
+    this.#closed = true;
+    super.release();
+  }
+  get closed() {
+    return this.#closed;
+  }
+};
+function writeImpl(db) {
+  const tx = db.transaction(OBJECT_STORE, "readwrite", RELAXED);
+  return new WriteImpl(tx);
+}
+function readImpl(db) {
+  const tx = db.transaction(OBJECT_STORE, "readonly");
+  return new ReadImpl(tx);
+}
+function objectStore(tx) {
+  return tx.objectStore(OBJECT_STORE);
+}
+function openDatabase(name) {
+  const idb = mustGetBrowserGlobal("indexedDB");
+  return new Promise((resolve, reject) => {
+    const req = idb.open(name);
+    req.onupgradeneeded = () => {
+      req.result.createObjectStore(OBJECT_STORE);
+    };
+    req.onsuccess = () => {
+      const db = req.result;
+      db.onversionchange = () => db.close();
+      resolve(db);
+    };
+    req.onerror = () => reject(req.error);
+  });
+}
+var IDBNotFoundError = class extends Error {
+  name = "IDBNotFoundError";
+};
+
 // ../replicache/src/make-idb-name.ts
 function makeIDBName(name, schemaVersion) {
   return makeIDBNameInternal(name, schemaVersion, Latest);
@@ -318,9 +569,9 @@ var AbortError = class extends Error {
 };
 
 // ../shared/src/sleep.ts
-import { resolver } from "@rocicorp/resolver";
+import { resolver as resolver2 } from "@rocicorp/resolver";
 var promiseVoid2 = Promise.resolve();
-var promiseNever = new Promise(() => void 0);
+var promiseNever2 = new Promise(() => void 0);
 function sleep(ms, signal) {
   const newAbortError = () => new AbortError("Aborted");
   if (signal?.aborted) {
@@ -346,9 +597,9 @@ function sleep(ms, signal) {
 }
 function sleepWithAbort(ms, signal) {
   if (ms === 0) {
-    return [promiseVoid2, promiseNever];
+    return [promiseVoid2, promiseNever2];
   }
-  const { promise: abortedPromise, resolve: abortedResolve } = resolver();
+  const { promise: abortedPromise, resolve: abortedResolve } = resolver2();
   const sleepPromise = new Promise((resolve) => {
     const handleAbort = () => {
       clearTimeout(id);
@@ -534,10 +785,10 @@ var StoreImpl = class {
     this.#assertValidHash = assertValidHash;
   }
   async read() {
-    return new ReadImpl(await this.#kv.read(), this.#assertValidHash);
+    return new ReadImpl2(await this.#kv.read(), this.#assertValidHash);
   }
   async write() {
-    return new WriteImpl(
+    return new WriteImpl2(
       await this.#kv.write(),
       this.#chunkHasher,
       this.#assertValidHash
@@ -547,7 +798,7 @@ var StoreImpl = class {
     return this.#kv.close();
   }
 };
-var ReadImpl = class {
+var ReadImpl2 = class {
   _tx;
   assertValidHash;
   constructor(kv, assertValidHash) {
@@ -590,7 +841,7 @@ var ReadImpl = class {
     return this._tx.closed;
   }
 };
-var WriteImpl = class extends ReadImpl {
+var WriteImpl2 = class extends ReadImpl2 {
   #chunkHasher;
   #putChunks = /* @__PURE__ */ new Set();
   #changedHeads = /* @__PURE__ */ new Map();
@@ -786,6 +1037,175 @@ async function confirmDeletedClients(dagWrite, deletedClientIds, deletedClientGr
   );
 }
 
+// ../shared/src/navigator.ts
+var localNavigator = typeof navigator !== "undefined" ? navigator : void 0;
+
+// ../replicache/src/kv/mem-store.ts
+import { RWLock } from "@rocicorp/lock";
+
+// ../replicache/src/kv/read-impl.ts
+var ReadImpl3 = class {
+  #map;
+  #release;
+  #closed = false;
+  constructor(map, release) {
+    this.#map = map;
+    this.#release = release;
+  }
+  release() {
+    this.#release();
+    this.#closed = true;
+  }
+  get closed() {
+    return this.#closed;
+  }
+  has(key) {
+    return maybeTransactionIsClosedRejection(this) ?? Promise.resolve(this.#map.has(key));
+  }
+  get(key) {
+    return maybeTransactionIsClosedRejection(this) ?? Promise.resolve(this.#map.get(key));
+  }
+};
+
+// ../replicache/src/kv/write-impl.ts
+var WriteImpl3 = class extends WriteImplBase {
+  #map;
+  constructor(map, release) {
+    super(new ReadImpl3(map, release));
+    this.#map = map;
+  }
+  commit() {
+    if (this.closed) {
+      return transactionIsClosedRejection();
+    }
+    this._pending.forEach((value, key) => {
+      if (value === deleteSentinel) {
+        this.#map.delete(key);
+      } else {
+        this.#map.set(key, value);
+      }
+    });
+    this._pending.clear();
+    this.release();
+    return promiseVoid;
+  }
+};
+
+// ../replicache/src/kv/mem-store.ts
+var stores = /* @__PURE__ */ new Map();
+function dropMemStore(name) {
+  stores.delete(name);
+  return promiseVoid;
+}
+var MemStore = class {
+  #map;
+  #rwLock;
+  #closed = false;
+  constructor(name) {
+    const entry = stores.get(name);
+    let lock;
+    let map;
+    if (entry) {
+      ({ lock, map } = entry);
+    } else {
+      lock = new RWLock();
+      map = /* @__PURE__ */ new Map();
+      stores.set(name, { lock, map });
+    }
+    this.#rwLock = lock;
+    this.#map = map;
+  }
+  async read() {
+    throwIfStoreClosed(this);
+    const release = await this.#rwLock.read();
+    return new ReadImpl3(this.#map, release);
+  }
+  async write() {
+    throwIfStoreClosed(this);
+    const release = await this.#rwLock.write();
+    return new WriteImpl3(this.#map, release);
+  }
+  close() {
+    this.#closed = true;
+    return promiseVoid;
+  }
+  get closed() {
+    return this.#closed;
+  }
+};
+
+// ../replicache/src/kv/idb-store-with-mem-fallback.ts
+var IDBStoreWithMemFallback = class {
+  #lc;
+  #name;
+  #store;
+  constructor(lc, name) {
+    this.#lc = lc;
+    this.#name = name;
+    this.#store = new IDBStore(name);
+  }
+  read() {
+    return this.#withBrainTransplant((s) => s.read());
+  }
+  write() {
+    return this.#withBrainTransplant((s) => s.write());
+  }
+  async #withBrainTransplant(f) {
+    try {
+      return await f(this.#store);
+    } catch (e) {
+      if (isFirefoxPrivateBrowsingError(e)) {
+        if (this.#store instanceof IDBStore) {
+          this.#lc.info?.(
+            "Switching to MemStore because of Firefox private browsing error"
+          );
+          this.#store = new MemStore(this.#name);
+        }
+        return f(this.#store);
+      }
+      throw e;
+    }
+  }
+  close() {
+    return this.#store.close();
+  }
+  get closed() {
+    return this.#store.closed;
+  }
+};
+function isFirefoxPrivateBrowsingError(e) {
+  return isFirefox() && e instanceof DOMException && e.name === "InvalidStateError" && e.message === "A mutation operation was attempted on a database that did not allow mutations.";
+}
+function isFirefox() {
+  return localNavigator?.userAgent?.includes("Firefox") ?? false;
+}
+function newIDBStoreWithMemFallback(lc, name) {
+  if (isFirefox()) {
+    return new IDBStoreWithMemFallback(lc, name);
+  }
+  return new IDBStore(name);
+}
+function dropIDBStoreWithMemFallback(name) {
+  if (!isFirefox()) {
+    return dropIDBStore(name);
+  }
+  try {
+    return dropIDBStore(name);
+  } catch (e) {
+    if (isFirefoxPrivateBrowsingError(e)) {
+      return dropMemStore(name);
+    }
+  }
+  return promiseVoid;
+}
+function dropIDBStore(name) {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.deleteDatabase(name);
+    req.onsuccess = () => resolve();
+    req.onerror = () => reject(req.error);
+  });
+}
+
 // ../replicache/src/get-kv-store-provider.ts
 function getKVStoreProvider(lc, kvStore) {
   switch (kvStore) {
@@ -816,6 +1236,99 @@ function createLogContext(logLevel = "info", logSinks = [consoleLogSink], contex
   return new LogContext(logLevel, context, logSink);
 }
 
+// ../replicache/src/persist/idb-databases-store-db-name.ts
+var IDB_DATABASES_VERSION = 0;
+var IDB_DATABASES_DB_NAME = "replicache-dbs-v" + IDB_DATABASES_VERSION;
+var testNamespace = "";
+function getIDBDatabasesDBName() {
+  return testNamespace + IDB_DATABASES_DB_NAME;
+}
+
+// ../replicache/src/persist/idb-databases-store.ts
+var DBS_KEY = "dbs";
+var PROFILE_ID_KEY = "profileId";
+function assertIndexedDBDatabaseRecord(value) {
+  assertObject(value);
+  for (const [name, db] of Object.entries(value)) {
+    assertString(name);
+    assertIndexedDBDatabase(db);
+    assert(name === db.name);
+  }
+}
+function assertIndexedDBDatabase(value) {
+  assertObject(value);
+  assertString(value.name);
+  assertString(value.replicacheName);
+  assertNumber(value.replicacheFormatVersion);
+  assertString(value.schemaVersion);
+  if (value.lastOpenedTimestampMS !== void 0) {
+    assertNumber(value.lastOpenedTimestampMS);
+  }
+}
+var IDBDatabasesStore = class {
+  #kvStore;
+  constructor(createKVStore) {
+    this.#kvStore = createKVStore(getIDBDatabasesDBName());
+  }
+  putDatabase(db) {
+    return this.#putDatabase({ ...db, lastOpenedTimestampMS: Date.now() });
+  }
+  putDatabaseForTesting(db) {
+    return this.#putDatabase(db);
+  }
+  #putDatabase(db) {
+    return withWrite(this.#kvStore, async (write) => {
+      const oldDbRecord = await getDatabases(write);
+      const dbRecord = {
+        ...oldDbRecord,
+        [db.name]: db
+      };
+      await write.put(DBS_KEY, dbRecord);
+      return dbRecord;
+    });
+  }
+  clearDatabases() {
+    return withWrite(this.#kvStore, (write) => write.del(DBS_KEY));
+  }
+  deleteDatabases(names) {
+    return withWrite(this.#kvStore, async (write) => {
+      const oldDbRecord = await getDatabases(write);
+      const dbRecord = {
+        ...oldDbRecord
+      };
+      for (const name of names) {
+        delete dbRecord[name];
+      }
+      await write.put(DBS_KEY, dbRecord);
+    });
+  }
+  getDatabases() {
+    return withRead(this.#kvStore, getDatabases);
+  }
+  close() {
+    return this.#kvStore.close();
+  }
+  getProfileID() {
+    return withWrite(this.#kvStore, async (write) => {
+      let profileId = await write.get(PROFILE_ID_KEY);
+      if (profileId === void 0) {
+        profileId = `p${makeClientID()}`;
+        await write.put(PROFILE_ID_KEY, profileId);
+      }
+      assertString(profileId);
+      return profileId;
+    });
+  }
+};
+async function getDatabases(read) {
+  let dbRecord = await read.get(DBS_KEY);
+  if (!dbRecord) {
+    dbRecord = deepFreeze({});
+  }
+  assertIndexedDBDatabaseRecord(dbRecord);
+  return dbRecord;
+}
+
 // ../replicache/src/persist/collect-idb-databases.ts
 var COLLECT_IDB_INTERVAL = 12 * 60 * 60 * 1e3;
 var INITIAL_COLLECT_IDB_DELAY = 5 * 60 * 1e3;
@@ -1960,7 +2473,7 @@ var QueryParseError = class extends Error {
 };
 
 // ../zql/src/query/query-impl.ts
-import { resolver as resolver2 } from "@rocicorp/resolver";
+import { resolver as resolver3 } from "@rocicorp/resolver";
 
 // ../zero-protocol/src/query-hash.ts
 var hashCache = /* @__PURE__ */ new WeakMap();
@@ -7117,7 +7630,7 @@ function materializeImpl(query, delegate, factory = arrayViewFactory, options) {
   const { ast, format, customQueryID } = qi;
   const queryHash = qi.hash();
   const queryID = customQueryID ? hashOfNameAndArgs(customQueryID.name, customQueryID.args) : queryHash;
-  const queryCompleteResolver = resolver2();
+  const queryCompleteResolver = resolver3();
   let queryComplete = delegate.defaultQueryComplete;
   const updateTTL = customQueryID ? (newTTL) => delegate.updateCustomQuery(customQueryID, newTTL) : (newTTL) => delegate.updateServerQuery(ast, newTTL);
   const gotCallback = (got, error) => {
@@ -7197,7 +7710,7 @@ async function runImpl(query, delegate, options) {
 function preloadImpl(query, delegate, options) {
   const qi = delegate.withContext(query);
   const ttl = options?.ttl ?? DEFAULT_PRELOAD_TTL_MS;
-  const { resolve, promise: complete } = resolver2();
+  const { resolve, promise: complete } = resolver3();
   const { customQueryID, ast } = qi;
   if (customQueryID) {
     const cleanup2 = delegate.addCustomQuery(ast, customQueryID, ttl, (got) => {
@@ -7584,15 +8097,15 @@ var SchemaVersionNotSupported2 = "SchemaVersionNotSupported";
 
 // ../zero-client/src/client/zero.ts
 import "@rocicorp/logger";
-import { resolver as resolver10 } from "@rocicorp/resolver";
+import { resolver as resolver11 } from "@rocicorp/resolver";
 
 // ../replicache/src/replicache-impl.ts
 import { Lock } from "@rocicorp/lock";
 import { consoleLogSink as consoleLogSink2 } from "@rocicorp/logger";
-import { resolver as resolver6 } from "@rocicorp/resolver";
+import { resolver as resolver7 } from "@rocicorp/resolver";
 
 // ../shared/src/document-visible.ts
-import { resolver as resolver3 } from "@rocicorp/resolver";
+import { resolver as resolver4 } from "@rocicorp/resolver";
 function getDocumentVisibilityWatcher(doc, hiddenIntervalMS, signal) {
   return doc ? new DocumentVisibilityWatcherImpl(doc, hiddenIntervalMS, signal) : new DocumentVisibilityWatcherNoDoc();
 }
@@ -7646,7 +8159,7 @@ var DocumentVisibilityWatcherImpl = class {
     if (this.visibilityState === state) {
       return Promise.resolve();
     }
-    const { promise, resolve } = resolver3();
+    const { promise, resolve } = resolver4();
     this.#promises.add({ resolve, state });
     return promise;
   }
@@ -7695,7 +8208,7 @@ var PushDelegate = class extends ConnectionLoopDelegateImpl {
 };
 
 // ../replicache/src/connection-loop.ts
-import { resolver as resolver4 } from "@rocicorp/resolver";
+import { resolver as resolver5 } from "@rocicorp/resolver";
 var MIN_DELAY_MS = 30;
 var MAX_DELAY_MS = 6e4;
 var ConnectionLoop = class {
@@ -7727,17 +8240,17 @@ var ConnectionLoop = class {
   // Back to the pending!
   // Controls whether the next iteration of the loop will wait at the pending
   // state.
-  #pendingResolver = resolver4();
+  #pendingResolver = resolver5();
   /**
    * This resolver is used to allow us to skip sleeps when we do send(true)
    */
-  #skipSleepsResolver = resolver4();
+  #skipSleepsResolver = resolver5();
   /**
    * Resolver for the next send. Never rejects. Returns an error instead since
    * this resolver is used in cases where they might not be someone waiting,
    * and we don't want an unhandled promise rejection in that case.
    */
-  #sendResolver = resolver4();
+  #sendResolver = resolver5();
   #delegate;
   #closed = false;
   #abortSignal = new AbortController();
@@ -7786,7 +8299,7 @@ var ConnectionLoop = class {
   }
   async run() {
     const sendRecords = [];
-    let recoverResolver = resolver4();
+    let recoverResolver = resolver5();
     let lastSendTime;
     let counter = 0;
     const delegate = this.#delegate;
@@ -7810,7 +8323,7 @@ var ConnectionLoop = class {
       await sleepMaybeSkip(delegate.debounceDelay);
       if (this.#closed) break;
       debug?.("debounced");
-      this.#pendingResolver = resolver4();
+      this.#pendingResolver = resolver5();
       if (counter >= delegate.maxConnections) {
         debug?.("Too many request in flight. Waiting until one finishes...");
         await this.#waitUntilAvailableConnection();
@@ -7849,7 +8362,7 @@ var ConnectionLoop = class {
         try {
           lastSendTime = start;
           debug?.("Sending request");
-          this.#skipSleepsResolver = resolver4();
+          this.#skipSleepsResolver = resolver5();
           ok = await delegate.invokeSend();
           debug?.("Send returned", ok);
         } catch (e) {
@@ -7865,12 +8378,12 @@ var ConnectionLoop = class {
         sendRecords.push({ duration: Date.now() - start, ok });
         if (recovered(sendRecords)) {
           recoverResolver.resolve();
-          recoverResolver = resolver4();
+          recoverResolver = resolver5();
         }
         counter--;
         this.#connectionAvailable();
         const sendResolver = this.#sendResolver;
-        this.#sendResolver = resolver4();
+        this.#sendResolver = resolver5();
         if (error) {
           sendResolver.resolve({ error });
         } else {
@@ -7891,7 +8404,7 @@ var ConnectionLoop = class {
     }
   }
   #waitUntilAvailableConnection() {
-    const { promise, resolve } = resolver4();
+    const { promise, resolve } = resolver5();
     this.#waitingConnectionResolve = resolve;
     return promise;
   }
@@ -7941,7 +8454,7 @@ function recovered(sendRecords) {
 }
 
 // ../replicache/src/dag/lazy-store.ts
-import { RWLock } from "@rocicorp/lock";
+import { RWLock as RWLock2 } from "@rocicorp/lock";
 var LazyStore = class {
   /**
    * This lock is used to ensure correct isolation of Reads and Writes.
@@ -7964,7 +8477,7 @@ var LazyStore = class {
    * - write `_heads`
    * - write `_memOnlyChunks`
    */
-  #rwLock = new RWLock();
+  #rwLock = new RWLock2();
   #heads = /* @__PURE__ */ new Map();
   #sourceStore;
   #chunkHasher;
@@ -10020,7 +10533,7 @@ function shouldAbortRefresh(memdagBaseSnapshot, perdagClientGroupBaseSnapshot, p
 }
 
 // ../replicache/src/process-scheduler.ts
-import { resolver as resolver5 } from "@rocicorp/resolver";
+import { resolver as resolver6 } from "@rocicorp/resolver";
 
 // ../replicache/src/request-idle.ts
 function requestIdle(timeout) {
@@ -10084,7 +10597,7 @@ var ProcessScheduler = class {
     if (this.#scheduledResolver) {
       return this.#scheduledResolver.promise;
     }
-    this.#scheduledResolver = resolver5();
+    this.#scheduledResolver = resolver6();
     void this.#scheduleInternal();
     return this.#scheduledResolver.promise;
   }
@@ -10740,7 +11253,7 @@ var ReplicacheImpl = class {
       newRandomHash,
       assertHash
     );
-    const readyResolver = resolver6();
+    const readyResolver = resolver7();
     this.#ready = readyResolver.promise;
     const { minDelayMs = MIN_DELAY_MS, maxDelayMs = MAX_DELAY_MS } = requestOptions;
     this.#requestOptions = { maxDelayMs, minDelayMs };
@@ -10759,9 +11272,9 @@ var ReplicacheImpl = class {
       new PushDelegate(this, () => this.#invokePush())
     );
     this.mutate = this.#registerMutators(mutators);
-    const profileIDResolver = resolver6();
+    const profileIDResolver = resolver7();
     this.#profileIDPromise = profileIDResolver.promise;
-    const clientGroupIDResolver = resolver6();
+    const clientGroupIDResolver = resolver7();
     this.#clientGroupIDPromise = clientGroupIDResolver.promise;
     if (false) {
       this.#mutationRecovery = new MutationRecovery({
@@ -10945,7 +11458,7 @@ var ReplicacheImpl = class {
    */
   async close() {
     this.#closed = true;
-    const { promise, resolve } = resolver6();
+    const { promise, resolve } = resolver7();
     closingInstances.set(this.name, promise);
     this.#closeAbortController.abort();
     getBrowserGlobal("document")?.removeEventListener(
@@ -12216,7 +12729,7 @@ function send(ws, data) {
 }
 
 // ../zero-client/src/client/active-clients-manager.ts
-import { resolver as resolver7 } from "@rocicorp/resolver";
+import { resolver as resolver8 } from "@rocicorp/resolver";
 var keyPrefix = "zero-active";
 function toLockName(clientGroupID, clientID) {
   return `${keyPrefix}/${clientGroupID}/${clientID}`;
@@ -12246,7 +12759,7 @@ function ignoreAbortError(e) {
 var ActiveClientsManager = class _ActiveClientsManager {
   clientGroupID;
   clientID;
-  #resolver = resolver7();
+  #resolver = resolver8();
   #lockManager;
   #activeClients = /* @__PURE__ */ new Set();
   /**
@@ -12412,7 +12925,7 @@ var MockClientLockManager = class {
 };
 
 // ../zero-client/src/client/connection-manager.ts
-import { resolver as resolver8 } from "@rocicorp/resolver";
+import { resolver as resolver9 } from "@rocicorp/resolver";
 var DEFAULT_TIMEOUT_CHECK_INTERVAL_MS = 1e3;
 var TERMINAL_STATES = [
   connection_status_enum_exports.NeedsAuth,
@@ -12443,7 +12956,7 @@ var ConnectionManager = class _ConnectionManager extends Subscribable {
   /**
    * Resolver used to signal waiting callers when the state changes.
    */
-  #stateChangeResolver = resolver8();
+  #stateChangeResolver = resolver9();
   constructor(options) {
     super();
     const now = Date.now();
@@ -12656,7 +13169,7 @@ var ConnectionManager = class _ConnectionManager extends Subscribable {
   };
   #resolveNextStateWaiters() {
     this.#stateChangeResolver.resolve(this.#state);
-    this.#stateChangeResolver = resolver8();
+    this.#stateChangeResolver = resolver9();
   }
   #publishState() {
     this.notify(this.#state);
@@ -14830,7 +15343,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.25.0-canary.3";
+var version2 = "0.25.0-canary.4";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -15146,7 +15659,7 @@ var State = class {
 };
 
 // ../zero-client/src/client/mutation-tracker.ts
-import { resolver as resolver9 } from "@rocicorp/resolver";
+import { resolver as resolver10 } from "@rocicorp/resolver";
 var currentEphemeralID = 0;
 function nextEphemeralID() {
   return ++currentEphemeralID;
@@ -15187,7 +15700,7 @@ var MutationTracker = class {
   }
   trackMutation() {
     const id = nextEphemeralID();
-    const mutationResolver = resolver9();
+    const mutationResolver = resolver10();
     this.#outstandingMutations.set(id, {
       resolver: mutationResolver
     });
@@ -16631,13 +17144,13 @@ var Zero = class _Zero {
   #pendingPullsByRequestID = /* @__PURE__ */ new Map();
   #lastMutationIDReceived = 0;
   #socket = void 0;
-  #socketResolver = resolver10();
+  #socketResolver = resolver11();
   /**
    * Utility promise that resolves when the socket transitions to connected.
    * It rejects if we hit an error or timeout before the connected message.
    * Used by push/pull helpers to queue work until the connection is usable.
    */
-  #connectResolver = resolver10();
+  #connectResolver = resolver11();
   #closeAbortController = new AbortController();
   #visibilityWatcher;
   #connectionManager;
@@ -17669,9 +18182,9 @@ ${error.errorBody.message}`, error);
       default:
         unreachable(connectionStatus);
     }
-    this.#socketResolver = resolver10();
+    this.#socketResolver = resolver11();
     lc.debug?.("Creating new connect resolver");
-    this.#connectResolver = resolver10();
+    this.#connectResolver = resolver11();
     this.#messageCount = 0;
     this.#connectStart = void 0;
     this.#connectedAt = 0;
@@ -17741,12 +18254,12 @@ ${error.errorBody.message}`, error);
     const body = pullResponseMessage[1];
     lc = lc.withContext("requestID", body.requestID);
     lc.debug?.("Handling pull response", body);
-    const resolver11 = this.#pendingPullsByRequestID.get(body.requestID);
-    if (!resolver11) {
+    const resolver12 = this.#pendingPullsByRequestID.get(body.requestID);
+    if (!resolver12) {
       lc.debug?.("No resolver found");
       return;
     }
-    resolver11.resolve(pullResponseMessage[1]);
+    resolver12.resolve(pullResponseMessage[1]);
   }
   async #pusher(req, requestID) {
     assert(req.pushVersion === 1);
@@ -18015,7 +18528,7 @@ ${error.errorBody.message}`, error);
       }
     ];
     send(socket, pullRequestMessage);
-    const pullResponseResolver = resolver10();
+    const pullResponseResolver = resolver11();
     this.#pendingPullsByRequestID.set(requestID, pullResponseResolver);
     try {
       const raceResult = await promiseRace({
@@ -18090,7 +18603,7 @@ ${error.errorBody.message}`, error);
    */
   async #ping(lc) {
     lc.debug?.("pinging");
-    const { promise, resolve } = resolver10();
+    const { promise, resolve } = resolver11();
     this.#onPong = resolve;
     const pingMessage = ["ping", {}];
     const t0 = performance.now();
@@ -18299,6 +18812,7 @@ async function makeActiveClientsManager(clientGroupID, clientID, signal, onDelet
 
 export {
   getDefaultPuller,
+  IDBNotFoundError,
   makeIDBName,
   dropDatabase,
   dropAllDatabases,
@@ -18337,4 +18851,4 @@ export {
   update_needed_reason_type_enum_exports,
   Zero
 };
-//# sourceMappingURL=chunk-IWL6EEA6.js.map
+//# sourceMappingURL=chunk-HE4M4K7Q.js.map