@rocicorp/zero 0.9.2024121900 → 0.9.2024122300

package/out/{chunk-3L5FRWGX.js → chunk-NYJROCBH.js}

@@ -1443,13 +1443,13 @@ var Chunk = class {
    * chunk.
    */
   meta;
-  constructor(hash, data, refs) {
+  constructor(hash2, data, refs) {
     assert(
-      !refs.includes(hash),
+      !refs.includes(hash2),
       "Chunk cannot reference itself"
     );
     assertDeepFrozen(data);
-    this.hash = hash;
+    this.hash = hash2;
     this.data = data;
     this.meta = refs;
   }
@@ -1466,8 +1466,8 @@ function assertRefs(v2) {
   }
 }
 function createChunk(data, refs, chunkHasher) {
-  const hash = chunkHasher();
-  return new Chunk(hash, data, refs);
+  const hash2 = chunkHasher();
+  return new Chunk(hash2, data, refs);
 }
 function throwChunkHasher() {
   throw new Error("unexpected call to compute chunk hash");
@@ -1755,7 +1755,7 @@ var RefCountUpdates = class {
     await Promise.all(
       Array.from(
         this.#putChunks.values(),
-        (hash) => this.#ensureRefCountLoaded(hash)
+        (hash2) => this.#ensureRefCountLoaded(hash2)
       )
     );
     if (this.#isLazyDelegate) {
@@ -1764,9 +1764,9 @@ var RefCountUpdates = class {
       let refCountsUpdated;
       do {
         refCountsUpdated = false;
-        for (const hash of this.#putChunks.values()) {
-          if (!this.#delegate.areRefsCounted(hash) && !this.#refsCounted.has(hash) && this.#refCountUpdates.get(hash) !== 0) {
-            await this.#updateRefsCounts(hash, 1);
+        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;
           }
@@ -1777,54 +1777,54 @@ var RefCountUpdates = class {
       await this.#changeRefCount(o, -1);
     }
     if (!isProd) {
-      for (const [hash, update] of this.#refCountUpdates) {
+      for (const [hash2, update] of this.#refCountUpdates) {
         assert(
           update >= 0,
-          `ref count update must be non-negative. ${hash}:${update}`
+          `ref count update must be non-negative. ${hash2}:${update}`
         );
       }
     }
     return this.#refCountUpdates;
   }
-  async #changeRefCount(hash, delta) {
-    await this.#ensureRefCountLoaded(hash);
-    if (this.#updateRefCount(hash, delta)) {
-      await this.#updateRefsCounts(hash, delta);
+  async #changeRefCount(hash2, delta) {
+    await this.#ensureRefCountLoaded(hash2);
+    if (this.#updateRefCount(hash2, delta)) {
+      await this.#updateRefsCounts(hash2, delta);
     }
   }
-  async #updateRefsCounts(hash, delta) {
-    if (hash === emptyHash) {
+  async #updateRefsCounts(hash2, delta) {
+    if (hash2 === emptyHash) {
       return;
     }
-    const refs = await this.#delegate.getRefs(hash);
+    const refs = await this.#delegate.getRefs(hash2);
     if (!isProd) {
       assert(
-        refs || this.#isLazyDelegate && !this.#putChunks.has(hash),
+        refs || this.#isLazyDelegate && !this.#putChunks.has(hash2),
         "refs must be defined"
       );
     }
     if (refs !== void 0) {
-      this.#refsCounted?.add(hash);
+      this.#refsCounted?.add(hash2);
       const ps = refs.map((ref) => this.#changeRefCount(ref, delta));
       await Promise.all(ps);
     }
   }
-  #ensureRefCountLoaded(hash) {
-    let p = this.#loadedRefCountPromises.get(hash);
+  #ensureRefCountLoaded(hash2) {
+    let p = this.#loadedRefCountPromises.get(hash2);
     if (p === void 0) {
       p = (async () => {
-        const value = await this.#delegate.getRefCount(hash) || 0;
-        this.#refCountUpdates.set(hash, value);
+        const value = await this.#delegate.getRefCount(hash2) || 0;
+        this.#refCountUpdates.set(hash2, value);
         return value;
       })();
-      this.#loadedRefCountPromises.set(hash, p);
+      this.#loadedRefCountPromises.set(hash2, p);
     }
     return p;
   }
-  #updateRefCount(hash, delta) {
-    const oldCount = this.#refCountUpdates.get(hash);
+  #updateRefCount(hash2, delta) {
+    const oldCount = this.#refCountUpdates.get(hash2);
     assertNumber(oldCount);
-    this.#refCountUpdates.set(hash, oldCount + delta);
+    this.#refCountUpdates.set(hash2, oldCount + delta);
     return oldCount === 0 && delta === 1 || oldCount === 1 && delta === -1;
   }
 };
@@ -1833,22 +1833,22 @@ var RefCountUpdates = class {
 var ChunkNotFoundError = class extends Error {
   name = "ChunkNotFoundError";
   hash;
-  constructor(hash) {
-    super(`Chunk not found ${hash}`);
-    this.hash = hash;
+  constructor(hash2) {
+    super(`Chunk not found ${hash2}`);
+    this.hash = hash2;
   }
 };
-async function mustGetChunk(store, hash) {
-  const chunk = await store.getChunk(hash);
+async function mustGetChunk(store, hash2) {
+  const chunk = await store.getChunk(hash2);
   if (chunk) {
     return chunk;
   }
-  throw new ChunkNotFoundError(hash);
+  throw new ChunkNotFoundError(hash2);
 }
 async function mustGetHeadHash(name, store) {
-  const hash = await store.getHead(name);
-  assert(hash, `Missing head ${name}`);
-  return hash;
+  const hash2 = await store.getHead(name);
+  assert(hash2, `Missing head ${name}`);
+  return hash2;
 }
 
 // ../replicache/src/dag/lazy-store.ts
@@ -2002,28 +2002,28 @@ var LazyRead = class {
     this.#release = release;
     this.assertValidHash = assertValidHash;
   }
-  isMemOnlyChunkHash(hash) {
-    return this._memOnlyChunks.has(hash);
+  isMemOnlyChunkHash(hash2) {
+    return this._memOnlyChunks.has(hash2);
   }
-  async hasChunk(hash) {
-    return await this.getChunk(hash) !== void 0;
+  async hasChunk(hash2) {
+    return await this.getChunk(hash2) !== void 0;
   }
-  async getChunk(hash) {
-    const memOnlyChunk = this._memOnlyChunks.get(hash);
+  async getChunk(hash2) {
+    const memOnlyChunk = this._memOnlyChunks.get(hash2);
     if (memOnlyChunk !== void 0) {
       return memOnlyChunk;
     }
-    let chunk = this._sourceChunksCache.get(hash);
+    let chunk = this._sourceChunksCache.get(hash2);
     if (chunk === void 0) {
-      chunk = await (await this._getSourceRead()).getChunk(hash);
+      chunk = await (await this._getSourceRead()).getChunk(hash2);
       if (chunk !== void 0) {
         this._sourceChunksCache.put(chunk);
       }
     }
     return chunk;
   }
-  mustGetChunk(hash) {
-    return mustGetChunk(this, hash);
+  mustGetChunk(hash2) {
+    return mustGetChunk(this, hash2);
   }
   getHead(name) {
     return Promise.resolve(this._heads.get(name));
@@ -2073,54 +2073,54 @@ var LazyWrite = class extends LazyRead {
     return chunk;
   };
   putChunk(c, size) {
-    const { hash, meta } = c;
-    this.assertValidHash(hash);
+    const { hash: hash2, meta } = c;
+    this.assertValidHash(hash2);
     if (meta.length > 0) {
       for (const h of meta) {
         this.assertValidHash(h);
       }
     }
-    if (this.#createdChunks.has(hash) || this.isMemOnlyChunkHash(hash)) {
-      this._pendingMemOnlyChunks.set(hash, c);
+    if (this.#createdChunks.has(hash2) || this.isMemOnlyChunkHash(hash2)) {
+      this._pendingMemOnlyChunks.set(hash2, c);
     } else {
-      this._pendingCachedChunks.set(hash, { chunk: c, size: size ?? -1 });
+      this._pendingCachedChunks.set(hash2, { chunk: c, size: size ?? -1 });
     }
     return promiseVoid;
   }
-  async setHead(name, hash) {
-    await this.#setHead(name, hash);
+  async setHead(name, hash2) {
+    await this.#setHead(name, hash2);
   }
   async removeHead(name) {
     await this.#setHead(name, void 0);
   }
-  async #setHead(name, hash) {
+  async #setHead(name, hash2) {
     const oldHash = await this.getHead(name);
     const v2 = this._pendingHeadChanges.get(name);
     if (v2 === void 0) {
-      this._pendingHeadChanges.set(name, { new: hash, old: oldHash });
+      this._pendingHeadChanges.set(name, { new: hash2, old: oldHash });
     } else {
-      v2.new = hash;
+      v2.new = hash2;
     }
   }
-  isMemOnlyChunkHash(hash) {
-    return this._pendingMemOnlyChunks.has(hash) || super.isMemOnlyChunkHash(hash);
+  isMemOnlyChunkHash(hash2) {
+    return this._pendingMemOnlyChunks.has(hash2) || super.isMemOnlyChunkHash(hash2);
   }
-  async getChunk(hash) {
-    const pendingMemOnlyChunk = this._pendingMemOnlyChunks.get(hash);
+  async getChunk(hash2) {
+    const pendingMemOnlyChunk = this._pendingMemOnlyChunks.get(hash2);
     if (pendingMemOnlyChunk !== void 0) {
       return pendingMemOnlyChunk;
     }
-    const memOnlyChunk = this._memOnlyChunks.get(hash);
+    const memOnlyChunk = this._memOnlyChunks.get(hash2);
     if (memOnlyChunk !== void 0) {
       return memOnlyChunk;
     }
-    const pendingCachedChunk = this._pendingCachedChunks.get(hash);
+    const pendingCachedChunk = this._pendingCachedChunks.get(hash2);
     if (pendingCachedChunk !== void 0) {
       return pendingCachedChunk.chunk;
     }
-    let chunk = this._sourceChunksCache.get(hash);
+    let chunk = this._sourceChunksCache.get(hash2);
     if (chunk === void 0) {
-      chunk = await (await this._getSourceRead()).getChunk(hash);
+      chunk = await (await this._getSourceRead()).getChunk(hash2);
       if (chunk !== void 0) {
         this._pendingCachedChunks.set(chunk.hash, { chunk, size: -1 });
       }
@@ -2146,21 +2146,21 @@ var LazyWrite = class extends LazyRead {
       pendingChunks,
       this
     );
-    for (const [hash, count] of refCountUpdates) {
-      if (this.isMemOnlyChunkHash(hash)) {
+    for (const [hash2, count] of refCountUpdates) {
+      if (this.isMemOnlyChunkHash(hash2)) {
         if (count === 0) {
-          this.#refCounts.delete(hash);
-          this._memOnlyChunks.delete(hash);
-          this.#refs.delete(hash);
+          this.#refCounts.delete(hash2);
+          this._memOnlyChunks.delete(hash2);
+          this.#refs.delete(hash2);
         } else {
-          this.#refCounts.set(hash, count);
-          const chunk = this._pendingMemOnlyChunks.get(hash);
+          this.#refCounts.set(hash2, count);
+          const chunk = this._pendingMemOnlyChunks.get(hash2);
           if (chunk) {
-            this.#refs.set(hash, chunk.meta);
-            this._memOnlyChunks.set(hash, chunk);
+            this.#refs.set(hash2, chunk.meta);
+            this._memOnlyChunks.set(hash2, chunk);
           }
         }
-        refCountUpdates.delete(hash);
+        refCountUpdates.delete(hash2);
       }
     }
     this._sourceChunksCache.updateForCommit(
@@ -2179,26 +2179,26 @@ var LazyWrite = class extends LazyRead {
     this._pendingHeadChanges.clear();
     this.release();
   }
-  getRefCount(hash) {
-    return this.#refCounts.get(hash);
+  getRefCount(hash2) {
+    return this.#refCounts.get(hash2);
   }
-  getRefs(hash) {
-    const pendingMemOnlyChunk = this._pendingMemOnlyChunks.get(hash);
+  getRefs(hash2) {
+    const pendingMemOnlyChunk = this._pendingMemOnlyChunks.get(hash2);
     if (pendingMemOnlyChunk) {
       return pendingMemOnlyChunk.meta;
     }
-    const memOnlyChunk = this._memOnlyChunks.get(hash);
+    const memOnlyChunk = this._memOnlyChunks.get(hash2);
     if (memOnlyChunk) {
       return memOnlyChunk.meta;
     }
-    const pendingCachedChunk = this._pendingCachedChunks.get(hash);
+    const pendingCachedChunk = this._pendingCachedChunks.get(hash2);
     if (pendingCachedChunk !== void 0) {
       return pendingCachedChunk.chunk.meta;
     }
-    return this.#refs.get(hash);
+    return this.#refs.get(hash2);
   }
-  areRefsCounted(hash) {
-    return this.#refs.has(hash);
+  areRefsCounted(hash2) {
+    return this.#refs.has(hash2);
   }
   chunksPersisted(chunkHashes) {
     const chunksToCache = [];
@@ -2232,37 +2232,37 @@ var ChunksCache = class {
     this.#refCounts = refCounts;
     this.#refs = refs;
   }
-  get(hash) {
-    const cacheEntry = this.cacheEntries.get(hash);
+  get(hash2) {
+    const cacheEntry = this.cacheEntries.get(hash2);
     if (cacheEntry) {
-      this.cacheEntries.delete(hash);
-      this.cacheEntries.set(hash, cacheEntry);
+      this.cacheEntries.delete(hash2);
+      this.cacheEntries.set(hash2, cacheEntry);
     }
     return cacheEntry?.chunk;
   }
-  getWithoutUpdatingLRU(hash) {
-    return this.cacheEntries.get(hash)?.chunk;
+  getWithoutUpdatingLRU(hash2) {
+    return this.cacheEntries.get(hash2)?.chunk;
   }
   put(chunk) {
-    const { hash } = chunk;
-    const oldCacheEntry = this.cacheEntries.get(hash);
+    const { hash: hash2 } = chunk;
+    const oldCacheEntry = this.cacheEntries.get(hash2);
     if (oldCacheEntry) {
-      this.cacheEntries.delete(hash);
-      this.cacheEntries.set(hash, oldCacheEntry);
+      this.cacheEntries.delete(hash2);
+      this.cacheEntries.set(hash2, oldCacheEntry);
       return;
     }
-    const refCount = this.#refCounts.get(hash);
+    const refCount = this.#refCounts.get(hash2);
     if (refCount === void 0 || refCount < 1) {
       return;
     }
     if (!this.#cacheChunk(chunk)) {
       return;
     }
-    if (!this.#refs.has(hash)) {
+    if (!this.#refs.has(hash2)) {
       for (const refHash of chunk.meta) {
         this.#refCounts.set(refHash, (this.#refCounts.get(refHash) || 0) + 1);
       }
-      this.#refs.set(hash, chunk.meta);
+      this.#refs.set(hash2, chunk.meta);
     }
     this.#ensureCacheSizeLimit();
   }
@@ -2287,40 +2287,40 @@ var ChunksCache = class {
     return true;
   }
   #evict(cacheEntry) {
-    const { hash } = cacheEntry.chunk;
+    const { hash: hash2 } = cacheEntry.chunk;
     this.#size -= cacheEntry.size;
-    this.cacheEntries.delete(hash);
+    this.cacheEntries.delete(hash2);
   }
-  #deleteEntryByHash(hash) {
-    this.#refCounts.delete(hash);
-    this.#refs.delete(hash);
-    const cacheEntry = this.cacheEntries.get(hash);
+  #deleteEntryByHash(hash2) {
+    this.#refCounts.delete(hash2);
+    this.#refs.delete(hash2);
+    const cacheEntry = this.cacheEntries.get(hash2);
     if (cacheEntry) {
       this.#size -= cacheEntry.size;
-      this.cacheEntries.delete(hash);
+      this.cacheEntries.delete(hash2);
     }
   }
   updateForCommit(chunksToPut, refCountUpdates) {
-    for (const [hash, count] of refCountUpdates) {
+    for (const [hash2, count] of refCountUpdates) {
       if (count === 0) {
         if (!this.#evictsAndDeletesSuspended) {
-          this.#deleteEntryByHash(hash);
+          this.#deleteEntryByHash(hash2);
         } else {
-          this.#refCounts.set(hash, 0);
-          this.#suspendedDeletes.push(hash);
+          this.#refCounts.set(hash2, 0);
+          this.#suspendedDeletes.push(hash2);
         }
       } else {
-        this.#refCounts.set(hash, count);
-        const chunkAndSize = chunksToPut.get(hash);
+        this.#refCounts.set(hash2, count);
+        const chunkAndSize = chunksToPut.get(hash2);
         if (chunkAndSize) {
           const { chunk, size } = chunkAndSize;
-          const oldCacheEntry = this.cacheEntries.get(hash);
+          const oldCacheEntry = this.cacheEntries.get(hash2);
           if (oldCacheEntry) {
-            this.cacheEntries.delete(hash);
-            this.cacheEntries.set(hash, oldCacheEntry);
+            this.cacheEntries.delete(hash2);
+            this.cacheEntries.set(hash2, oldCacheEntry);
           } else {
             this.#cacheChunk(chunk, size !== -1 ? size : void 0);
-            this.#refs.set(hash, chunk.meta);
+            this.#refs.set(hash2, chunk.meta);
           }
         }
       }
@@ -2339,9 +2339,9 @@ var ChunksCache = class {
       return await fn();
     } finally {
       this.#evictsAndDeletesSuspended = false;
-      for (const hash of this.#suspendedDeletes) {
-        if (this.#refCounts.get(hash) === 0) {
-          this.#deleteEntryByHash(hash);
+      for (const hash2 of this.#suspendedDeletes) {
+        if (this.#refCounts.get(hash2) === 0) {
+          this.#deleteEntryByHash(hash2);
         }
       }
       this.#ensureCacheSizeLimit();
@@ -2350,14 +2350,14 @@ var ChunksCache = class {
 };
 
 // ../replicache/src/dag/key.ts
-function chunkDataKey(hash) {
-  return `c/${hash}/d`;
+function chunkDataKey(hash2) {
+  return `c/${hash2}/d`;
 }
-function chunkMetaKey(hash) {
-  return `c/${hash}/m`;
+function chunkMetaKey(hash2) {
+  return `c/${hash2}/m`;
 }
-function chunkRefCountKey(hash) {
-  return `c/${hash}/r`;
+function chunkRefCountKey(hash2) {
+  return `c/${hash2}/r`;
 }
 function headKey(name) {
   return `h/${name}`;
@@ -2394,15 +2394,15 @@ var ReadImpl3 = class {
     this._tx = kv;
     this.assertValidHash = assertValidHash;
   }
-  hasChunk(hash) {
-    return this._tx.has(chunkDataKey(hash));
+  hasChunk(hash2) {
+    return this._tx.has(chunkDataKey(hash2));
   }
-  async getChunk(hash) {
-    const data = await this._tx.get(chunkDataKey(hash));
+  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(hash));
+    const refsVal = await this._tx.get(chunkMetaKey(hash2));
     let refs;
     if (refsVal !== void 0) {
       assertRefs(refsVal);
@@ -2410,10 +2410,10 @@ var ReadImpl3 = class {
     } else {
       refs = [];
     }
-    return new Chunk(hash, data, refs);
+    return new Chunk(hash2, data, refs);
   }
-  mustGetChunk(hash) {
-    return mustGetChunk(this, hash);
+  mustGetChunk(hash2) {
+    return mustGetChunk(this, hash2);
   }
   async getHead(name) {
     const data = await this._tx.get(headKey(name));
@@ -2443,41 +2443,41 @@ var WriteImpl3 = class extends ReadImpl3 {
     return this._tx;
   }
   async putChunk(c) {
-    const { hash, data, meta } = c;
-    this.assertValidHash(hash);
-    const key = chunkDataKey(hash);
+    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(hash), meta);
+      p2 = this._tx.put(chunkMetaKey(hash2), meta);
     }
-    this.#putChunks.add(hash);
+    this.#putChunks.add(hash2);
     await p1;
     await p2;
   }
-  setHead(name, hash) {
-    return this.#setHead(name, hash);
+  setHead(name, hash2) {
+    return this.#setHead(name, hash2);
   }
   removeHead(name) {
     return this.#setHead(name, void 0);
   }
-  async #setHead(name, hash) {
+  async #setHead(name, hash2) {
     const oldHash = await this.getHead(name);
     const hk = headKey(name);
     let p1;
-    if (hash === void 0) {
+    if (hash2 === void 0) {
       p1 = this._tx.del(hk);
     } else {
-      p1 = this._tx.put(hk, hash);
+      p1 = this._tx.put(hk, hash2);
     }
     const v2 = this.#changedHeads.get(name);
     if (v2 === void 0) {
-      this.#changedHeads.set(name, { new: hash, old: oldHash });
+      this.#changedHeads.set(name, { new: hash2, old: oldHash });
     } else {
-      v2.new = hash;
+      v2.new = hash2;
     }
     await p1;
   }
@@ -2490,8 +2490,8 @@ var WriteImpl3 = class extends ReadImpl3 {
     await this.#applyRefCountUpdates(refCountUpdates);
     await this._tx.commit();
   }
-  async getRefCount(hash) {
-    const value = await this._tx.get(chunkRefCountKey(hash));
+  async getRefCount(hash2) {
+    const value = await this._tx.get(chunkRefCountKey(hash2));
     if (value === void 0) {
       return void 0;
     }
@@ -2503,8 +2503,8 @@ var WriteImpl3 = class extends ReadImpl3 {
     }
     return value;
   }
-  async getRefs(hash) {
-    const meta = await this._tx.get(chunkMetaKey(hash));
+  async getRefs(hash2) {
+    const meta = await this._tx.get(chunkMetaKey(hash2));
     if (meta === void 0) {
       return [];
     }
@@ -2513,23 +2513,23 @@ var WriteImpl3 = class extends ReadImpl3 {
   }
   async #applyRefCountUpdates(refCountCache) {
     const ps = [];
-    for (const [hash, count] of refCountCache) {
+    for (const [hash2, count] of refCountCache) {
       if (count === 0) {
-        ps.push(this.#removeAllRelatedKeys(hash));
+        ps.push(this.#removeAllRelatedKeys(hash2));
       } else {
-        const refCountKey = chunkRefCountKey(hash);
+        const refCountKey = chunkRefCountKey(hash2);
         ps.push(this._tx.put(refCountKey, count));
       }
     }
     await Promise.all(ps);
   }
-  async #removeAllRelatedKeys(hash) {
+  async #removeAllRelatedKeys(hash2) {
     await Promise.all([
-      this._tx.del(chunkDataKey(hash)),
-      this._tx.del(chunkMetaKey(hash)),
-      this._tx.del(chunkRefCountKey(hash))
+      this._tx.del(chunkDataKey(hash2)),
+      this._tx.del(chunkMetaKey(hash2)),
+      this._tx.del(chunkRefCountKey(hash2))
     ]);
-    this.#putChunks.delete(hash);
+    this.#putChunks.delete(hash2);
   }
   release() {
     this._tx.release();
@@ -2638,15 +2638,15 @@ async function localMutationsGreaterThan(commit, mutationIDLimits, dagRead) {
   return commits;
 }
 async function baseSnapshotFromHead(name, dagRead) {
-  const hash = await dagRead.getHead(name);
-  assert(hash, `Missing head ${name}`);
-  return baseSnapshotFromHash(hash, dagRead);
+  const hash2 = await dagRead.getHead(name);
+  assert(hash2, `Missing head ${name}`);
+  return baseSnapshotFromHash(hash2, dagRead);
 }
-async function baseSnapshotHashFromHash(hash, dagRead) {
-  return (await baseSnapshotFromHash(hash, dagRead)).chunk.hash;
+async function baseSnapshotHashFromHash(hash2, dagRead) {
+  return (await baseSnapshotFromHash(hash2, dagRead)).chunk.hash;
 }
-async function baseSnapshotFromHash(hash, dagRead) {
-  const commit = await commitFromHash(hash, dagRead);
+async function baseSnapshotFromHash(hash2, dagRead) {
+  const commit = await commitFromHash(hash2, dagRead);
   return baseSnapshotFromCommit(commit, dagRead);
 }
 async function baseSnapshotFromCommit(commit, dagRead) {
@@ -2690,13 +2690,13 @@ async function commitChain(fromCommitHash, dagRead) {
   commits.push(commit);
   return commits;
 }
-async function commitFromHash(hash, dagRead) {
-  const chunk = await dagRead.mustGetChunk(hash);
+async function commitFromHash(hash2, dagRead) {
+  const chunk = await dagRead.mustGetChunk(hash2);
   return fromChunk(chunk);
 }
 async function commitFromHead(name, dagRead) {
-  const hash = await mustGetHeadHash(name, dagRead);
-  return commitFromHash(hash, dagRead);
+  const hash2 = await mustGetHeadHash(name, dagRead);
+  return commitFromHash(hash2, dagRead);
 }
 function assertIndexChangeMeta(v2) {
   assertNumber(v2.lastMutationID);
@@ -2988,8 +2988,8 @@ function makeNodeChunkData(level, entries, formatVersion) {
     formatVersion >= V7 ? entries : entries.map((e) => e.slice(0, 2))
   ]);
 }
-async function findLeaf(key, hash, source, expectedRootHash) {
-  const node = await source.getNode(hash);
+async function findLeaf(key, hash2, source, expectedRootHash) {
+  const node = await source.getNode(hash2);
   if (expectedRootHash !== source.rootHash) {
     return findLeaf(key, source.rootHash, source, source.rootHash);
   }
@@ -3053,9 +3053,9 @@ var NodeImpl = class {
   hash;
   isMutable;
   #childNodeSize = -1;
-  constructor(entries, hash, isMutable) {
+  constructor(entries, hash2, isMutable) {
     this.entries = entries;
-    this.hash = hash;
+    this.hash = hash2;
     this.isMutable = isMutable;
   }
   maxKey() {
@@ -3134,8 +3134,8 @@ function readonlySplice(array10, start, deleteCount, ...items) {
 }
 var InternalNodeImpl = class _InternalNodeImpl extends NodeImpl {
   level;
-  constructor(entries, hash, level, isMutable) {
-    super(entries, hash, isMutable);
+  constructor(entries, hash2, level, isMutable) {
+    super(entries, hash2, isMutable);
     this.level = level;
   }
   async set(key, value, entrySize, tree) {
@@ -3167,8 +3167,8 @@ var InternalNodeImpl = class _InternalNodeImpl extends NodeImpl {
     let startIndex;
     let removeCount;
     if (i > 0) {
-      const hash = thisEntries[i - 1][1];
-      const previousSibling = await tree.getNode(hash);
+      const hash2 = thisEntries[i - 1][1];
+      const previousSibling = await tree.getNode(hash2);
       values = joinIterables(
         previousSibling.entries,
         childNode.entries
@@ -3176,8 +3176,8 @@ var InternalNodeImpl = class _InternalNodeImpl extends NodeImpl {
       startIndex = i - 1;
       removeCount = 2;
     } else if (i < thisEntries.length - 1) {
-      const hash = thisEntries[i + 1][1];
-      const nextSibling = await tree.getNode(hash);
+      const hash2 = thisEntries[i + 1][1];
+      const nextSibling = await tree.getNode(hash2);
       values = joinIterables(
         childNode.entries,
         nextSibling.entries
@@ -3291,15 +3291,15 @@ var InternalNodeImpl = class _InternalNodeImpl extends NodeImpl {
     return new DataNodeImpl(entries, newRandomHash(), true);
   }
 };
-function newNodeImpl(entries, hash, level, isMutable) {
+function newNodeImpl(entries, hash2, level, isMutable) {
   if (level === 0) {
     return new DataNodeImpl(
       entries,
-      hash,
+      hash2,
       isMutable
     );
   }
-  return new InternalNodeImpl(entries, hash, level, isMutable);
+  return new InternalNodeImpl(entries, hash2, level, isMutable);
 }
 function isDataNodeImpl(node) {
   return node.level === 0;
@@ -3445,15 +3445,15 @@ var BTreeRead = class {
     this.getEntrySize = getEntrySize;
     this.chunkHeaderSize = chunkHeaderSize;
   }
-  async getNode(hash) {
-    if (hash === emptyHash) {
+  async getNode(hash2) {
+    if (hash2 === emptyHash) {
       return emptyDataNodeImpl;
     }
-    const cached = this._cache.get(hash);
+    const cached = this._cache.get(hash2);
     if (cached) {
       return cached;
     }
-    const chunk = await this._dagRead.mustGetChunk(hash);
+    const chunk = await this._dagRead.mustGetChunk(hash2);
     const data = parseBTreeNode(
       chunk.data,
       this._formatVersion,
@@ -3461,11 +3461,11 @@ var BTreeRead = class {
     );
     const impl = newNodeImpl(
       data[NODE_ENTRIES],
-      hash,
+      hash2,
       data[NODE_LEVEL],
       false
     );
-    this._cache.set(hash, impl);
+    this._cache.set(hash2, impl);
     return impl;
   }
   async get(key) {
@@ -3499,15 +3499,15 @@ var BTreeRead = class {
       () => this.rootHash,
       this.rootHash,
       fromKey,
-      async (hash) => {
-        const cached = await this.getNode(hash);
+      async (hash2) => {
+        const cached = await this.getNode(hash2);
         if (cached) {
           return [
             cached.level,
             cached.isMutable ? cached.entries.slice() : cached.entries
           ];
         }
-        const chunk = await this._dagRead.mustGetChunk(hash);
+        const chunk = await this._dagRead.mustGetChunk(hash2);
         return parseBTreeNode(
           chunk.data,
           this._formatVersion,
@@ -3631,11 +3631,11 @@ function* diffEntries(lastEntries, currentEntries) {
     };
   }
 }
-async function* scanForHash(expectedRootHash, getRootHash, hash, fromKey, readNode) {
-  if (hash === emptyHash) {
+async function* scanForHash(expectedRootHash, getRootHash, hash2, fromKey, readNode) {
+  if (hash2 === emptyHash) {
     return;
   }
-  const data = await readNode(hash);
+  const data = await readNode(hash2);
   const entries = data[NODE_ENTRIES];
   let i = 0;
   if (fromKey) {
@@ -4329,10 +4329,10 @@ var BTreeWrite = class extends BTreeRead {
     });
   }
 };
-function gatherNewChunks(hash, newChunks, createChunk2, modified, formatVersion) {
-  const node = modified.get(hash);
+function gatherNewChunks(hash2, newChunks, createChunk2, modified, formatVersion) {
+  const node = modified.get(hash2);
   if (node === void 0) {
-    return hash;
+    return hash2;
   }
   if (isDataNodeImpl(node)) {
     const chunk2 = createChunk2(toChunkData(node, formatVersion), []);
@@ -5018,16 +5018,16 @@ function clientGroupMapToChunkData(clientGroups, dagWrite) {
   }
   return deepFreeze(chunkData);
 }
-async function getClientGroupsAtHash(hash, dagRead) {
-  const chunk = await dagRead.getChunk(hash);
+async function getClientGroupsAtHash(hash2, dagRead) {
+  const chunk = await dagRead.getChunk(hash2);
   return chunkDataToClientGroupMap(chunk?.data);
 }
 async function getClientGroups(dagRead) {
-  const hash = await dagRead.getHead(CLIENT_GROUPS_HEAD_NAME);
-  if (!hash) {
+  const hash2 = await dagRead.getHead(CLIENT_GROUPS_HEAD_NAME);
+  if (!hash2) {
     return /* @__PURE__ */ new Map();
   }
-  return getClientGroupsAtHash(hash, dagRead);
+  return getClientGroupsAtHash(hash2, dagRead);
 }
 async function setClientGroups(clientGroups, dagWrite) {
   const currClientGroups = await getClientGroups(dagWrite);
@@ -5284,14 +5284,14 @@ function clientMapToChunkData(clients, dagWrite) {
   return deepFreeze(Object.fromEntries(clients));
 }
 async function getClients(dagRead) {
-  const hash = await dagRead.getHead(CLIENTS_HEAD_NAME);
-  return getClientsAtHash(hash, dagRead);
+  const hash2 = await dagRead.getHead(CLIENTS_HEAD_NAME);
+  return getClientsAtHash(hash2, dagRead);
 }
-async function getClientsAtHash(hash, dagRead) {
-  if (!hash) {
+async function getClientsAtHash(hash2, dagRead) {
+  if (!hash2) {
     return /* @__PURE__ */ new Map();
   }
-  const chunk = await dagRead.getChunk(hash);
+  const chunk = await dagRead.getChunk(hash2);
   return chunkDataToClientMap(chunk?.data);
 }
 var ClientStateNotFoundError = class extends Error {
@@ -5482,8 +5482,8 @@ function getRefsForClients(clients) {
   const refs = /* @__PURE__ */ new Set();
   for (const client of clients.values()) {
     if (isClientV6(client)) {
-      for (const hash of client.refreshHashes) {
-        refs.add(hash);
+      for (const hash2 of client.refreshHashes) {
+        refs.add(hash2);
       }
       if (client.persistHash) {
         refs.add(client.persistHash);
@@ -9683,9 +9683,17 @@ function filterFalse(conditions) {
 // ../zql/src/query/query-impl.ts
 import { resolver as resolver7 } from "@rocicorp/resolver";
 
-// ../shared/src/xxhash.ts
-import xxhash from "xxhash-wasm";
-var { create64, h32, h64 } = await xxhash();
+// ../shared/src/hash.ts
+import { xxHash32 } from "js-xxhash";
+var h64 = (s) => hash(s, 2);
+var h128 = (s) => hash(s, 4);
+function hash(str, words) {
+  let hash2 = 0n;
+  for (let i = 0; i < words; i++) {
+    hash2 = (hash2 << 32n) + BigInt(xxHash32(str, i));
+  }
+  return hash2;
+}
 
 // ../zero-protocol/src/ast.ts
 import { compareUTF8 as compareUTF83 } from "compare-utf8";
@@ -9965,9 +9973,9 @@ function hashOfAST(ast) {
   if (cached) {
     return cached;
   }
-  const hash = h64(JSON.stringify(normalized)).toString(36);
-  hashCache.set(normalized, hash);
-  return hash;
+  const hash2 = h64(JSON.stringify(normalized)).toString(36);
+  hashCache.set(normalized, hash2);
+  return hash2;
 }
 
 // ../zql/src/ivm/change.ts
@@ -11890,8 +11898,8 @@ var AbstractQuery = class {
   hash() {
     if (!this.#hash) {
       const ast = this._completeAst();
-      const hash = hashOfAST(ast);
-      this.#hash = hash;
+      const hash2 = hashOfAST(ast);
+      this.#hash = hash2;
     }
     return this.#hash;
   }
@@ -12742,7 +12750,7 @@ var upstreamSchema = valita_exports.union(
 );
 
 // ../zero-protocol/src/protocol-version.ts
-var PROTOCOL_VERSION = 2;
+var PROTOCOL_VERSION = 3;
 
 // ../zero-client/src/util/nanoid.ts
 function nanoid(size = 21) {
@@ -14846,23 +14854,6 @@ var MemoryStorage = class {
   }
 };
 
-// ../shared/src/reverse-string.ts
-function reverseString(str) {
-  let reversed = "";
-  for (let i = str.length - 1; i >= 0; i--) {
-    reversed += str[i];
-  }
-  return reversed;
-}
-
-// ../shared/src/h64-with-reverse.ts
-function h64WithReverse(str) {
-  const forward = h64(str);
-  const backward = h64(reverseString(str));
-  const full = (forward << 64n) + backward;
-  return full.toString(36);
-}
-
 // ../zero-client/src/client/keys.ts
 var CLIENTS_KEY_PREFIX = "c/";
 var DESIRED_QUERIES_KEY_PREFIX = "d/";
@@ -14871,14 +14862,14 @@ var ENTITIES_KEY_PREFIX = "e/";
 function toClientsKey(clientID) {
   return CLIENTS_KEY_PREFIX + clientID;
 }
-function toDesiredQueriesKey(clientID, hash) {
-  return DESIRED_QUERIES_KEY_PREFIX + clientID + "/" + hash;
+function toDesiredQueriesKey(clientID, hash2) {
+  return DESIRED_QUERIES_KEY_PREFIX + clientID + "/" + hash2;
 }
 function desiredQueriesPrefixForClient(clientID) {
   return DESIRED_QUERIES_KEY_PREFIX + clientID + "/";
 }
-function toGotQueriesKey(hash) {
-  return GOT_QUERIES_KEY_PREFIX + hash;
+function toGotQueriesKey(hash2) {
+  return GOT_QUERIES_KEY_PREFIX + hash2;
 }
 function toPrimaryKeyString(tableName, primaryKey, value) {
   if (primaryKey.length === 1) {
@@ -14886,7 +14877,7 @@ function toPrimaryKeyString(tableName, primaryKey, value) {
   }
   const values = primaryKey.map((k) => parse(value[k], primaryKeyValueSchema));
   const str = JSON.stringify(values);
-  const idSegment = h64WithReverse(str);
+  const idSegment = h128(str);
   return ENTITIES_KEY_PREFIX + tableName + "/" + idSegment;
 }
 
@@ -15454,7 +15445,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.9.2024121900+535718";
+var version2 = "0.9.2024122300+b69fce";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -15802,26 +15793,26 @@ var QueryManager = class {
       existingQueryHashes.add(key.substring(prefix.length, key.length));
     }
     const patch = /* @__PURE__ */ new Map();
-    for (const hash of existingQueryHashes) {
-      if (!this.#queries.has(hash)) {
-        patch.set(hash, { op: "del", hash });
+    for (const hash2 of existingQueryHashes) {
+      if (!this.#queries.has(hash2)) {
+        patch.set(hash2, { op: "del", hash: hash2 });
       }
     }
-    for (const [hash, { normalized }] of this.#queries) {
-      if (!existingQueryHashes.has(hash)) {
-        patch.set(hash, { op: "put", hash, ast: normalized });
+    for (const [hash2, { normalized }] of this.#queries) {
+      if (!existingQueryHashes.has(hash2)) {
+        patch.set(hash2, { op: "put", hash: hash2, ast: normalized });
       }
     }
     if (lastPatch) {
-      for (const [hash, { op }] of lastPatch) {
-        if (op === "put" && !patch.has(hash)) {
-          patch.set(hash, { op: "del", hash });
+      for (const [hash2, { op }] of lastPatch) {
+        if (op === "put" && !patch.has(hash2)) {
+          patch.set(hash2, { op: "del", hash: hash2 });
         }
       }
-      for (const [hash, { op }] of patch) {
-        const lastPatchOp = lastPatch.get(hash);
+      for (const [hash2, { op }] of patch) {
+        const lastPatchOp = lastPatch.get(hash2);
         if (lastPatchOp && lastPatchOp.op === op) {
-          patch.delete(hash);
+          patch.delete(hash2);
         }
       }
     }
@@ -16045,6 +16036,13 @@ function validateServerParam(paramName, server) {
   return urlString;
 }
 function getServer(server) {
+  const WS = getBrowserGlobal("WebSocket");
+  if (!WS) {
+    console.warn(
+      "Zero started in an unsupported environment, no data will be synced."
+    );
+    return null;
+  }
   if (server === void 0 || server === null) {
     console.warn(
       "Zero starting up with no server URL. This is supported for unit testing and prototyping, but no data will be synced."
@@ -16220,7 +16218,7 @@ function mergePokes(pokeBuffer, schema) {
             ...queriesPatch.map(
               (op) => queryPatchOpToReplicachePatchOp(
                 op,
-                (hash) => toDesiredQueriesKey(clientID, hash)
+                (hash2) => toDesiredQueriesKey(clientID, hash2)
               )
             )
           );
@@ -16625,6 +16623,12 @@ var Zero = class {
     }
     return createLogOptions(options);
   }
+  /**
+   * The server URL that this Zero instance is configured with.
+   */
+  get server() {
+    return this.#server;
+  }
   /**
    * The name of the IndexedDB database in which the data of this
    * instance of Zero is stored.
@@ -17472,4 +17476,4 @@ export {
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-3L5FRWGX.js.map
+//# sourceMappingURL=chunk-NYJROCBH.js.map