@rocicorp/zero 0.12.2025013000 → 0.12.2025013100

package/out/{chunk-UEPZPKPV.js → chunk-XBQPXRPX.js}

@@ -715,1118 +715,1333 @@ var IDBNotFoundError = class extends Error {
   name = "IDBNotFoundError";
 };
 
-// ../replicache/src/transaction-closed-error.ts
-var TransactionClosedError = class extends Error {
-  constructor() {
-    super("Transaction is closed");
-  }
-};
-function throwIfClosed(tx) {
-  if (tx.closed) {
-    throw new TransactionClosedError();
-  }
-}
-function rejectIfClosed(tx) {
-  return tx.closed ? Promise.reject(new TransactionClosedError()) : void 0;
-}
-
-// ../replicache/src/format-version-enum.ts
-var DD31 = 5;
-var V6 = 6;
-var V7 = 7;
-var Latest = V7;
-
-// ../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 ReadImpl2 = 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 Promise.resolve(this.#map.has(key));
-  }
-  get(key) {
-    return Promise.resolve(this.#map.get(key));
-  }
+// ../shared/src/abort-error.ts
+var AbortError = class extends Error {
+  name = "AbortError";
 };
 
-// ../replicache/src/kv/write-impl.ts
-var WriteImpl2 = class extends WriteImplBase {
-  #map;
-  constructor(map, release) {
-    super(new ReadImpl2(map, release));
-    this.#map = map;
+// ../shared/src/sleep.ts
+import { resolver as resolver2 } from "@rocicorp/resolver";
+var promiseVoid2 = Promise.resolve();
+var promiseNever = new Promise(() => void 0);
+function sleep(ms, signal) {
+  const newAbortError = () => new AbortError("Aborted");
+  if (signal?.aborted) {
+    return Promise.reject(newAbortError());
   }
-  commit() {
-    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;
+  if (ms === 0) {
+    return promiseVoid2;
   }
-};
-
-// ../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 });
+  return new Promise((resolve, reject) => {
+    let handleAbort;
+    if (signal) {
+      handleAbort = () => {
+        clearTimeout(id);
+        reject(newAbortError());
+      };
+      signal.addEventListener("abort", handleAbort, { once: true });
     }
-    this.#rwLock = lock;
-    this.#map = map;
-  }
-  async read() {
-    const release = await this.#rwLock.read();
-    return new ReadImpl2(this.#map, release);
-  }
-  async write() {
-    const release = await this.#rwLock.write();
-    return new WriteImpl2(this.#map, release);
-  }
-  close() {
-    this.#closed = true;
-    return promiseVoid;
-  }
-  get closed() {
-    return this.#closed;
+    const id = setTimeout(() => {
+      resolve();
+      signal?.removeEventListener("abort", handleAbort);
+    }, ms);
+  });
+}
+function sleepWithAbort(ms, signal) {
+  if (ms === 0) {
+    return [promiseVoid2, promiseNever];
   }
-};
+  const { promise: abortedPromise, resolve: abortedResolve } = resolver2();
+  const sleepPromise = new Promise((resolve) => {
+    const handleAbort = () => {
+      clearTimeout(id);
+      abortedResolve();
+    };
+    const id = setTimeout(() => {
+      resolve();
+      signal.removeEventListener("abort", handleAbort);
+    }, ms);
+    signal.addEventListener("abort", handleAbort, { once: true });
+  });
+  return [sleepPromise, abortedPromise];
+}
 
-// ../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());
+// ../replicache/src/bg-interval.ts
+function initBgIntervalProcess(processName, process2, delayMs, lc, signal) {
+  void runBgIntervalProcess(processName, process2, delayMs, lc, signal);
+}
+async function runBgIntervalProcess(processName, process2, delayMs, lc, signal) {
+  if (signal.aborted) {
+    return;
   }
-  async #withBrainTransplant(f) {
+  lc = lc.withContext("bgIntervalProcess", processName);
+  lc.debug?.("Starting");
+  while (!signal.aborted) {
     try {
-      return await f(this.#store);
+      await sleep(delayMs(), signal);
     } 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);
+      if (!(e instanceof AbortError)) {
+        throw e;
+      }
+    }
+    if (!signal.aborted) {
+      lc.debug?.("Running");
+      try {
+        await process2();
+      } catch (e) {
+        if (signal.aborted) {
+          lc.debug?.("Error running most likely due to close.", e);
+        } else {
+          lc.error?.("Error running.", e);
         }
-        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.";
+  lc.debug?.("Stopping");
 }
-function isFirefox() {
-  return localNavigator?.userAgent.includes("Firefox") ?? false;
+
+// ../shared/src/random-uint64.ts
+function randomUint64() {
+  const high = Math.floor(Math.random() * 4294967295);
+  const low = Math.floor(Math.random() * 4294967295);
+  return BigInt(high) << 32n | BigInt(low);
 }
-function newIDBStoreWithMemFallback(lc, name) {
-  if (isFirefox()) {
-    return new IDBStoreWithMemFallback(lc, name);
+
+// ../shared/src/valita.ts
+var valita_exports = {};
+__export(valita_exports, {
+  assert: () => assert2,
+  deepPartial: () => deepPartial,
+  instanceOfAbstractType: () => instanceOfAbstractType,
+  is: () => is,
+  parse: () => parse,
+  readonly: () => readonly,
+  readonlyArray: () => readonlyArray,
+  readonlyObject: () => readonlyObject,
+  readonlyRecord: () => readonlyRecord,
+  test: () => test,
+  testOptional: () => testOptional
+});
+__reExport(valita_exports, valita_star);
+import * as v from "@badrap/valita";
+import * as valita_star from "@badrap/valita";
+function toDisplay(value) {
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+      return JSON.stringify(value);
+    case "undefined":
+      return "undefined";
+    case "bigint":
+      return value.toString() + "n";
+    default:
+      if (value === null) {
+        return "null";
+      }
+      if (Array.isArray(value)) {
+        return "array";
+      }
+      return typeof value;
   }
-  return new IDBStore(name);
 }
-function dropIDBStoreWithMemFallback(name) {
-  if (!isFirefox()) {
-    return dropIDBStore(name);
+function toDisplayAtPath(v2, path2) {
+  if (!path2?.length) {
+    return toDisplay(v2);
   }
-  try {
-    return dropIDBStore(name);
-  } catch (e) {
-    if (isFirefoxPrivateBrowsingError(e)) {
-      return dropMemStore(name);
-    }
+  let cur = v2;
+  for (const p of path2) {
+    cur = cur[p];
   }
-  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/replicache-impl.ts
-import { Lock as Lock2 } from "@rocicorp/lock";
-import { consoleLogSink as consoleLogSink2 } from "@rocicorp/logger";
-import { resolver as resolver6 } from "@rocicorp/resolver";
-
-// ../shared/src/abort-error.ts
-var AbortError = class extends Error {
-  name = "AbortError";
-};
-
-// ../shared/src/document-visible.ts
-import { resolver as resolver2 } from "@rocicorp/resolver";
-function getDocumentVisibilityWatcher(doc, hiddenIntervalMS, signal) {
-  return doc ? new DocumentVisibilityWatcherImpl(doc, hiddenIntervalMS, signal) : new DocumentVisibilityWatcherNoDoc();
+  return toDisplay(cur);
 }
-var DocumentVisibilityWatcherImpl = class {
-  #doc;
-  #hiddenIntervalMS;
-  #timeoutID = 0;
-  // This trails doc.visibilityState by hiddenIntervalMS when being hidden. This
-  // is because we want to wait for the tab to be hidden for a while before
-  // considering as hidden.
-  visibilityState;
-  #promises = /* @__PURE__ */ new Set();
-  constructor(doc, hiddenIntervalMS, signal) {
-    this.#doc = doc;
-    this.#hiddenIntervalMS = hiddenIntervalMS;
-    this.visibilityState = doc.visibilityState;
-    this.#doc.addEventListener("visibilitychange", this.#onVisibilityChange, {
-      signal
-    });
+function displayList(word, expected, toDisplay2 = (x) => String(x)) {
+  if (expected.length === 1) {
+    return toDisplay2(expected[0]);
   }
-  #onVisibilityChange = () => {
-    if (this.#doc.visibilityState === "visible") {
-      clearTimeout(this.#timeoutID);
-      this.#setVisibilityState("visible");
-    } else {
-      this.#timeoutID = setTimeout(() => {
-        this.#setVisibilityState("hidden");
-      }, this.#hiddenIntervalMS);
+  const suffix = `${toDisplay2(
+    expected[expected.length - 2]
+  )} ${word} ${toDisplay2(expected[expected.length - 1])}`;
+  if (expected.length === 2) {
+    return suffix;
+  }
+  return `${expected.slice(0, -2).map(toDisplay2).join(", ")}, ${suffix}`;
+}
+function getMessage(err2, v2, schema, mode) {
+  const firstIssue = err2.issues[0];
+  const { path: path2 } = firstIssue;
+  const atPath = path2?.length ? ` at ${path2.join(".")}` : "";
+  switch (firstIssue.code) {
+    case "invalid_type":
+      return `Expected ${displayList(
+        "or",
+        firstIssue.expected
+      )}${atPath}. Got ${toDisplayAtPath(v2, path2)}`;
+    case "missing_value": {
+      const atPath2 = path2 && path2.length > 1 ? ` at ${path2.slice(0, -1).join(".")}` : "";
+      if (firstIssue.path?.length) {
+        return `Missing property ${firstIssue.path.at(-1)}${atPath2}`;
+      }
+      return `TODO Unknown missing property${atPath2}`;
     }
-  };
-  #setVisibilityState(visibilityState) {
-    if (visibilityState === this.visibilityState) {
-      return;
+    case "invalid_literal":
+      return `Expected literal value ${displayList(
+        "or",
+        firstIssue.expected,
+        toDisplay
+      )}${atPath} Got ${toDisplayAtPath(v2, path2)}`;
+    case "invalid_length": {
+      return `Expected array with length ${firstIssue.minLength === firstIssue.maxLength ? firstIssue.minLength : `between ${firstIssue.minLength} and ${firstIssue.maxLength}`}${atPath}. Got array with length ${v2.length}`;
     }
-    this.visibilityState = visibilityState;
-    for (const entry of this.#promises) {
-      const { resolve, state } = entry;
-      if (state === visibilityState) {
-        resolve();
-        this.#promises.delete(entry);
+    case "unrecognized_keys":
+      if (firstIssue.keys.length === 1) {
+        return `Unexpected property ${firstIssue.keys[0]}${atPath}`;
       }
+      return `Unexpected properties ${displayList(
+        "and",
+        firstIssue.keys
+      )}${atPath}`;
+    case "invalid_union":
+      return schema.name === "union" ? getDeepestUnionParseError(v2, schema, mode ?? "strict") : `Invalid union value${atPath}`;
+    case "custom_error": {
+      const { error } = firstIssue;
+      const message = !error ? "unknown" : typeof error === "string" ? error : error.message ?? "unknown";
+      return `${message}${atPath}. Got ${toDisplayAtPath(v2, path2)}`;
     }
   }
-  waitForVisible() {
-    return this.#waitFor("visible");
-  }
-  waitForHidden() {
-    return this.#waitFor("hidden");
-  }
-  #waitFor(state) {
-    if (this.visibilityState === state) {
-      return Promise.resolve();
+}
+function getDeepestUnionParseError(value, schema, mode) {
+  const failures = [];
+  for (const type of schema.options) {
+    const r = type.try(value, { mode });
+    if (!r.ok) {
+      failures.push({ type, err: r });
     }
-    const { promise, resolve } = resolver2();
-    this.#promises.add({ resolve, state });
-    return promise;
-  }
-};
-var resolvedPromise = Promise.resolve();
-var promiseThatNeverResolves = new Promise(() => void 0);
-var DocumentVisibilityWatcherNoDoc = class {
-  visibilityState = "visible";
-  waitForVisible() {
-    return resolvedPromise;
   }
-  waitForHidden() {
-    return promiseThatNeverResolves;
+  if (failures.length) {
+    failures.sort(pathCmp);
+    if (failures.length === 1 || pathCmp(failures[0], failures[1]) < 0) {
+      return getMessage(failures[0].err, value, failures[0].type, mode);
+    }
   }
-};
-
-// ../replicache/src/connection-loop-delegates.ts
-var ConnectionLoopDelegateImpl = class {
-  rep;
-  invokeSend;
-  // TODO: Remove the ability to have more than one concurrent connection and update tests.
-  // Bug: https://github.com/rocicorp/replicache-internal/issues/303
-  maxConnections = 1;
-  constructor(rep, invokeSend) {
-    this.rep = rep;
-    this.invokeSend = invokeSend;
+  try {
+    const str = JSON.stringify(value);
+    return `Invalid union value: ${str}`;
+  } catch (e) {
+    return `Invalid union value`;
   }
-  get maxDelayMs() {
-    return this.rep.requestOptions.maxDelayMs;
+}
+function pathCmp(a, b) {
+  const aPath = a.err.issues[0].path;
+  const bPath = b.err.issues[0].path;
+  if (aPath.length !== bPath.length) {
+    return bPath.length - aPath.length;
   }
-  get minDelayMs() {
-    return this.rep.requestOptions.minDelayMs;
+  for (let i = 0; i < aPath.length; i++) {
+    if (bPath[i] > aPath[i]) {
+      return -1;
+    }
+    if (bPath[i] < aPath[i]) {
+      return 1;
+    }
   }
-};
-var PullDelegate = class extends ConnectionLoopDelegateImpl {
-  debounceDelay = 0;
-  get watchdogTimer() {
-    return this.rep.pullInterval;
+  return 0;
+}
+function parse(value, schema, mode) {
+  const res = test(value, schema, mode);
+  if (!res.ok) {
+    throw new TypeError(res.error);
   }
-};
-var PushDelegate = class extends ConnectionLoopDelegateImpl {
-  get debounceDelay() {
-    return this.rep.pushDelay;
+  return res.value;
+}
+function is(value, schema, mode) {
+  return test(value, schema, mode).ok;
+}
+function assert2(value, schema, mode) {
+  parse(value, schema, mode);
+}
+function test(value, schema, mode) {
+  const res = schema.try(value, mode ? { mode } : void 0);
+  if (!res.ok) {
+    return {
+      ok: false,
+      error: getMessage(res, value, schema, mode)
+    };
   }
-  watchdogTimer = null;
-};
-
-// ../replicache/src/connection-loop.ts
-import { resolver as resolver4 } from "@rocicorp/resolver";
-
-// ../shared/src/sleep.ts
-import { resolver as resolver3 } from "@rocicorp/resolver";
-var promiseVoid2 = Promise.resolve();
-var promiseNever = new Promise(() => void 0);
-function sleep(ms, signal) {
-  const newAbortError = () => new AbortError("Aborted");
-  if (signal?.aborted) {
-    return Promise.reject(newAbortError());
+  return res;
+}
+function testOptional(value, schema, mode) {
+  let flags = 1;
+  if (mode === "passthrough") {
+    flags = 0;
+  } else if (mode === "strip") {
+    flags = 2;
   }
-  if (ms === 0) {
-    return promiseVoid2;
+  const res = schema.func(value, flags);
+  if (res === void 0) {
+    return { ok: true, value };
+  } else if (res.ok) {
+    return res;
   }
-  return new Promise((resolve, reject) => {
-    let handleAbort;
-    if (signal) {
-      handleAbort = () => {
-        clearTimeout(id);
-        reject(newAbortError());
-      };
-      signal.addEventListener("abort", handleAbort, { once: true });
-    }
-    const id = setTimeout(() => {
-      resolve();
-      signal?.removeEventListener("abort", handleAbort);
-    }, ms);
-  });
+  const err2 = new v.ValitaError(res);
+  return { ok: false, error: getMessage(err2, value, schema, mode) };
 }
-function sleepWithAbort(ms, signal) {
-  if (ms === 0) {
-    return [promiseVoid2, promiseNever];
+function readonly(t2) {
+  return t2;
+}
+function readonlyObject(t2) {
+  return v.object(t2);
+}
+function readonlyArray(t2) {
+  return v.array(t2);
+}
+function readonlyRecord(t2) {
+  return v.record(t2);
+}
+var AbstractType = Object.getPrototypeOf(
+  Object.getPrototypeOf(v.string().optional())
+).constructor;
+function instanceOfAbstractType(obj) {
+  return obj instanceof AbstractType;
+}
+function deepPartial(s) {
+  const shape = {};
+  for (const [key, type] of Object.entries(s.shape)) {
+    if (type.name === "object") {
+      shape[key] = deepPartial(type).optional();
+    } else {
+      shape[key] = type.optional();
+    }
   }
-  const { promise: abortedPromise, resolve: abortedResolve } = resolver3();
-  const sleepPromise = new Promise((resolve) => {
-    const handleAbort = () => {
-      clearTimeout(id);
-      abortedResolve();
-    };
-    const id = setTimeout(() => {
-      resolve();
-      signal.removeEventListener("abort", handleAbort);
-    }, ms);
-    signal.addEventListener("abort", handleAbort, { once: true });
-  });
-  return [sleepPromise, abortedPromise];
+  return v.object(shape);
 }
 
-// ../replicache/src/connection-loop.ts
-var MIN_DELAY_MS = 30;
-var MAX_DELAY_MS = 6e4;
-var ConnectionLoop = class {
-  // ConnectionLoop runs a loop sending network requests (either pushes or
-  // pulls) to the server. Our goal, generally, is to send requests as fast as
-  // we can, but to adjust in case of slowness, network errors, etc. We will
-  // send requests in parallel if the server supports it. We also debounce
-  // pushes since they frequently happen in series very near to one another
-  // (e.g., during drag'n drops).
-  //
-  // The loop flows through the following states forever, until it is closed:
-  //
-  // Pending: Wait for event or watchdog
-  //          |
-  //          v
-  // Debounce: Wait for more events (we debounce pushes)
-  //          |
-  //          v
-  // Wait for available connection (we limit number of parallel requests
-  // allowed)
-  //          |
-  //          v
-  // Wait to send (if requests are taking too long, we will slow down)
-  //          |
-  //          v
-  // Send (asynchronously, wrt the loop)
-  //          |
-  //          v
-  // Back to the pending!
-  // Controls whether the next iteration of the loop will wait at the pending
-  // state.
-  #pendingResolver = resolver4();
-  /**
-   * This resolver is used to allow us to skip sleeps when we do send(true)
-   */
-  #skipSleepsResolver = resolver4();
+// ../replicache/src/hash.ts
+var STRING_LENGTH = 22;
+var hashRe = /^[0-9a-v-]+$/;
+var emptyUUID = "0".repeat(STRING_LENGTH);
+var emptyHash = emptyUUID;
+var newRandomHash = makeNewRandomHashFunctionInternal();
+function toStringAndSlice(n, len) {
+  return n.toString(32).slice(-len).padStart(len, "0");
+}
+function makeNewRandomHashFunctionInternal() {
+  let base = "";
+  let i = 0;
+  return () => {
+    if (!base) {
+      base = toStringAndSlice(randomUint64(), 12);
+    }
+    const tail = toStringAndSlice(i++, 10);
+    return base + tail;
+  };
+}
+function isHash(value) {
+  return typeof value === "string" && hashRe.test(value);
+}
+function assertHash(value) {
+  assert2(value, hashSchema);
+}
+var hashSchema = valita_exports.string().assert(isHash, "Invalid hash");
+
+// ../replicache/src/dag/chunk.ts
+function asRefs(sortedRefs) {
+  return sortedRefs;
+}
+function toRefs(refs) {
+  if (Array.isArray(refs)) {
+    refs.sort();
+    for (let i = 1; i < refs.length; i++) {
+      assert(refs[i - 1] !== refs[i], "Refs must not have duplicates");
+    }
+    return asRefs(refs);
+  }
+  const refsArray = [...refs];
+  refsArray.sort();
+  return asRefs(refsArray);
+}
+var Chunk = class {
+  hash;
+  data;
   /**
-   * 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.
+   * Meta is an array of refs. If there are no refs we do not write a meta
+   * chunk.
    */
-  #sendResolver = resolver4();
+  meta;
+  constructor(hash2, data, refs) {
+    assert(
+      !refs.includes(hash2),
+      "Chunk cannot reference itself"
+    );
+    assertDeepFrozen(data);
+    this.hash = hash2;
+    this.data = data;
+    this.meta = refs;
+  }
+};
+function assertRefs(v2) {
+  if (!Array.isArray(v2)) {
+    throw new Error("Refs must be an array");
+  }
+  if (v2.length > 0) {
+    assertString(v2[0]);
+    for (let i = 1; i < v2.length; i++) {
+      assertString(v2[i]);
+    }
+  }
+}
+function createChunk(data, refs, chunkHasher) {
+  const hash2 = chunkHasher();
+  return new Chunk(hash2, data, refs);
+}
+
+// ../replicache/src/dag/gc.ts
+function computeRefCountUpdates(headChanges, putChunks, delegate) {
+  return new RefCountUpdates(headChanges, putChunks, delegate).compute();
+}
+var RefCountUpdates = class {
+  #newHeads;
+  #oldHeads;
+  #putChunks;
   #delegate;
-  #closed = false;
-  /**
-   * Number of pending send calls.
-   *
-   * We keep track of this because if close happens while we are waiting for the
-   * send to resolve we should reject the send promise.
-   */
-  #sendCounter = 0;
-  #lc;
-  #visibilityWatcher;
-  constructor(lc, delegate, visibilityWatcher) {
-    this.#lc = lc;
+  #refsCounted;
+  #refCountUpdates;
+  #loadedRefCountPromises;
+  #isLazyDelegate;
+  constructor(headChanges, putChunks, delegate) {
+    const newHeads = [];
+    const oldHeads = [];
+    for (const changedHead of headChanges) {
+      if (changedHead.old !== changedHead.new) {
+        changedHead.old && oldHeads.push(changedHead.old);
+        changedHead.new && newHeads.push(changedHead.new);
+      }
+    }
+    this.#newHeads = newHeads;
+    this.#oldHeads = oldHeads;
+    this.#putChunks = putChunks;
     this.#delegate = delegate;
-    this.#visibilityWatcher = visibilityWatcher;
-    void this.run();
+    this.#refCountUpdates = /* @__PURE__ */ new Map();
+    this.#loadedRefCountPromises = /* @__PURE__ */ new Map();
+    this.#isLazyDelegate = delegate.areRefsCounted !== void 0;
+    this.#refsCounted = this.#isLazyDelegate ? /* @__PURE__ */ new Set() : null;
   }
-  close() {
-    this.#closed = true;
-    if (this.#sendCounter > 0) {
-      this.#sendResolver.resolve({ error: closeError() });
+  async compute() {
+    for (const n of this.#newHeads) {
+      await this.#changeRefCount(n, 1);
     }
-  }
-  /**
-   *
-   * @returns Returns undefined if ok, otherwise it return the error that caused
-   * the send to fail.
-   */
-  async send(now) {
-    if (this.#closed) {
-      return { error: closeError() };
+    await Promise.all(
+      Array.from(
+        this.#putChunks.values(),
+        (hash2) => this.#ensureRefCountLoaded(hash2)
+      )
+    );
+    if (this.#isLazyDelegate) {
+      assert(this.#delegate.areRefsCounted);
+      assert(this.#refsCounted);
+      let refCountsUpdated;
+      do {
+        refCountsUpdated = false;
+        for (const hash2 of this.#putChunks.values()) {
+          if (!this.#delegate.areRefsCounted(hash2) && !this.#refsCounted.has(hash2) && this.#refCountUpdates.get(hash2) !== 0) {
+            await this.#updateRefsCounts(hash2, 1);
+            refCountsUpdated = true;
+            break;
+          }
+        }
+      } while (refCountsUpdated);
     }
-    this.#sendCounter++;
-    this.#lc.debug?.("send", now);
-    if (now) {
-      this.#skipSleepsResolver.resolve();
-    } else {
-      await this.#visibilityWatcher?.waitForVisible();
+    for (const o of this.#oldHeads) {
+      await this.#changeRefCount(o, -1);
     }
-    this.#pendingResolver.resolve();
-    const result = await this.#sendResolver.promise;
-    this.#sendCounter--;
-    return result;
-  }
-  async run() {
-    const sendRecords = [];
-    let recoverResolver = resolver4();
-    let lastSendTime;
-    let counter = 0;
-    const delegate = this.#delegate;
-    const { debug } = this.#lc;
-    let delay = 0;
-    debug?.("Starting connection loop");
-    const sleepMaybeSkip = (ms) => Promise.race([this.#skipSleepsResolver.promise, sleep(ms)]);
-    while (!this.#closed) {
-      debug?.(
-        didLastSendRequestFail(sendRecords) ? "Last request failed. Trying again" : "Waiting for a send"
-      );
-      const races = [this.#pendingResolver.promise];
-      const t2 = delegate.watchdogTimer;
-      if (t2 !== null) {
-        races.push(sleep(t2));
-      }
-      await Promise.race(races);
-      if (this.#closed) break;
-      debug?.("Waiting for debounce");
-      await sleepMaybeSkip(delegate.debounceDelay);
-      if (this.#closed) break;
-      debug?.("debounced");
-      this.#pendingResolver = resolver4();
-      if (counter >= delegate.maxConnections) {
-        debug?.("Too many request in flight. Waiting until one finishes...");
-        await this.#waitUntilAvailableConnection();
-        if (this.#closed) break;
-        debug?.("...finished");
-      }
-      if (counter > 0 || didLastSendRequestFail(sendRecords)) {
-        delay = computeDelayAndUpdateDurations(delay, delegate, sendRecords);
-        debug?.(
-          didLastSendRequestFail(sendRecords) ? "Last connection errored. Sleeping for" : "More than one outstanding connection (" + counter + "). Sleeping for",
-          delay,
-          "ms"
+    if (!isProd) {
+      for (const [hash2, update] of this.#refCountUpdates) {
+        assert(
+          update >= 0,
+          `ref count update must be non-negative. ${hash2}:${update}`
         );
-      } else {
-        delay = 0;
-      }
-      const clampedDelay = Math.min(
-        delegate.maxDelayMs,
-        Math.max(delegate.minDelayMs, delay)
-      );
-      if (lastSendTime !== void 0) {
-        const timeSinceLastSend = Date.now() - lastSendTime;
-        if (clampedDelay > timeSinceLastSend) {
-          await Promise.race([
-            sleepMaybeSkip(clampedDelay - timeSinceLastSend),
-            recoverResolver.promise
-          ]);
-          if (this.#closed) break;
-        }
       }
-      counter++;
-      (async () => {
-        const start = Date.now();
-        let ok2;
-        let error;
-        try {
-          lastSendTime = start;
-          debug?.("Sending request");
-          this.#skipSleepsResolver = resolver4();
-          ok2 = await delegate.invokeSend();
-          debug?.("Send returned", ok2);
-        } catch (e) {
-          debug?.("Send failed", e);
-          error = e;
-          ok2 = false;
-        }
-        if (this.#closed) {
-          debug?.("Closed after invokeSend");
-          return;
-        }
-        debug?.("Request done", { duration: Date.now() - start, ok: ok2 });
-        sendRecords.push({ duration: Date.now() - start, ok: ok2 });
-        if (recovered(sendRecords)) {
-          recoverResolver.resolve();
-          recoverResolver = resolver4();
-        }
-        counter--;
-        this.#connectionAvailable();
-        const sendResolver = this.#sendResolver;
-        this.#sendResolver = resolver4();
-        if (error) {
-          sendResolver.resolve({ error });
-        } else {
-          sendResolver.resolve(void 0);
-        }
-        if (!ok2) {
-          this.#pendingResolver.resolve();
-        }
-      })();
     }
+    return this.#refCountUpdates;
   }
-  #waitingConnectionResolve = void 0;
-  #connectionAvailable() {
-    if (this.#waitingConnectionResolve) {
-      const resolve = this.#waitingConnectionResolve;
-      this.#waitingConnectionResolve = void 0;
-      resolve();
+  async #changeRefCount(hash2, delta) {
+    await this.#ensureRefCountLoaded(hash2);
+    if (this.#updateRefCount(hash2, delta)) {
+      await this.#updateRefsCounts(hash2, delta);
     }
   }
-  #waitUntilAvailableConnection() {
-    const { promise, resolve } = resolver4();
-    this.#waitingConnectionResolve = resolve;
-    return promise;
-  }
-};
-var CONNECTION_MEMORY_COUNT = 9;
-function closeError() {
-  return new Error("Closed");
-}
-function computeDelayAndUpdateDurations(delay, delegate, sendRecords) {
-  const { length } = sendRecords;
-  if (length === 0) {
-    return delay;
-  }
-  const { ok: ok2 } = sendRecords[sendRecords.length - 1];
-  const { maxConnections, minDelayMs } = delegate;
-  if (!ok2) {
-    return delay === 0 ? minDelayMs : delay * 2;
-  }
-  if (length > 1) {
-    const previous = sendRecords[sendRecords.length - 2];
-    while (sendRecords.length > CONNECTION_MEMORY_COUNT) {
-      sendRecords.shift();
+  async #updateRefsCounts(hash2, delta) {
+    if (hash2 === emptyHash) {
+      return;
     }
-    if (ok2 && !previous.ok) {
-      return minDelayMs;
+    const refs = await this.#delegate.getRefs(hash2);
+    if (!isProd) {
+      assert(
+        refs || this.#isLazyDelegate && !this.#putChunks.has(hash2),
+        "refs must be defined"
+      );
+    }
+    if (refs !== void 0) {
+      this.#refsCounted?.add(hash2);
+      const ps = refs.map((ref) => this.#changeRefCount(ref, delta));
+      await Promise.all(ps);
     }
   }
-  const med = median(
-    sendRecords.filter(({ ok: ok3 }) => ok3).map(({ duration }) => duration)
-  );
-  return med / maxConnections | 0;
-}
-function median(values) {
-  values.sort();
-  const { length } = values;
-  const half = length >> 1;
-  if (length % 2 === 1) {
-    return values[half];
+  #ensureRefCountLoaded(hash2) {
+    let p = this.#loadedRefCountPromises.get(hash2);
+    if (p === void 0) {
+      p = (async () => {
+        const value = await this.#delegate.getRefCount(hash2) || 0;
+        this.#refCountUpdates.set(hash2, value);
+        return value;
+      })();
+      this.#loadedRefCountPromises.set(hash2, p);
+    }
+    return p;
   }
-  return (values[half - 1] + values[half]) / 2;
+  #updateRefCount(hash2, delta) {
+    const oldCount = this.#refCountUpdates.get(hash2);
+    assertNumber(oldCount);
+    this.#refCountUpdates.set(hash2, oldCount + delta);
+    return oldCount === 0 && delta === 1 || oldCount === 1 && delta === -1;
+  }
+};
+
+// ../replicache/src/dag/key.ts
+function chunkDataKey(hash2) {
+  return `c/${hash2}/d`;
 }
-function didLastSendRequestFail(sendRecords) {
-  return sendRecords.length > 0 && !sendRecords[sendRecords.length - 1].ok;
+function chunkMetaKey(hash2) {
+  return `c/${hash2}/m`;
 }
-function recovered(sendRecords) {
-  return sendRecords.length > 1 && !sendRecords[sendRecords.length - 2].ok && sendRecords[sendRecords.length - 1].ok;
+function chunkRefCountKey(hash2) {
+  return `c/${hash2}/r`;
+}
+function headKey(name) {
+  return `h/${name}`;
 }
 
-// ../replicache/src/dag/lazy-store.ts
-import { RWLock as RWLock2 } from "@rocicorp/lock";
-
-// ../shared/src/iterables.ts
-function* joinIterables(...iters) {
-  for (const iter of iters) {
-    yield* iter;
+// ../replicache/src/dag/store.ts
+var ChunkNotFoundError = class extends Error {
+  name = "ChunkNotFoundError";
+  hash;
+  constructor(hash2) {
+    super(`Chunk not found ${hash2}`);
+    this.hash = hash2;
   }
-}
-function* mergeIterables(iterables, comparator2, distinct = false) {
-  const iterators = iterables.map((i) => i[Symbol.iterator]());
-  try {
-    const current = iterators.map((i) => i.next());
-    let lastYielded;
-    while (current.some((c) => !c.done)) {
-      const min = current.reduce(
-        (acc, c, i) => {
-          if (c.done) {
-            return acc;
-          }
-          if (acc === void 0 || comparator2(c.value, acc[0]) < 0) {
-            return [c.value, i];
-          }
-          return acc;
-        },
-        void 0
-      );
-      assert(min !== void 0, "min is undefined");
-      current[min[1]] = iterators[min[1]].next();
-      if (lastYielded !== void 0 && distinct && comparator2(lastYielded, min[0]) === 0) {
-        continue;
-      }
-      lastYielded = min[0];
-      yield min[0];
-    }
-  } finally {
-    for (const it of iterators) {
-      it.return?.();
-    }
+};
+async function mustGetChunk(store, hash2) {
+  const chunk = await store.getChunk(hash2);
+  if (chunk) {
+    return chunk;
   }
+  throw new ChunkNotFoundError(hash2);
+}
+async function mustGetHeadHash(name, store) {
+  const hash2 = await store.getHead(name);
+  assert(hash2, `Missing head ${name}`);
+  return hash2;
 }
 
-// ../replicache/src/size-of-value.ts
-var SIZE_TAG = 1;
-var SIZE_INT32 = 4;
-var SIZE_SMI = 5;
-var SIZE_DOUBLE = 8;
-function getSizeOfValue(value) {
-  switch (typeof value) {
-    case "string":
-      return SIZE_TAG + SIZE_INT32 + value.length;
-    case "number":
-      if (isSmi(value)) {
-        if (value <= -(2 ** 30) || value >= 2 ** 30 - 1) {
-          return SIZE_TAG + SIZE_SMI;
-        }
-        return SIZE_TAG + SIZE_INT32;
-      }
-      return SIZE_TAG + SIZE_DOUBLE;
-    case "boolean":
-      return SIZE_TAG;
-    case "object":
-      if (value === null) {
-        return SIZE_TAG;
-      }
-      if (Array.isArray(value)) {
-        let sum = 2 * SIZE_TAG + SIZE_INT32;
-        for (const element of value) {
-          sum += getSizeOfValue(element);
-        }
-        return sum;
-      }
-      {
-        const val = value;
-        let sum = 2 * SIZE_TAG + SIZE_INT32;
-        for (const k in val) {
-          if (hasOwn(val, k)) {
-            const propertyValue = val[k];
-            if (propertyValue !== void 0) {
-              sum += getSizeOfValue(k) + getSizeOfValue(propertyValue);
-            }
-          }
-        }
-        return sum;
-      }
+// ../replicache/src/dag/store-impl.ts
+var StoreImpl = class {
+  #kv;
+  #chunkHasher;
+  #assertValidHash;
+  constructor(kv, chunkHasher, assertValidHash) {
+    this.#kv = kv;
+    this.#chunkHasher = chunkHasher;
+    this.#assertValidHash = assertValidHash;
   }
-  throw new Error(`Invalid value. type: ${typeof value}, value: ${value}`);
-}
-function isSmi(value) {
-  return value === (value | 0);
-}
-var entryFixed = 2 * SIZE_TAG + SIZE_INT32 + SIZE_TAG + SIZE_INT32;
-function getSizeOfEntry(key, value) {
-  return entryFixed + getSizeOfValue(key) + getSizeOfValue(value);
-}
-
-// ../replicache/src/dag/chunk.ts
-function asRefs(sortedRefs) {
-  return sortedRefs;
-}
-function toRefs(refs) {
-  if (Array.isArray(refs)) {
-    refs.sort();
-    for (let i = 1; i < refs.length; i++) {
-      assert(refs[i - 1] !== refs[i], "Refs must not have duplicates");
-    }
-    return asRefs(refs);
+  async read() {
+    return new ReadImpl2(await this.#kv.read(), this.#assertValidHash);
   }
-  const refsArray = [...refs];
-  refsArray.sort();
-  return asRefs(refsArray);
-}
-var Chunk = class {
-  hash;
-  data;
-  /**
-   * Meta is an array of refs. If there are no refs we do not write a meta
-   * chunk.
-   */
-  meta;
-  constructor(hash2, data, refs) {
-    assert(
-      !refs.includes(hash2),
-      "Chunk cannot reference itself"
+  async write() {
+    return new WriteImpl2(
+      await this.#kv.write(),
+      this.#chunkHasher,
+      this.#assertValidHash
     );
-    assertDeepFrozen(data);
-    this.hash = hash2;
-    this.data = data;
-    this.meta = refs;
+  }
+  close() {
+    return this.#kv.close();
   }
 };
-function assertRefs(v2) {
-  if (!Array.isArray(v2)) {
-    throw new Error("Refs must be an array");
+var ReadImpl2 = class {
+  _tx;
+  assertValidHash;
+  constructor(kv, assertValidHash) {
+    this._tx = kv;
+    this.assertValidHash = assertValidHash;
   }
-  if (v2.length > 0) {
-    assertString(v2[0]);
-    for (let i = 1; i < v2.length; i++) {
-      assertString(v2[i]);
+  hasChunk(hash2) {
+    return this._tx.has(chunkDataKey(hash2));
+  }
+  async getChunk(hash2) {
+    const data = await this._tx.get(chunkDataKey(hash2));
+    if (data === void 0) {
+      return void 0;
+    }
+    const refsVal = await this._tx.get(chunkMetaKey(hash2));
+    let refs;
+    if (refsVal !== void 0) {
+      assertRefs(refsVal);
+      refs = refsVal;
+    } else {
+      refs = [];
     }
+    return new Chunk(hash2, data, refs);
   }
-}
-function createChunk(data, refs, chunkHasher) {
-  const hash2 = chunkHasher();
-  return new Chunk(hash2, data, refs);
-}
-
-// ../shared/src/random-uint64.ts
-function randomUint64() {
-  const high = Math.floor(Math.random() * 4294967295);
-  const low = Math.floor(Math.random() * 4294967295);
-  return BigInt(high) << 32n | BigInt(low);
-}
-
-// ../shared/src/valita.ts
-var valita_exports = {};
-__export(valita_exports, {
-  assert: () => assert2,
-  deepPartial: () => deepPartial,
-  instanceOfAbstractType: () => instanceOfAbstractType,
-  is: () => is,
-  parse: () => parse,
-  readonly: () => readonly,
-  readonlyArray: () => readonlyArray,
-  readonlyObject: () => readonlyObject,
-  readonlyRecord: () => readonlyRecord,
-  test: () => test,
-  testOptional: () => testOptional
-});
-__reExport(valita_exports, valita_star);
-import * as v from "@badrap/valita";
-import * as valita_star from "@badrap/valita";
-function toDisplay(value) {
-  switch (typeof value) {
-    case "string":
-    case "number":
-    case "boolean":
-      return JSON.stringify(value);
-    case "undefined":
-      return "undefined";
-    case "bigint":
-      return value.toString() + "n";
-    default:
-      if (value === null) {
-        return "null";
-      }
-      if (Array.isArray(value)) {
-        return "array";
-      }
-      return typeof value;
+  mustGetChunk(hash2) {
+    return mustGetChunk(this, hash2);
   }
-}
-function toDisplayAtPath(v2, path2) {
-  if (!path2?.length) {
-    return toDisplay(v2);
+  async getHead(name) {
+    const data = await this._tx.get(headKey(name));
+    if (data === void 0) {
+      return void 0;
+    }
+    assertHash(data);
+    return data;
   }
-  let cur = v2;
-  for (const p of path2) {
-    cur = cur[p];
+  release() {
+    this._tx.release();
   }
-  return toDisplay(cur);
-}
-function displayList(word, expected, toDisplay2 = (x) => String(x)) {
-  if (expected.length === 1) {
-    return toDisplay2(expected[0]);
+  get closed() {
+    return this._tx.closed;
   }
-  const suffix = `${toDisplay2(
-    expected[expected.length - 2]
-  )} ${word} ${toDisplay2(expected[expected.length - 1])}`;
-  if (expected.length === 2) {
-    return suffix;
+};
+var WriteImpl2 = class extends ReadImpl2 {
+  #chunkHasher;
+  #putChunks = /* @__PURE__ */ new Set();
+  #changedHeads = /* @__PURE__ */ new Map();
+  constructor(kvw, chunkHasher, assertValidHash) {
+    super(kvw, assertValidHash);
+    this.#chunkHasher = chunkHasher;
   }
-  return `${expected.slice(0, -2).map(toDisplay2).join(", ")}, ${suffix}`;
-}
-function getMessage(err2, v2, schema, mode) {
-  const firstIssue = err2.issues[0];
-  const { path: path2 } = firstIssue;
-  const atPath = path2?.length ? ` at ${path2.join(".")}` : "";
-  switch (firstIssue.code) {
-    case "invalid_type":
-      return `Expected ${displayList(
-        "or",
-        firstIssue.expected
-      )}${atPath}. Got ${toDisplayAtPath(v2, path2)}`;
-    case "missing_value": {
-      const atPath2 = path2 && path2.length > 1 ? ` at ${path2.slice(0, -1).join(".")}` : "";
-      if (firstIssue.path?.length) {
-        return `Missing property ${firstIssue.path.at(-1)}${atPath2}`;
+  createChunk = (data, refs) => createChunk(data, refs, this.#chunkHasher);
+  get kvWrite() {
+    return this._tx;
+  }
+  async putChunk(c) {
+    const { hash: hash2, data, meta } = c;
+    this.assertValidHash(hash2);
+    const key = chunkDataKey(hash2);
+    const p1 = this._tx.put(key, data);
+    let p2;
+    if (meta.length > 0) {
+      for (const h of meta) {
+        this.assertValidHash(h);
       }
-      return `TODO Unknown missing property${atPath2}`;
-    }
-    case "invalid_literal":
-      return `Expected literal value ${displayList(
-        "or",
-        firstIssue.expected,
-        toDisplay
-      )}${atPath} Got ${toDisplayAtPath(v2, path2)}`;
-    case "invalid_length": {
-      return `Expected array with length ${firstIssue.minLength === firstIssue.maxLength ? firstIssue.minLength : `between ${firstIssue.minLength} and ${firstIssue.maxLength}`}${atPath}. Got array with length ${v2.length}`;
-    }
-    case "unrecognized_keys":
-      if (firstIssue.keys.length === 1) {
-        return `Unexpected property ${firstIssue.keys[0]}${atPath}`;
-      }
-      return `Unexpected properties ${displayList(
-        "and",
-        firstIssue.keys
-      )}${atPath}`;
-    case "invalid_union":
-      return schema.name === "union" ? getDeepestUnionParseError(v2, schema, mode ?? "strict") : `Invalid union value${atPath}`;
-    case "custom_error": {
-      const { error } = firstIssue;
-      const message = !error ? "unknown" : typeof error === "string" ? error : error.message ?? "unknown";
-      return `${message}${atPath}. Got ${toDisplayAtPath(v2, path2)}`;
+      p2 = this._tx.put(chunkMetaKey(hash2), meta);
     }
+    this.#putChunks.add(hash2);
+    await p1;
+    await p2;
   }
-}
-function getDeepestUnionParseError(value, schema, mode) {
-  const failures = [];
-  for (const type of schema.options) {
-    const r = type.try(value, { mode });
-    if (!r.ok) {
-      failures.push({ type, err: r });
-    }
+  setHead(name, hash2) {
+    return this.#setHead(name, hash2);
   }
-  if (failures.length) {
-    failures.sort(pathCmp);
-    if (failures.length === 1 || pathCmp(failures[0], failures[1]) < 0) {
-      return getMessage(failures[0].err, value, failures[0].type, mode);
+  removeHead(name) {
+    return this.#setHead(name, void 0);
+  }
+  async #setHead(name, hash2) {
+    const oldHash = await this.getHead(name);
+    const hk = headKey(name);
+    let p1;
+    if (hash2 === void 0) {
+      p1 = this._tx.del(hk);
+    } else {
+      p1 = this._tx.put(hk, hash2);
+    }
+    const v2 = this.#changedHeads.get(name);
+    if (v2 === void 0) {
+      this.#changedHeads.set(name, { new: hash2, old: oldHash });
+    } else {
+      v2.new = hash2;
     }
+    await p1;
   }
-  try {
-    const str = JSON.stringify(value);
-    return `Invalid union value: ${str}`;
-  } catch (e) {
-    return `Invalid union value`;
+  async commit() {
+    const refCountUpdates = await computeRefCountUpdates(
+      this.#changedHeads.values(),
+      this.#putChunks,
+      this
+    );
+    await this.#applyRefCountUpdates(refCountUpdates);
+    await this._tx.commit();
   }
-}
-function pathCmp(a, b) {
-  const aPath = a.err.issues[0].path;
-  const bPath = b.err.issues[0].path;
-  if (aPath.length !== bPath.length) {
-    return bPath.length - aPath.length;
+  async getRefCount(hash2) {
+    const value = await this._tx.get(chunkRefCountKey(hash2));
+    if (value === void 0) {
+      return void 0;
+    }
+    assertNumber(value);
+    if (value < 0 || value > 65535 || value !== (value | 0)) {
+      throw new Error(
+        `Invalid ref count ${value}. We expect the value to be a Uint16`
+      );
+    }
+    return value;
   }
-  for (let i = 0; i < aPath.length; i++) {
-    if (bPath[i] > aPath[i]) {
-      return -1;
+  async getRefs(hash2) {
+    const meta = await this._tx.get(chunkMetaKey(hash2));
+    if (meta === void 0) {
+      return [];
     }
-    if (bPath[i] < aPath[i]) {
-      return 1;
+    assertRefs(meta);
+    return meta;
+  }
+  async #applyRefCountUpdates(refCountCache) {
+    const ps = [];
+    for (const [hash2, count] of refCountCache) {
+      if (count === 0) {
+        ps.push(this.#removeAllRelatedKeys(hash2));
+      } else {
+        const refCountKey = chunkRefCountKey(hash2);
+        ps.push(this._tx.put(refCountKey, count));
+      }
     }
+    await Promise.all(ps);
   }
-  return 0;
-}
-function parse(value, schema, mode) {
-  const res = test(value, schema, mode);
-  if (!res.ok) {
-    throw new TypeError(res.error);
+  async #removeAllRelatedKeys(hash2) {
+    await Promise.all([
+      this._tx.del(chunkDataKey(hash2)),
+      this._tx.del(chunkMetaKey(hash2)),
+      this._tx.del(chunkRefCountKey(hash2))
+    ]);
+    this.#putChunks.delete(hash2);
   }
-  return res.value;
-}
-function is(value, schema, mode) {
-  return test(value, schema, mode).ok;
-}
-function assert2(value, schema, mode) {
-  parse(value, schema, mode);
-}
-function test(value, schema, mode) {
-  const res = schema.try(value, mode ? { mode } : void 0);
-  if (!res.ok) {
-    return {
-      ok: false,
-      error: getMessage(res, value, schema, mode)
-    };
+  release() {
+    this._tx.release();
   }
-  return res;
+};
+
+// ../replicache/src/format-version-enum.ts
+var DD31 = 5;
+var V6 = 6;
+var V7 = 7;
+var Latest = V7;
+
+// ../replicache/src/log-options.ts
+import {
+  consoleLogSink,
+  LogContext,
+  TeeLogSink
+} from "@rocicorp/logger";
+function createLogContext(logLevel = "info", logSinks = [consoleLogSink], context) {
+  const logSink = logSinks.length === 1 ? logSinks[0] : new TeeLogSink(logSinks);
+  return new LogContext(logLevel, context, logSink);
 }
-function testOptional(value, schema, mode) {
-  let flags = 1;
-  if (mode === "passthrough") {
-    flags = 0;
-  } else if (mode === "strip") {
-    flags = 2;
+
+// ../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;
   }
-  const res = schema.func(value, flags);
-  if (res === void 0) {
-    return { ok: true, value };
-  } else if (res.ok) {
-    return res;
+  release() {
+    this.#release();
+    this.#closed = true;
   }
-  const err2 = new v.ValitaError(res);
-  return { ok: false, error: getMessage(err2, value, schema, mode) };
-}
-function readonly(t2) {
-  return t2;
-}
-function readonlyObject(t2) {
-  return v.object(t2);
-}
-function readonlyArray(t2) {
-  return v.array(t2);
-}
-function readonlyRecord(t2) {
-  return v.record(t2);
-}
-var AbstractType = Object.getPrototypeOf(
-  Object.getPrototypeOf(v.string().optional())
-).constructor;
-function instanceOfAbstractType(obj) {
-  return obj instanceof AbstractType;
+  get closed() {
+    return this.#closed;
+  }
+  has(key) {
+    return Promise.resolve(this.#map.has(key));
+  }
+  get(key) {
+    return 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() {
+    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;
 }
-function deepPartial(s) {
-  const shape = {};
-  for (const [key, type] of Object.entries(s.shape)) {
-    if (type.name === "object") {
-      shape[key] = deepPartial(type).optional();
+var MemStore = class {
+  #map;
+  #rwLock;
+  #closed = false;
+  constructor(name) {
+    const entry = stores.get(name);
+    let lock;
+    let map;
+    if (entry) {
+      ({ lock, map } = entry);
     } else {
-      shape[key] = type.optional();
+      lock = new RWLock();
+      map = /* @__PURE__ */ new Map();
+      stores.set(name, { lock, map });
+    }
+    this.#rwLock = lock;
+    this.#map = map;
+  }
+  async read() {
+    const release = await this.#rwLock.read();
+    return new ReadImpl3(this.#map, release);
+  }
+  async write() {
+    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/replicache-impl.ts
+import { Lock as Lock2 } from "@rocicorp/lock";
+import { consoleLogSink as consoleLogSink2 } from "@rocicorp/logger";
+import { resolver as resolver6 } from "@rocicorp/resolver";
+
+// ../shared/src/document-visible.ts
+import { resolver as resolver3 } from "@rocicorp/resolver";
+function getDocumentVisibilityWatcher(doc, hiddenIntervalMS, signal) {
+  return doc ? new DocumentVisibilityWatcherImpl(doc, hiddenIntervalMS, signal) : new DocumentVisibilityWatcherNoDoc();
+}
+var DocumentVisibilityWatcherImpl = class {
+  #doc;
+  #hiddenIntervalMS;
+  #timeoutID = 0;
+  // This trails doc.visibilityState by hiddenIntervalMS when being hidden. This
+  // is because we want to wait for the tab to be hidden for a while before
+  // considering as hidden.
+  visibilityState;
+  #promises = /* @__PURE__ */ new Set();
+  constructor(doc, hiddenIntervalMS, signal) {
+    this.#doc = doc;
+    this.#hiddenIntervalMS = hiddenIntervalMS;
+    this.visibilityState = doc.visibilityState;
+    this.#doc.addEventListener("visibilitychange", this.#onVisibilityChange, {
+      signal
+    });
+  }
+  #onVisibilityChange = () => {
+    if (this.#doc.visibilityState === "visible") {
+      clearTimeout(this.#timeoutID);
+      this.#setVisibilityState("visible");
+    } else {
+      this.#timeoutID = setTimeout(() => {
+        this.#setVisibilityState("hidden");
+      }, this.#hiddenIntervalMS);
+    }
+  };
+  #setVisibilityState(visibilityState) {
+    if (visibilityState === this.visibilityState) {
+      return;
+    }
+    this.visibilityState = visibilityState;
+    for (const entry of this.#promises) {
+      const { resolve, state } = entry;
+      if (state === visibilityState) {
+        resolve();
+        this.#promises.delete(entry);
+      }
+    }
+  }
+  waitForVisible() {
+    return this.#waitFor("visible");
+  }
+  waitForHidden() {
+    return this.#waitFor("hidden");
+  }
+  #waitFor(state) {
+    if (this.visibilityState === state) {
+      return Promise.resolve();
+    }
+    const { promise, resolve } = resolver3();
+    this.#promises.add({ resolve, state });
+    return promise;
+  }
+};
+var resolvedPromise = Promise.resolve();
+var promiseThatNeverResolves = new Promise(() => void 0);
+var DocumentVisibilityWatcherNoDoc = class {
+  visibilityState = "visible";
+  waitForVisible() {
+    return resolvedPromise;
+  }
+  waitForHidden() {
+    return promiseThatNeverResolves;
+  }
+};
+
+// ../replicache/src/connection-loop-delegates.ts
+var ConnectionLoopDelegateImpl = class {
+  rep;
+  invokeSend;
+  // TODO: Remove the ability to have more than one concurrent connection and update tests.
+  // Bug: https://github.com/rocicorp/replicache-internal/issues/303
+  maxConnections = 1;
+  constructor(rep, invokeSend) {
+    this.rep = rep;
+    this.invokeSend = invokeSend;
+  }
+  get maxDelayMs() {
+    return this.rep.requestOptions.maxDelayMs;
+  }
+  get minDelayMs() {
+    return this.rep.requestOptions.minDelayMs;
+  }
+};
+var PullDelegate = class extends ConnectionLoopDelegateImpl {
+  debounceDelay = 0;
+  get watchdogTimer() {
+    return this.rep.pullInterval;
+  }
+};
+var PushDelegate = class extends ConnectionLoopDelegateImpl {
+  get debounceDelay() {
+    return this.rep.pushDelay;
+  }
+  watchdogTimer = null;
+};
+
+// ../replicache/src/connection-loop.ts
+import { resolver as resolver4 } from "@rocicorp/resolver";
+var MIN_DELAY_MS = 30;
+var MAX_DELAY_MS = 6e4;
+var ConnectionLoop = class {
+  // ConnectionLoop runs a loop sending network requests (either pushes or
+  // pulls) to the server. Our goal, generally, is to send requests as fast as
+  // we can, but to adjust in case of slowness, network errors, etc. We will
+  // send requests in parallel if the server supports it. We also debounce
+  // pushes since they frequently happen in series very near to one another
+  // (e.g., during drag'n drops).
+  //
+  // The loop flows through the following states forever, until it is closed:
+  //
+  // Pending: Wait for event or watchdog
+  //          |
+  //          v
+  // Debounce: Wait for more events (we debounce pushes)
+  //          |
+  //          v
+  // Wait for available connection (we limit number of parallel requests
+  // allowed)
+  //          |
+  //          v
+  // Wait to send (if requests are taking too long, we will slow down)
+  //          |
+  //          v
+  // Send (asynchronously, wrt the loop)
+  //          |
+  //          v
+  // Back to the pending!
+  // Controls whether the next iteration of the loop will wait at the pending
+  // state.
+  #pendingResolver = resolver4();
+  /**
+   * This resolver is used to allow us to skip sleeps when we do send(true)
+   */
+  #skipSleepsResolver = resolver4();
+  /**
+   * 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();
+  #delegate;
+  #closed = false;
+  /**
+   * Number of pending send calls.
+   *
+   * We keep track of this because if close happens while we are waiting for the
+   * send to resolve we should reject the send promise.
+   */
+  #sendCounter = 0;
+  #lc;
+  #visibilityWatcher;
+  constructor(lc, delegate, visibilityWatcher) {
+    this.#lc = lc;
+    this.#delegate = delegate;
+    this.#visibilityWatcher = visibilityWatcher;
+    void this.run();
+  }
+  close() {
+    this.#closed = true;
+    if (this.#sendCounter > 0) {
+      this.#sendResolver.resolve({ error: closeError() });
+    }
+  }
+  /**
+   *
+   * @returns Returns undefined if ok, otherwise it return the error that caused
+   * the send to fail.
+   */
+  async send(now) {
+    if (this.#closed) {
+      return { error: closeError() };
+    }
+    this.#sendCounter++;
+    this.#lc.debug?.("send", now);
+    if (now) {
+      this.#skipSleepsResolver.resolve();
+    } else {
+      await this.#visibilityWatcher?.waitForVisible();
+    }
+    this.#pendingResolver.resolve();
+    const result = await this.#sendResolver.promise;
+    this.#sendCounter--;
+    return result;
+  }
+  async run() {
+    const sendRecords = [];
+    let recoverResolver = resolver4();
+    let lastSendTime;
+    let counter = 0;
+    const delegate = this.#delegate;
+    const { debug } = this.#lc;
+    let delay = 0;
+    debug?.("Starting connection loop");
+    const sleepMaybeSkip = (ms) => Promise.race([this.#skipSleepsResolver.promise, sleep(ms)]);
+    while (!this.#closed) {
+      debug?.(
+        didLastSendRequestFail(sendRecords) ? "Last request failed. Trying again" : "Waiting for a send"
+      );
+      const races = [this.#pendingResolver.promise];
+      const t2 = delegate.watchdogTimer;
+      if (t2 !== null) {
+        races.push(sleep(t2));
+      }
+      await Promise.race(races);
+      if (this.#closed) break;
+      debug?.("Waiting for debounce");
+      await sleepMaybeSkip(delegate.debounceDelay);
+      if (this.#closed) break;
+      debug?.("debounced");
+      this.#pendingResolver = resolver4();
+      if (counter >= delegate.maxConnections) {
+        debug?.("Too many request in flight. Waiting until one finishes...");
+        await this.#waitUntilAvailableConnection();
+        if (this.#closed) break;
+        debug?.("...finished");
+      }
+      if (counter > 0 || didLastSendRequestFail(sendRecords)) {
+        delay = computeDelayAndUpdateDurations(delay, delegate, sendRecords);
+        debug?.(
+          didLastSendRequestFail(sendRecords) ? "Last connection errored. Sleeping for" : "More than one outstanding connection (" + counter + "). Sleeping for",
+          delay,
+          "ms"
+        );
+      } else {
+        delay = 0;
+      }
+      const clampedDelay = Math.min(
+        delegate.maxDelayMs,
+        Math.max(delegate.minDelayMs, delay)
+      );
+      if (lastSendTime !== void 0) {
+        const timeSinceLastSend = Date.now() - lastSendTime;
+        if (clampedDelay > timeSinceLastSend) {
+          await Promise.race([
+            sleepMaybeSkip(clampedDelay - timeSinceLastSend),
+            recoverResolver.promise
+          ]);
+          if (this.#closed) break;
+        }
+      }
+      counter++;
+      (async () => {
+        const start = Date.now();
+        let ok2;
+        let error;
+        try {
+          lastSendTime = start;
+          debug?.("Sending request");
+          this.#skipSleepsResolver = resolver4();
+          ok2 = await delegate.invokeSend();
+          debug?.("Send returned", ok2);
+        } catch (e) {
+          debug?.("Send failed", e);
+          error = e;
+          ok2 = false;
+        }
+        if (this.#closed) {
+          debug?.("Closed after invokeSend");
+          return;
+        }
+        debug?.("Request done", { duration: Date.now() - start, ok: ok2 });
+        sendRecords.push({ duration: Date.now() - start, ok: ok2 });
+        if (recovered(sendRecords)) {
+          recoverResolver.resolve();
+          recoverResolver = resolver4();
+        }
+        counter--;
+        this.#connectionAvailable();
+        const sendResolver = this.#sendResolver;
+        this.#sendResolver = resolver4();
+        if (error) {
+          sendResolver.resolve({ error });
+        } else {
+          sendResolver.resolve(void 0);
+        }
+        if (!ok2) {
+          this.#pendingResolver.resolve();
+        }
+      })();
+    }
+  }
+  #waitingConnectionResolve = void 0;
+  #connectionAvailable() {
+    if (this.#waitingConnectionResolve) {
+      const resolve = this.#waitingConnectionResolve;
+      this.#waitingConnectionResolve = void 0;
+      resolve();
+    }
+  }
+  #waitUntilAvailableConnection() {
+    const { promise, resolve } = resolver4();
+    this.#waitingConnectionResolve = resolve;
+    return promise;
+  }
+};
+var CONNECTION_MEMORY_COUNT = 9;
+function closeError() {
+  return new Error("Closed");
+}
+function computeDelayAndUpdateDurations(delay, delegate, sendRecords) {
+  const { length } = sendRecords;
+  if (length === 0) {
+    return delay;
+  }
+  const { ok: ok2 } = sendRecords[sendRecords.length - 1];
+  const { maxConnections, minDelayMs } = delegate;
+  if (!ok2) {
+    return delay === 0 ? minDelayMs : delay * 2;
+  }
+  if (length > 1) {
+    const previous = sendRecords[sendRecords.length - 2];
+    while (sendRecords.length > CONNECTION_MEMORY_COUNT) {
+      sendRecords.shift();
+    }
+    if (ok2 && !previous.ok) {
+      return minDelayMs;
     }
   }
-  return v.object(shape);
-}
-
-// ../replicache/src/hash.ts
-var STRING_LENGTH = 22;
-var hashRe = /^[0-9a-v-]+$/;
-var emptyUUID = "0".repeat(STRING_LENGTH);
-var emptyHash = emptyUUID;
-var newRandomHash = makeNewRandomHashFunctionInternal();
-function toStringAndSlice(n, len) {
-  return n.toString(32).slice(-len).padStart(len, "0");
+  const med = median(
+    sendRecords.filter(({ ok: ok3 }) => ok3).map(({ duration }) => duration)
+  );
+  return med / maxConnections | 0;
 }
-function makeNewRandomHashFunctionInternal() {
-  let base = "";
-  let i = 0;
-  return () => {
-    if (!base) {
-      base = toStringAndSlice(randomUint64(), 12);
-    }
-    const tail = toStringAndSlice(i++, 10);
-    return base + tail;
-  };
+function median(values) {
+  values.sort();
+  const { length } = values;
+  const half = length >> 1;
+  if (length % 2 === 1) {
+    return values[half];
+  }
+  return (values[half - 1] + values[half]) / 2;
 }
-function isHash(value) {
-  return typeof value === "string" && hashRe.test(value);
+function didLastSendRequestFail(sendRecords) {
+  return sendRecords.length > 0 && !sendRecords[sendRecords.length - 1].ok;
 }
-function assertHash(value) {
-  assert2(value, hashSchema);
+function recovered(sendRecords) {
+  return sendRecords.length > 1 && !sendRecords[sendRecords.length - 2].ok && sendRecords[sendRecords.length - 1].ok;
 }
-var hashSchema = valita_exports.string().assert(isHash, "Invalid hash");
 
-// ../replicache/src/dag/gc.ts
-function computeRefCountUpdates(headChanges, putChunks, delegate) {
-  return new RefCountUpdates(headChanges, putChunks, delegate).compute();
-}
-var RefCountUpdates = class {
-  #newHeads;
-  #oldHeads;
-  #putChunks;
-  #delegate;
-  #refsCounted;
-  #refCountUpdates;
-  #loadedRefCountPromises;
-  #isLazyDelegate;
-  constructor(headChanges, putChunks, delegate) {
-    const newHeads = [];
-    const oldHeads = [];
-    for (const changedHead of headChanges) {
-      if (changedHead.old !== changedHead.new) {
-        changedHead.old && oldHeads.push(changedHead.old);
-        changedHead.new && newHeads.push(changedHead.new);
-      }
-    }
-    this.#newHeads = newHeads;
-    this.#oldHeads = oldHeads;
-    this.#putChunks = putChunks;
-    this.#delegate = delegate;
-    this.#refCountUpdates = /* @__PURE__ */ new Map();
-    this.#loadedRefCountPromises = /* @__PURE__ */ new Map();
-    this.#isLazyDelegate = delegate.areRefsCounted !== void 0;
-    this.#refsCounted = this.#isLazyDelegate ? /* @__PURE__ */ new Set() : null;
+// ../replicache/src/dag/lazy-store.ts
+import { RWLock as RWLock2 } from "@rocicorp/lock";
+
+// ../shared/src/iterables.ts
+function* joinIterables(...iters) {
+  for (const iter of iters) {
+    yield* iter;
   }
-  async compute() {
-    for (const n of this.#newHeads) {
-      await this.#changeRefCount(n, 1);
-    }
-    await Promise.all(
-      Array.from(
-        this.#putChunks.values(),
-        (hash2) => this.#ensureRefCountLoaded(hash2)
-      )
-    );
-    if (this.#isLazyDelegate) {
-      assert(this.#delegate.areRefsCounted);
-      assert(this.#refsCounted);
-      let refCountsUpdated;
-      do {
-        refCountsUpdated = false;
-        for (const hash2 of this.#putChunks.values()) {
-          if (!this.#delegate.areRefsCounted(hash2) && !this.#refsCounted.has(hash2) && this.#refCountUpdates.get(hash2) !== 0) {
-            await this.#updateRefsCounts(hash2, 1);
-            refCountsUpdated = true;
-            break;
+}
+function* mergeIterables(iterables, comparator2, distinct = false) {
+  const iterators = iterables.map((i) => i[Symbol.iterator]());
+  try {
+    const current = iterators.map((i) => i.next());
+    let lastYielded;
+    while (current.some((c) => !c.done)) {
+      const min = current.reduce(
+        (acc, c, i) => {
+          if (c.done) {
+            return acc;
           }
-        }
-      } while (refCountsUpdated);
-    }
-    for (const o of this.#oldHeads) {
-      await this.#changeRefCount(o, -1);
-    }
-    if (!isProd) {
-      for (const [hash2, update] of this.#refCountUpdates) {
-        assert(
-          update >= 0,
-          `ref count update must be non-negative. ${hash2}:${update}`
-        );
-      }
-    }
-    return this.#refCountUpdates;
-  }
-  async #changeRefCount(hash2, delta) {
-    await this.#ensureRefCountLoaded(hash2);
-    if (this.#updateRefCount(hash2, delta)) {
-      await this.#updateRefsCounts(hash2, delta);
-    }
-  }
-  async #updateRefsCounts(hash2, delta) {
-    if (hash2 === emptyHash) {
-      return;
-    }
-    const refs = await this.#delegate.getRefs(hash2);
-    if (!isProd) {
-      assert(
-        refs || this.#isLazyDelegate && !this.#putChunks.has(hash2),
-        "refs must be defined"
+          if (acc === void 0 || comparator2(c.value, acc[0]) < 0) {
+            return [c.value, i];
+          }
+          return acc;
+        },
+        void 0
       );
+      assert(min !== void 0, "min is undefined");
+      current[min[1]] = iterators[min[1]].next();
+      if (lastYielded !== void 0 && distinct && comparator2(lastYielded, min[0]) === 0) {
+        continue;
+      }
+      lastYielded = min[0];
+      yield min[0];
     }
-    if (refs !== void 0) {
-      this.#refsCounted?.add(hash2);
-      const ps = refs.map((ref) => this.#changeRefCount(ref, delta));
-      await Promise.all(ps);
-    }
-  }
-  #ensureRefCountLoaded(hash2) {
-    let p = this.#loadedRefCountPromises.get(hash2);
-    if (p === void 0) {
-      p = (async () => {
-        const value = await this.#delegate.getRefCount(hash2) || 0;
-        this.#refCountUpdates.set(hash2, value);
-        return value;
-      })();
-      this.#loadedRefCountPromises.set(hash2, p);
+  } finally {
+    for (const it of iterators) {
+      it.return?.();
     }
-    return p;
-  }
-  #updateRefCount(hash2, delta) {
-    const oldCount = this.#refCountUpdates.get(hash2);
-    assertNumber(oldCount);
-    this.#refCountUpdates.set(hash2, oldCount + delta);
-    return oldCount === 0 && delta === 1 || oldCount === 1 && delta === -1;
   }
-};
+}
 
-// ../replicache/src/dag/store.ts
-var ChunkNotFoundError = class extends Error {
-  name = "ChunkNotFoundError";
-  hash;
-  constructor(hash2) {
-    super(`Chunk not found ${hash2}`);
-    this.hash = hash2;
-  }
-};
-async function mustGetChunk(store, hash2) {
-  const chunk = await store.getChunk(hash2);
-  if (chunk) {
-    return chunk;
+// ../replicache/src/size-of-value.ts
+var SIZE_TAG = 1;
+var SIZE_INT32 = 4;
+var SIZE_SMI = 5;
+var SIZE_DOUBLE = 8;
+function getSizeOfValue(value) {
+  switch (typeof value) {
+    case "string":
+      return SIZE_TAG + SIZE_INT32 + value.length;
+    case "number":
+      if (isSmi(value)) {
+        if (value <= -(2 ** 30) || value >= 2 ** 30 - 1) {
+          return SIZE_TAG + SIZE_SMI;
+        }
+        return SIZE_TAG + SIZE_INT32;
+      }
+      return SIZE_TAG + SIZE_DOUBLE;
+    case "boolean":
+      return SIZE_TAG;
+    case "object":
+      if (value === null) {
+        return SIZE_TAG;
+      }
+      if (Array.isArray(value)) {
+        let sum = 2 * SIZE_TAG + SIZE_INT32;
+        for (const element of value) {
+          sum += getSizeOfValue(element);
+        }
+        return sum;
+      }
+      {
+        const val = value;
+        let sum = 2 * SIZE_TAG + SIZE_INT32;
+        for (const k in val) {
+          if (hasOwn(val, k)) {
+            const propertyValue = val[k];
+            if (propertyValue !== void 0) {
+              sum += getSizeOfValue(k) + getSizeOfValue(propertyValue);
+            }
+          }
+        }
+        return sum;
+      }
   }
-  throw new ChunkNotFoundError(hash2);
+  throw new Error(`Invalid value. type: ${typeof value}, value: ${value}`);
 }
-async function mustGetHeadHash(name, store) {
-  const hash2 = await store.getHead(name);
-  assert(hash2, `Missing head ${name}`);
-  return hash2;
+function isSmi(value) {
+  return value === (value | 0);
+}
+var entryFixed = 2 * SIZE_TAG + SIZE_INT32 + SIZE_TAG + SIZE_INT32;
+function getSizeOfEntry(key, value) {
+  return entryFixed + getSizeOfValue(key) + getSizeOfValue(value);
 }
 
 // ../replicache/src/dag/lazy-store.ts
@@ -2327,193 +2542,6 @@ var ChunksCache = class {
   }
 };
 
-// ../replicache/src/dag/key.ts
-function chunkDataKey(hash2) {
-  return `c/${hash2}/d`;
-}
-function chunkMetaKey(hash2) {
-  return `c/${hash2}/m`;
-}
-function chunkRefCountKey(hash2) {
-  return `c/${hash2}/r`;
-}
-function headKey(name) {
-  return `h/${name}`;
-}
-
-// ../replicache/src/dag/store-impl.ts
-var StoreImpl = class {
-  #kv;
-  #chunkHasher;
-  #assertValidHash;
-  constructor(kv, chunkHasher, assertValidHash) {
-    this.#kv = kv;
-    this.#chunkHasher = chunkHasher;
-    this.#assertValidHash = assertValidHash;
-  }
-  async read() {
-    return new ReadImpl3(await this.#kv.read(), this.#assertValidHash);
-  }
-  async write() {
-    return new WriteImpl3(
-      await this.#kv.write(),
-      this.#chunkHasher,
-      this.#assertValidHash
-    );
-  }
-  close() {
-    return this.#kv.close();
-  }
-};
-var ReadImpl3 = class {
-  _tx;
-  assertValidHash;
-  constructor(kv, assertValidHash) {
-    this._tx = kv;
-    this.assertValidHash = assertValidHash;
-  }
-  hasChunk(hash2) {
-    return this._tx.has(chunkDataKey(hash2));
-  }
-  async getChunk(hash2) {
-    const data = await this._tx.get(chunkDataKey(hash2));
-    if (data === void 0) {
-      return void 0;
-    }
-    const refsVal = await this._tx.get(chunkMetaKey(hash2));
-    let refs;
-    if (refsVal !== void 0) {
-      assertRefs(refsVal);
-      refs = refsVal;
-    } else {
-      refs = [];
-    }
-    return new Chunk(hash2, data, refs);
-  }
-  mustGetChunk(hash2) {
-    return mustGetChunk(this, hash2);
-  }
-  async getHead(name) {
-    const data = await this._tx.get(headKey(name));
-    if (data === void 0) {
-      return void 0;
-    }
-    assertHash(data);
-    return data;
-  }
-  release() {
-    this._tx.release();
-  }
-  get closed() {
-    return this._tx.closed;
-  }
-};
-var WriteImpl3 = class extends ReadImpl3 {
-  #chunkHasher;
-  #putChunks = /* @__PURE__ */ new Set();
-  #changedHeads = /* @__PURE__ */ new Map();
-  constructor(kvw, chunkHasher, assertValidHash) {
-    super(kvw, assertValidHash);
-    this.#chunkHasher = chunkHasher;
-  }
-  createChunk = (data, refs) => createChunk(data, refs, this.#chunkHasher);
-  get kvWrite() {
-    return this._tx;
-  }
-  async putChunk(c) {
-    const { hash: hash2, data, meta } = c;
-    this.assertValidHash(hash2);
-    const key = chunkDataKey(hash2);
-    const p1 = this._tx.put(key, data);
-    let p2;
-    if (meta.length > 0) {
-      for (const h of meta) {
-        this.assertValidHash(h);
-      }
-      p2 = this._tx.put(chunkMetaKey(hash2), meta);
-    }
-    this.#putChunks.add(hash2);
-    await p1;
-    await p2;
-  }
-  setHead(name, hash2) {
-    return this.#setHead(name, hash2);
-  }
-  removeHead(name) {
-    return this.#setHead(name, void 0);
-  }
-  async #setHead(name, hash2) {
-    const oldHash = await this.getHead(name);
-    const hk = headKey(name);
-    let p1;
-    if (hash2 === void 0) {
-      p1 = this._tx.del(hk);
-    } else {
-      p1 = this._tx.put(hk, hash2);
-    }
-    const v2 = this.#changedHeads.get(name);
-    if (v2 === void 0) {
-      this.#changedHeads.set(name, { new: hash2, old: oldHash });
-    } else {
-      v2.new = hash2;
-    }
-    await p1;
-  }
-  async commit() {
-    const refCountUpdates = await computeRefCountUpdates(
-      this.#changedHeads.values(),
-      this.#putChunks,
-      this
-    );
-    await this.#applyRefCountUpdates(refCountUpdates);
-    await this._tx.commit();
-  }
-  async getRefCount(hash2) {
-    const value = await this._tx.get(chunkRefCountKey(hash2));
-    if (value === void 0) {
-      return void 0;
-    }
-    assertNumber(value);
-    if (value < 0 || value > 65535 || value !== (value | 0)) {
-      throw new Error(
-        `Invalid ref count ${value}. We expect the value to be a Uint16`
-      );
-    }
-    return value;
-  }
-  async getRefs(hash2) {
-    const meta = await this._tx.get(chunkMetaKey(hash2));
-    if (meta === void 0) {
-      return [];
-    }
-    assertRefs(meta);
-    return meta;
-  }
-  async #applyRefCountUpdates(refCountCache) {
-    const ps = [];
-    for (const [hash2, count] of refCountCache) {
-      if (count === 0) {
-        ps.push(this.#removeAllRelatedKeys(hash2));
-      } else {
-        const refCountKey = chunkRefCountKey(hash2);
-        ps.push(this._tx.put(refCountKey, count));
-      }
-    }
-    await Promise.all(ps);
-  }
-  async #removeAllRelatedKeys(hash2) {
-    await Promise.all([
-      this._tx.del(chunkDataKey(hash2)),
-      this._tx.del(chunkMetaKey(hash2)),
-      this._tx.del(chunkRefCountKey(hash2))
-    ]);
-    this.#putChunks.delete(hash2);
-  }
-  release() {
-    this._tx.release();
-  }
-};
-
 // ../replicache/src/db/meta-type-enum.ts
 var LocalDD31 = 4;
 var SnapshotDD31 = 5;
@@ -2999,13 +3027,13 @@ var DataNodeImpl = class extends NodeImpl {
     }
   }
 };
-function readonlySplice(array10, start, deleteCount, ...items) {
-  const arr = array10.slice(0, start);
+function readonlySplice(array9, start, deleteCount, ...items) {
+  const arr = array9.slice(0, start);
   for (let i = 0; i < items.length; i++) {
     arr.push(items[i]);
   }
-  for (let i = start + deleteCount; i < array10.length; i++) {
-    arr.push(array10[i]);
+  for (let i = start + deleteCount; i < array9.length; i++) {
+    arr.push(array9[i]);
   }
   return arr;
 }
@@ -3804,6 +3832,21 @@ function toDbScanOptions(options) {
   };
 }
 
+// ../replicache/src/transaction-closed-error.ts
+var TransactionClosedError = class extends Error {
+  constructor() {
+    super("Transaction is closed");
+  }
+};
+function throwIfClosed(tx) {
+  if (tx.closed) {
+    throw new TransactionClosedError();
+  }
+}
+function rejectIfClosed(tx) {
+  return tx.closed ? Promise.reject(new TransactionClosedError()) : void 0;
+}
+
 // ../replicache/src/scan-iterator.ts
 var ScanResultImpl = class {
   #iter;
@@ -4689,17 +4732,6 @@ function isDefaultPusher(pusher) {
   return defaultPushers.has(pusher);
 }
 
-// ../replicache/src/log-options.ts
-import {
-  consoleLogSink,
-  LogContext,
-  TeeLogSink
-} from "@rocicorp/logger";
-function createLogContext(logLevel = "info", logSinks = [consoleLogSink], context) {
-  const logSink = logSinks.length === 1 ? logSinks[0] : new TeeLogSink(logSinks);
-  return new LogContext(logLevel, context, logSink);
-}
-
 // ../replicache/src/index-defs.ts
 var indexDefinitionSchema = readonlyObject({
   prefix: valita_exports.string().optional(),
@@ -5492,47 +5524,13 @@ function initOnPersistChannel(replicacheName, signal, handlePersist) {
 // ../replicache/src/pending-mutations.ts
 async function pendingMutationsForAPI(dagRead) {
   const mainHeadHash = await mustGetHeadHash(DEFAULT_HEAD_NAME, dagRead);
-  const pending = await localMutationsDD31(mainHeadHash, dagRead);
-  return pending.map((p) => ({
-    id: p.meta.mutationID,
-    name: p.meta.mutatorName,
-    args: p.meta.mutatorArgsJSON,
-    clientID: p.meta.clientID
-  })).reverse();
-}
-
-// ../replicache/src/bg-interval.ts
-function initBgIntervalProcess(processName, process2, delayMs, lc, signal) {
-  void runBgIntervalProcess(processName, process2, delayMs, lc, signal);
-}
-async function runBgIntervalProcess(processName, process2, delayMs, lc, signal) {
-  if (signal.aborted) {
-    return;
-  }
-  lc = lc.withContext("bgIntervalProcess", processName);
-  lc.debug?.("Starting");
-  while (!signal.aborted) {
-    try {
-      await sleep(delayMs(), signal);
-    } catch (e) {
-      if (!(e instanceof AbortError)) {
-        throw e;
-      }
-    }
-    if (!signal.aborted) {
-      lc.debug?.("Running");
-      try {
-        await process2();
-      } catch (e) {
-        if (signal.aborted) {
-          lc.debug?.("Error running most likely due to close.", e);
-        } else {
-          lc.error?.("Error running.", e);
-        }
-      }
-    }
-  }
-  lc.debug?.("Stopping");
+  const pending = await localMutationsDD31(mainHeadHash, dagRead);
+  return pending.map((p) => ({
+    id: p.meta.mutationID,
+    name: p.meta.mutatorName,
+    args: p.meta.mutatorArgsJSON,
+    clientID: p.meta.clientID
+  })).reverse();
 }
 
 // ../replicache/src/persist/make-client-id.ts
@@ -5984,6 +5982,46 @@ function gcClientGroups(dagStore) {
   });
 }
 
+// ../replicache/src/persist/heartbeat.ts
+var HEARTBEAT_INTERVAL = 60 * 1e3;
+var latestHeartbeatUpdate;
+function startHeartbeats(clientID, dagStore, onClientStateNotFound, heartbeatIntervalMs, lc, signal) {
+  initBgIntervalProcess(
+    "Heartbeat",
+    async () => {
+      latestHeartbeatUpdate = writeHeartbeat(clientID, dagStore);
+      try {
+        return await latestHeartbeatUpdate;
+      } catch (e) {
+        if (e instanceof ClientStateNotFoundError) {
+          onClientStateNotFound();
+          return;
+        }
+        throw e;
+      }
+    },
+    () => heartbeatIntervalMs,
+    lc,
+    signal
+  );
+}
+function writeHeartbeat(clientID, dagStore) {
+  return withWrite(dagStore, async (dagWrite) => {
+    const clients = await getClients(dagWrite);
+    const client = clients.get(clientID);
+    if (!client) {
+      throw new ClientStateNotFoundError(clientID);
+    }
+    const newClient = {
+      ...client,
+      heartbeatTimestampMs: Date.now()
+    };
+    const newClients = new Map(clients).set(clientID, newClient);
+    await setClients(newClients, dagWrite);
+    return newClients;
+  });
+}
+
 // ../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;
@@ -6044,215 +6082,37 @@ var IDBDatabasesStore = class {
       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 SDD_IDB_MAX_AGE = 30 * 24 * 60 * 60 * 1e3;
-var DD31_IDB_MAX_AGE = 14 * 24 * 60 * 60 * 1e3;
-var INITIAL_COLLECT_IDB_DELAY = 5 * 60 * 1e3;
-function initCollectIDBDatabases(idbDatabasesStore, kvDropStore, collectInterval, initialCollectDelay, sddMaxAge, dd31MaxAge, lc, signal) {
-  let initial = true;
-  initBgIntervalProcess(
-    "CollectIDBDatabases",
-    async () => {
-      await collectIDBDatabases(
-        idbDatabasesStore,
-        Date.now(),
-        sddMaxAge,
-        dd31MaxAge,
-        kvDropStore
-      );
-    },
-    () => {
-      if (initial) {
-        initial = false;
-        return initialCollectDelay;
-      }
-      return collectInterval;
-    },
-    lc,
-    signal
-  );
-}
-async function collectIDBDatabases(idbDatabasesStore, now, sddMaxAge, dd31MaxAge, kvDropStore, newDagStore = defaultNewDagStore) {
-  const databases = await idbDatabasesStore.getDatabases();
-  const dbs = Object.values(databases);
-  const canCollectResults = await Promise.all(
-    dbs.map(
-      async (db) => [
-        db.name,
-        await canCollectDatabase(db, now, sddMaxAge, dd31MaxAge, newDagStore)
-      ]
-    )
-  );
-  const namesToRemove = canCollectResults.filter((result) => result[1]).map((result) => result[0]);
-  const { errors } = await dropDatabases(
-    idbDatabasesStore,
-    namesToRemove,
-    kvDropStore
-  );
-  if (errors.length) {
-    throw errors[0];
-  }
-}
-async function dropDatabaseInternal(name, idbDatabasesStore, kvDropStore) {
-  await kvDropStore(name);
-  await idbDatabasesStore.deleteDatabases([name]);
-}
-async function dropDatabases(idbDatabasesStore, namesToRemove, kvDropStore) {
-  const dropStoreResults = await Promise.allSettled(
-    namesToRemove.map(async (name) => {
-      await dropDatabaseInternal(name, idbDatabasesStore, kvDropStore);
-      return name;
-    })
-  );
-  const dropped = [];
-  const errors = [];
-  for (const result of dropStoreResults) {
-    if (result.status === "fulfilled") {
-      dropped.push(result.value);
-    } else {
-      errors.push(result.reason);
-    }
-  }
-  return { dropped, errors };
-}
-function defaultNewDagStore(name) {
-  const perKvStore = new IDBStore(name);
-  return new StoreImpl(perKvStore, newRandomHash, assertHash);
-}
-async function canCollectDatabase(db, now, sddMaxAge, dd31MaxAge, newDagStore) {
-  if (db.replicacheFormatVersion > Latest) {
-    return false;
-  }
-  if (db.lastOpenedTimestampMS !== void 0) {
-    const isDD31 = db.replicacheFormatVersion >= DD31;
-    if (now - db.lastOpenedTimestampMS < (isDD31 ? dd31MaxAge : sddMaxAge)) {
-      return false;
-    }
-    if (!isDD31) {
-      return true;
-    }
-    assert(
-      db.replicacheFormatVersion === DD31 || db.replicacheFormatVersion === V6 || db.replicacheFormatVersion === V7
-    );
-    return !await anyPendingMutationsInClientGroups(newDagStore(db.name));
-  }
-  const perdag = newDagStore(db.name);
-  const clientMap = await withRead(perdag, getClients);
-  await perdag.close();
-  return allClientsOlderThan(clientMap, now, sddMaxAge);
-}
-function allClientsOlderThan(clients, now, maxAge) {
-  for (const client of clients.values()) {
-    if (now - client.heartbeatTimestampMs < maxAge) {
-      return false;
-    }
-  }
-  return true;
-}
-async function dropDatabase(dbName, opts) {
-  const logContext = createLogContext(opts?.logLevel, opts?.logSinks, {
-    dropDatabase: void 0
-  });
-  const kvStoreProvider = getKVStoreProvider(logContext, opts?.kvStore);
-  await dropDatabaseInternal(
-    dbName,
-    new IDBDatabasesStore(kvStoreProvider.create),
-    kvStoreProvider.drop
-  );
-}
-async function dropAllDatabases(opts) {
-  const logContext = createLogContext(opts?.logLevel, opts?.logSinks, {
-    dropAllDatabases: void 0
-  });
-  const kvStoreProvider = getKVStoreProvider(logContext, opts?.kvStore);
-  const store = new IDBDatabasesStore(kvStoreProvider.create);
-  const databases = await store.getDatabases();
-  const dbNames = Object.values(databases).map((db) => db.name);
-  const result = await dropDatabases(store, dbNames, kvStoreProvider.drop);
-  return result;
-}
-async function anyPendingMutationsInClientGroups(perdag) {
-  const clientGroups = await withRead(perdag, getClientGroups);
-  for (const clientGroup of clientGroups.values()) {
-    if (clientGroupHasPendingMutations(clientGroup)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-// ../replicache/src/persist/heartbeat.ts
-var HEARTBEAT_INTERVAL = 60 * 1e3;
-var latestHeartbeatUpdate;
-function startHeartbeats(clientID, dagStore, onClientStateNotFound, heartbeatIntervalMs, lc, signal) {
-  initBgIntervalProcess(
-    "Heartbeat",
-    async () => {
-      latestHeartbeatUpdate = writeHeartbeat(clientID, dagStore);
-      try {
-        return await latestHeartbeatUpdate;
-      } catch (e) {
-        if (e instanceof ClientStateNotFoundError) {
-          onClientStateNotFound();
-          return;
-        }
-        throw e;
-      }
-    },
-    () => heartbeatIntervalMs,
-    lc,
-    signal
-  );
-}
-function writeHeartbeat(clientID, dagStore) {
-  return withWrite(dagStore, async (dagWrite) => {
-    const clients = await getClients(dagWrite);
-    const client = clients.get(clientID);
-    if (!client) {
-      throw new ClientStateNotFoundError(clientID);
-    }
-    const newClient = {
-      ...client,
-      heartbeatTimestampMs: Date.now()
-    };
-    const newClients = new Map(clients).set(clientID, newClient);
-    await setClients(newClients, dagWrite);
-    return newClients;
-  });
+      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/dag/visitor.ts
@@ -7130,14 +6990,14 @@ function diffBinarySearch(diff2, prefix, compareKey) {
 }
 
 // ../shared/src/random-values.ts
-function getNonCryptoRandomValues(array10) {
-  if (array10 === null) {
+function getNonCryptoRandomValues(array9) {
+  if (array9 === null) {
     throw new TypeError("array cannot be null");
   }
-  for (let i = 0; i < array10.length; i++) {
-    array10[i] = Math.floor(Math.random() * 256);
+  for (let i = 0; i < array9.length; i++) {
+    array9[i] = Math.floor(Math.random() * 256);
   }
-  return array10;
+  return array9;
 }
 
 // ../replicache/src/sync/request-id.ts
@@ -8307,8 +8167,143 @@ function getKVStoreProvider(lc, kvStore) {
   }
 }
 
-// ../replicache/src/mod.ts
-import { consoleLogSink as consoleLogSink3 } from "@rocicorp/logger";
+// ../replicache/src/persist/collect-idb-databases.ts
+var COLLECT_IDB_INTERVAL = 12 * 60 * 60 * 1e3;
+var SDD_IDB_MAX_AGE = 30 * 24 * 60 * 60 * 1e3;
+var DD31_IDB_MAX_AGE = 14 * 24 * 60 * 60 * 1e3;
+var INITIAL_COLLECT_IDB_DELAY = 5 * 60 * 1e3;
+function initCollectIDBDatabases(idbDatabasesStore, kvDropStore, collectInterval, initialCollectDelay, sddMaxAge, dd31MaxAge, lc, signal) {
+  let initial = true;
+  initBgIntervalProcess(
+    "CollectIDBDatabases",
+    async () => {
+      await collectIDBDatabases(
+        idbDatabasesStore,
+        Date.now(),
+        sddMaxAge,
+        dd31MaxAge,
+        kvDropStore
+      );
+    },
+    () => {
+      if (initial) {
+        initial = false;
+        return initialCollectDelay;
+      }
+      return collectInterval;
+    },
+    lc,
+    signal
+  );
+}
+async function collectIDBDatabases(idbDatabasesStore, now, sddMaxAge, dd31MaxAge, kvDropStore, newDagStore = defaultNewDagStore) {
+  const databases = await idbDatabasesStore.getDatabases();
+  const dbs = Object.values(databases);
+  const canCollectResults = await Promise.all(
+    dbs.map(
+      async (db) => [
+        db.name,
+        await canCollectDatabase(db, now, sddMaxAge, dd31MaxAge, newDagStore)
+      ]
+    )
+  );
+  const namesToRemove = canCollectResults.filter((result) => result[1]).map((result) => result[0]);
+  const { errors } = await dropDatabases(
+    idbDatabasesStore,
+    namesToRemove,
+    kvDropStore
+  );
+  if (errors.length) {
+    throw errors[0];
+  }
+}
+async function dropDatabaseInternal(name, idbDatabasesStore, kvDropStore) {
+  await kvDropStore(name);
+  await idbDatabasesStore.deleteDatabases([name]);
+}
+async function dropDatabases(idbDatabasesStore, namesToRemove, kvDropStore) {
+  const dropStoreResults = await Promise.allSettled(
+    namesToRemove.map(async (name) => {
+      await dropDatabaseInternal(name, idbDatabasesStore, kvDropStore);
+      return name;
+    })
+  );
+  const dropped = [];
+  const errors = [];
+  for (const result of dropStoreResults) {
+    if (result.status === "fulfilled") {
+      dropped.push(result.value);
+    } else {
+      errors.push(result.reason);
+    }
+  }
+  return { dropped, errors };
+}
+function defaultNewDagStore(name) {
+  const perKvStore = new IDBStore(name);
+  return new StoreImpl(perKvStore, newRandomHash, assertHash);
+}
+async function canCollectDatabase(db, now, sddMaxAge, dd31MaxAge, newDagStore) {
+  if (db.replicacheFormatVersion > Latest) {
+    return false;
+  }
+  if (db.lastOpenedTimestampMS !== void 0) {
+    const isDD31 = db.replicacheFormatVersion >= DD31;
+    if (now - db.lastOpenedTimestampMS < (isDD31 ? dd31MaxAge : sddMaxAge)) {
+      return false;
+    }
+    if (!isDD31) {
+      return true;
+    }
+    assert(
+      db.replicacheFormatVersion === DD31 || db.replicacheFormatVersion === V6 || db.replicacheFormatVersion === V7
+    );
+    return !await anyPendingMutationsInClientGroups(newDagStore(db.name));
+  }
+  const perdag = newDagStore(db.name);
+  const clientMap = await withRead(perdag, getClients);
+  await perdag.close();
+  return allClientsOlderThan(clientMap, now, sddMaxAge);
+}
+function allClientsOlderThan(clients, now, maxAge) {
+  for (const client of clients.values()) {
+    if (now - client.heartbeatTimestampMs < maxAge) {
+      return false;
+    }
+  }
+  return true;
+}
+async function dropDatabase(dbName, opts) {
+  const logContext = createLogContext(opts?.logLevel, opts?.logSinks, {
+    dropDatabase: void 0
+  });
+  const kvStoreProvider = getKVStoreProvider(logContext, opts?.kvStore);
+  await dropDatabaseInternal(
+    dbName,
+    new IDBDatabasesStore(kvStoreProvider.create),
+    kvStoreProvider.drop
+  );
+}
+async function dropAllDatabases(opts) {
+  const logContext = createLogContext(opts?.logLevel, opts?.logSinks, {
+    dropAllDatabases: void 0
+  });
+  const kvStoreProvider = getKVStoreProvider(logContext, opts?.kvStore);
+  const store = new IDBDatabasesStore(kvStoreProvider.create);
+  const databases = await store.getDatabases();
+  const dbNames = Object.values(databases).map((db) => db.name);
+  const result = await dropDatabases(store, dbNames, kvStoreProvider.drop);
+  return result;
+}
+async function anyPendingMutationsInClientGroups(perdag) {
+  const clientGroups = await withRead(perdag, getClientGroups);
+  for (const clientGroup of clientGroups.values()) {
+    if (clientGroupHasPendingMutations(clientGroup)) {
+      return true;
+    }
+  }
+  return false;
+}
 
 // ../zero-schema/src/builder/relationship-builder.ts
 function relationships(table2, cb) {
@@ -8898,8 +8893,8 @@ var negateOperatorMap = {
 function negateOperator(op) {
   return must(negateOperatorMap[op]);
 }
-function filterUndefined(array10) {
-  return array10.filter((e) => e !== void 0);
+function filterUndefined(array9) {
+  return array9.filter((e) => e !== void 0);
 }
 function filterTrue(conditions) {
   return conditions.filter((c) => !isAlwaysTrue(c));
@@ -11428,25 +11423,6 @@ function escapeLike(val) {
 import { LogContext as LogContext4 } from "@rocicorp/logger";
 import { resolver as resolver8 } from "@rocicorp/resolver";
 
-// ../zero-protocol/src/error-kind-enum.ts
-var AuthInvalidated = "AuthInvalidated";
-var ClientNotFound = "ClientNotFound";
-var InvalidConnectionRequest = "InvalidConnectionRequest";
-var InvalidConnectionRequestBaseCookie = "InvalidConnectionRequestBaseCookie";
-var InvalidConnectionRequestLastMutationID = "InvalidConnectionRequestLastMutationID";
-var InvalidConnectionRequestClientDeleted = "InvalidConnectionRequestClientDeleted";
-var InvalidMessage = "InvalidMessage";
-var InvalidPush = "InvalidPush";
-var MutationFailed = "MutationFailed";
-var MutationRateLimited = "MutationRateLimited";
-var Rebalance = "Rebalance";
-var Rehome = "Rehome";
-var Unauthorized = "Unauthorized";
-var VersionNotSupported = "VersionNotSupported";
-var SchemaVersionNotSupported = "SchemaVersionNotSupported";
-var ServerOverloaded = "ServerOverloaded";
-var Internal = "Internal";
-
 // ../zero-protocol/src/queries-patch.ts
 var putOpSchema = valita_exports.object({
   op: valita_exports.literal("put"),
@@ -11463,30 +11439,6 @@ var clearOpSchema = valita_exports.object({
 var patchOpSchema = valita_exports.union(putOpSchema, delOpSchema, clearOpSchema);
 var queriesPatchSchema = valita_exports.array(patchOpSchema);
 
-// ../zero-protocol/src/change-desired-queries.ts
-var changeDesiredQueriesBodySchema = valita_exports.object({
-  desiredQueriesPatch: queriesPatchSchema
-});
-var changeDesiredQueriesMessageSchema = valita_exports.tuple([
-  valita_exports.literal("changeDesiredQueries"),
-  changeDesiredQueriesBodySchema
-]);
-
-// ../zero-protocol/src/clients-patch.ts
-var putOpSchema2 = valita_exports.object({
-  op: valita_exports.literal("put"),
-  clientID: valita_exports.string()
-});
-var delOpSchema2 = valita_exports.object({
-  op: valita_exports.literal("del"),
-  clientID: valita_exports.string()
-});
-var clearOpSchema2 = valita_exports.object({
-  op: valita_exports.literal("clear")
-});
-var patchOpSchema2 = valita_exports.union(putOpSchema2, delOpSchema2, clearOpSchema2);
-var clientsPatchSchema = valita_exports.array(patchOpSchema2);
-
 // ../zero-protocol/src/connect.ts
 var connectedBodySchema = valita_exports.object({
   wsid: valita_exports.string(),
@@ -11511,6 +11463,25 @@ function encodeSecProtocols(initConnectionMessage, authToken) {
   return encodeURIComponent(btoa(JSON.stringify(protocols)));
 }
 
+// ../zero-protocol/src/error-kind-enum.ts
+var AuthInvalidated = "AuthInvalidated";
+var ClientNotFound = "ClientNotFound";
+var InvalidConnectionRequest = "InvalidConnectionRequest";
+var InvalidConnectionRequestBaseCookie = "InvalidConnectionRequestBaseCookie";
+var InvalidConnectionRequestLastMutationID = "InvalidConnectionRequestLastMutationID";
+var InvalidConnectionRequestClientDeleted = "InvalidConnectionRequestClientDeleted";
+var InvalidMessage = "InvalidMessage";
+var InvalidPush = "InvalidPush";
+var MutationFailed = "MutationFailed";
+var MutationRateLimited = "MutationRateLimited";
+var Rebalance = "Rebalance";
+var Rehome = "Rehome";
+var Unauthorized = "Unauthorized";
+var VersionNotSupported = "VersionNotSupported";
+var SchemaVersionNotSupported = "SchemaVersionNotSupported";
+var ServerOverloaded = "ServerOverloaded";
+var Internal = "Internal";
+
 // ../zero-protocol/src/error.ts
 var basicErrorKindSchema = valita_exports.union(
   valita_exports.literal(AuthInvalidated),
@@ -11557,6 +11528,21 @@ var errorMessageSchema = valita_exports.tuple([
   errorBodySchema
 ]);
 
+// ../zero-protocol/src/clients-patch.ts
+var putOpSchema2 = valita_exports.object({
+  op: valita_exports.literal("put"),
+  clientID: valita_exports.string()
+});
+var delOpSchema2 = valita_exports.object({
+  op: valita_exports.literal("del"),
+  clientID: valita_exports.string()
+});
+var clearOpSchema2 = valita_exports.object({
+  op: valita_exports.literal("clear")
+});
+var patchOpSchema2 = valita_exports.union(putOpSchema2, delOpSchema2, clearOpSchema2);
+var clientsPatchSchema = valita_exports.array(patchOpSchema2);
+
 // ../zero-protocol/src/primary-key.ts
 var primaryKeySchema = readonly(
   valita_exports.tuple([valita_exports.string()]).concat(valita_exports.array(valita_exports.string()))
@@ -11700,14 +11686,15 @@ var downstreamSchema = valita_exports.union(
   pullResponseMessageSchema
 );
 
-// ../zero-protocol/src/ping.ts
-var pingBodySchema = valita_exports.object({});
-var pingMessageSchema = valita_exports.tuple([valita_exports.literal("ping"), pingBodySchema]);
-
 // ../zero-protocol/src/mutation-type-enum.ts
 var CRUD = "crud";
 var Custom = "custom";
 
+// ../zero-protocol/src/protocol-version.ts
+var PROTOCOL_VERSION = 4;
+var MIN_SERVER_SUPPORTED_PROTOCOL_VERSION = 2;
+assert(MIN_SERVER_SUPPORTED_PROTOCOL_VERSION < PROTOCOL_VERSION);
+
 // ../zero-protocol/src/push.ts
 var CRUD_MUTATION_NAME = "_zero_crud";
 var insertOpSchema = valita_exports.object({
@@ -11773,30 +11760,6 @@ var pushBodySchema = valita_exports.object({
 });
 var pushMessageSchema = valita_exports.tuple([valita_exports.literal("push"), pushBodySchema]);
 
-// ../zero-protocol/src/delete-clients.ts
-var deleteClientsBodySchema = valita_exports.object({
-  clientIDs: valita_exports.array(valita_exports.string())
-});
-var deleteClientsMessageSchema = valita_exports.tuple([
-  valita_exports.literal("deleteClients"),
-  deleteClientsBodySchema
-]);
-
-// ../zero-protocol/src/up.ts
-var upstreamSchema = valita_exports.union(
-  initConnectionMessageSchema,
-  pingMessageSchema,
-  deleteClientsMessageSchema,
-  changeDesiredQueriesMessageSchema,
-  pullRequestMessageSchema,
-  pushMessageSchema
-);
-
-// ../zero-protocol/src/protocol-version.ts
-var PROTOCOL_VERSION = 4;
-var MIN_SERVER_SUPPORTED_PROTOCOL_VERSION = 2;
-assert(MIN_SERVER_SUPPORTED_PROTOCOL_VERSION < PROTOCOL_VERSION);
-
 // ../zero-client/src/util/nanoid.ts
 function nanoid(size = 21) {
   const randomBytes = getNonCryptoRandomValues(new Uint8Array(size));
@@ -13150,7 +13113,7 @@ function appendPath(url, toAppend) {
 // ../zero-client/src/client/log-options.ts
 import {
   TeeLogSink as TeeLogSink2,
-  consoleLogSink as consoleLogSink4
+  consoleLogSink as consoleLogSink3
 } from "@rocicorp/logger";
 
 // ../datadog/src/datadog-log-sink.ts
@@ -13372,7 +13335,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.12.2025013000";
+var version2 = "0.12.2025013100";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -13392,7 +13355,7 @@ var LevelFilterLogSink = class {
     this.#wrappedLogSink.log(level, context, ...args);
   }
   async flush() {
-    await consoleLogSink4.flush?.();
+    await consoleLogSink3.flush?.();
   }
 };
 var DATADOG_LOG_LEVEL = "info";
@@ -13402,7 +13365,7 @@ function createLogOptions(options, createDatadogLogSink = (options2) => new Data
   if (!enableAnalytics || server === null) {
     return {
       logLevel: consoleLogLevel,
-      logSink: consoleLogSink4
+      logSink: consoleLogSink3
     };
   }
   const serverURL = new URL(server);
@@ -13411,7 +13374,7 @@ function createLogOptions(options, createDatadogLogSink = (options2) => new Data
   const baseURL = new URL(appendPath(server, "/logs/v0/log"));
   const logLevel = consoleLogLevel === "debug" ? "debug" : "info";
   const logSink = new TeeLogSink2([
-    new LevelFilterLogSink(consoleLogSink4, consoleLogLevel),
+    new LevelFilterLogSink(consoleLogSink3, consoleLogLevel),
     new LevelFilterLogSink(
       createDatadogLogSink({
         service: datadogServiceLabel,
@@ -14973,23 +14936,23 @@ var Zero = class {
     this.#lastMutationIDSent = NULL_LAST_MUTATION_ID_SENT;
     this.#pokeHandler.handleDisconnect();
   }
-  async #handlePokeStart(_lc, pokeMessage) {
+  #handlePokeStart(_lc, pokeMessage) {
     resetBackoff();
     this.#abortPingTimeout();
-    await this.#pokeHandler.handlePokeStart(pokeMessage[1]);
+    this.#pokeHandler.handlePokeStart(pokeMessage[1]);
   }
-  async #handlePokePart(_lc, pokeMessage) {
+  #handlePokePart(_lc, pokeMessage) {
     this.#abortPingTimeout();
-    const lastMutationIDChangeForSelf = await this.#pokeHandler.handlePokePart(
+    const lastMutationIDChangeForSelf = this.#pokeHandler.handlePokePart(
       pokeMessage[1]
     );
     if (lastMutationIDChangeForSelf !== void 0) {
       this.#lastMutationIDReceived = lastMutationIDChangeForSelf;
     }
   }
-  async #handlePokeEnd(_lc, pokeMessage) {
+  #handlePokeEnd(_lc, pokeMessage) {
     this.#abortPingTimeout();
-    await this.#pokeHandler.handlePokeEnd(pokeMessage[1]);
+    this.#pokeHandler.handlePokeEnd(pokeMessage[1]);
   }
   #onPokeError() {
     const lc = this.#lc;
@@ -15439,4 +15402,4 @@ export {
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-UEPZPKPV.js.map
+//# sourceMappingURL=chunk-XBQPXRPX.js.map