@rocicorp/zero 0.3.2024102502 → 0.3.2024102800

package/out/zero.js

@@ -1,74 +1,28 @@
 import {
-  __export,
-  __reExport,
   hasOwn
-} from "./chunk-2RUT5EQV.js";
+} from "./chunk-HARIWJ2J.js";
+import {
+  applyChange,
+  assert,
+  assertArray,
+  assertBoolean,
+  assertNotNull,
+  assertNotUndefined,
+  assertNumber,
+  assertObject,
+  assertString,
+  must,
+  throwInvalidType,
+  unreachable
+} from "./chunk-RCVGGCMG.js";
+import {
+  __export,
+  __reExport
+} from "./chunk-F5QR3K72.js";
 
 // ../replicache/src/mod.ts
 import { consoleLogSink as consoleLogSink3 } from "@rocicorp/logger";
 
-// ../shared/src/asserts.ts
-function assert(b, msg = "Assertion failed") {
-  if (!b) {
-    throw new Error(msg);
-  }
-}
-function assertString(v2) {
-  assertType(v2, "string");
-}
-function assertNumber(v2) {
-  assertType(v2, "number");
-}
-function assertBoolean(v2) {
-  assertType(v2, "boolean");
-}
-function assertType(v2, t2) {
-  if (typeof v2 !== t2) {
-    throwInvalidType(v2, t2);
-  }
-}
-function assertObject(v2) {
-  if (v2 === null) {
-    throwInvalidType(v2, "object");
-  }
-  assertType(v2, "object");
-}
-function assertArray(v2) {
-  if (!Array.isArray(v2)) {
-    throwInvalidType(v2, "array");
-  }
-}
-function invalidType(v2, t2) {
-  let s = "Invalid type: ";
-  if (v2 === null || v2 === void 0) {
-    s += v2;
-  } else {
-    s += `${typeof v2} \`${v2}\``;
-  }
-  return s + `, expected ${t2}`;
-}
-function throwInvalidType(v2, t2) {
-  throw new Error(invalidType(v2, t2));
-}
-function assertNotNull(v2) {
-  if (v2 === null) {
-    throw new Error("Expected non-null value");
-  }
-}
-function assertUndefined(v2, msg = "Expected undefined value") {
-  if (v2 !== void 0) {
-    throw new Error(msg);
-  }
-}
-function assertNotUndefined(v2, msg = "Expected non undefined value") {
-  if (v2 === void 0) {
-    throw new Error(msg);
-  }
-}
-function unreachable(_) {
-  throw new Error("Unreachable");
-}
-
 // ../shared/src/config.ts
 var isProd = process.env.NODE_ENV === "production";
 
@@ -1049,13 +1003,13 @@ var Chunk = class {
    * chunk.
    */
   meta;
-  constructor(hash2, data, refs) {
+  constructor(hash, data, refs) {
     assert(
-      !refs.includes(hash2),
+      !refs.includes(hash),
       "Chunk cannot reference itself"
     );
     assertDeepFrozen(data);
-    this.hash = hash2;
+    this.hash = hash;
     this.data = data;
     this.meta = refs;
   }
@@ -1072,8 +1026,8 @@ function assertRefs(v2) {
   }
 }
 function createChunk(data, refs, chunkHasher) {
-  const hash2 = chunkHasher();
-  return new Chunk(hash2, data, refs);
+  const hash = chunkHasher();
+  return new Chunk(hash, data, refs);
 }
 function throwChunkHasher() {
   throw new Error("unexpected call to compute chunk hash");
@@ -1117,7 +1071,7 @@ var RefCountUpdates = class {
     await Promise.all(
       Array.from(
         this.#putChunks.values(),
-        (hash2) => this.#ensureRefCountLoaded(hash2)
+        (hash) => this.#ensureRefCountLoaded(hash)
       )
     );
     if (this.#isLazyDelegate) {
@@ -1126,9 +1080,9 @@ var RefCountUpdates = class {
       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);
+        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);
             refCountsUpdated = true;
             break;
           }
@@ -1139,67 +1093,67 @@ var RefCountUpdates = class {
       await this.#changeRefCount(o, -1);
     }
     if (!isProd) {
-      for (const [hash2, update] of this.#refCountUpdates) {
+      for (const [hash, update] of this.#refCountUpdates) {
         assert(
           update >= 0,
-          `ref count update must be non-negative. ${hash2}:${update}`
+          `ref count update must be non-negative. ${hash}:${update}`
         );
       }
     }
     return this.#refCountUpdates;
   }
-  async #changeRefCount(hash2, delta) {
-    await this.#ensureRefCountLoaded(hash2);
-    if (this.#updateRefCount(hash2, delta)) {
-      await this.#updateRefsCounts(hash2, delta);
+  async #changeRefCount(hash, delta) {
+    await this.#ensureRefCountLoaded(hash);
+    if (this.#updateRefCount(hash, delta)) {
+      await this.#updateRefsCounts(hash, delta);
     }
   }
-  async #updateRefsCounts(hash2, delta) {
-    if (hash2 === emptyHash) {
+  async #updateRefsCounts(hash, delta) {
+    if (hash === emptyHash) {
       return;
     }
-    const refs = await this.#delegate.getRefs(hash2);
+    const refs = await this.#delegate.getRefs(hash);
     if (!isProd) {
       assert(
-        refs || this.#isLazyDelegate && !this.#putChunks.has(hash2),
+        refs || this.#isLazyDelegate && !this.#putChunks.has(hash),
         "refs must be defined"
       );
     }
     if (refs !== void 0) {
-      this.#refsCounted?.add(hash2);
+      this.#refsCounted?.add(hash);
       const ps = refs.map((ref) => this.#changeRefCount(ref, delta));
       await Promise.all(ps);
     }
   }
-  #ensureRefCountLoaded(hash2) {
-    let p = this.#loadedRefCountPromises.get(hash2);
+  #ensureRefCountLoaded(hash) {
+    let p = this.#loadedRefCountPromises.get(hash);
     if (p === void 0) {
       p = (async () => {
-        const value = await this.#delegate.getRefCount(hash2) || 0;
-        this.#refCountUpdates.set(hash2, value);
+        const value = await this.#delegate.getRefCount(hash) || 0;
+        this.#refCountUpdates.set(hash, value);
         return value;
       })();
-      this.#loadedRefCountPromises.set(hash2, p);
+      this.#loadedRefCountPromises.set(hash, p);
     }
     return p;
   }
-  #updateRefCount(hash2, delta) {
-    const oldCount = this.#refCountUpdates.get(hash2);
+  #updateRefCount(hash, delta) {
+    const oldCount = this.#refCountUpdates.get(hash);
     assertNumber(oldCount);
-    this.#refCountUpdates.set(hash2, oldCount + delta);
+    this.#refCountUpdates.set(hash, oldCount + delta);
     return oldCount === 0 && delta === 1 || oldCount === 1 && delta === -1;
   }
 };
 
 // ../replicache/src/dag/key.ts
-function chunkDataKey(hash2) {
-  return `c/${hash2}/d`;
+function chunkDataKey(hash) {
+  return `c/${hash}/d`;
 }
-function chunkMetaKey(hash2) {
-  return `c/${hash2}/m`;
+function chunkMetaKey(hash) {
+  return `c/${hash}/m`;
 }
-function chunkRefCountKey(hash2) {
-  return `c/${hash2}/r`;
+function chunkRefCountKey(hash) {
+  return `c/${hash}/r`;
 }
 function headKey(name) {
   return `h/${name}`;
@@ -1209,22 +1163,22 @@ function headKey(name) {
 var ChunkNotFoundError = class extends Error {
   name = "ChunkNotFoundError";
   hash;
-  constructor(hash2) {
-    super(`Chunk not found ${hash2}`);
-    this.hash = hash2;
+  constructor(hash) {
+    super(`Chunk not found ${hash}`);
+    this.hash = hash;
   }
 };
-async function mustGetChunk(store, hash2) {
-  const chunk = await store.getChunk(hash2);
+async function mustGetChunk(store, hash) {
+  const chunk = await store.getChunk(hash);
   if (chunk) {
     return chunk;
   }
-  throw new ChunkNotFoundError(hash2);
+  throw new ChunkNotFoundError(hash);
 }
 async function mustGetHeadHash(name, store) {
-  const hash2 = await store.getHead(name);
-  assert(hash2, `Missing head ${name}`);
-  return hash2;
+  const hash = await store.getHead(name);
+  assert(hash, `Missing head ${name}`);
+  return hash;
 }
 
 // ../replicache/src/dag/store-impl.ts
@@ -1258,15 +1212,15 @@ var ReadImpl2 = class {
     this._tx = kv;
     this.assertValidHash = assertValidHash;
   }
-  hasChunk(hash2) {
-    return this._tx.has(chunkDataKey(hash2));
+  hasChunk(hash) {
+    return this._tx.has(chunkDataKey(hash));
   }
-  async getChunk(hash2) {
-    const data = await this._tx.get(chunkDataKey(hash2));
+  async getChunk(hash) {
+    const data = await this._tx.get(chunkDataKey(hash));
     if (data === void 0) {
       return void 0;
     }
-    const refsVal = await this._tx.get(chunkMetaKey(hash2));
+    const refsVal = await this._tx.get(chunkMetaKey(hash));
     let refs;
     if (refsVal !== void 0) {
       assertRefs(refsVal);
@@ -1274,10 +1228,10 @@ var ReadImpl2 = class {
     } else {
       refs = [];
     }
-    return new Chunk(hash2, data, refs);
+    return new Chunk(hash, data, refs);
   }
-  mustGetChunk(hash2) {
-    return mustGetChunk(this, hash2);
+  mustGetChunk(hash) {
+    return mustGetChunk(this, hash);
   }
   async getHead(name) {
     const data = await this._tx.get(headKey(name));
@@ -1307,41 +1261,41 @@ var WriteImpl2 = class extends ReadImpl2 {
     return this._tx;
   }
   async putChunk(c) {
-    const { hash: hash2, data, meta } = c;
-    this.assertValidHash(hash2);
-    const key = chunkDataKey(hash2);
+    const { hash, data, meta } = c;
+    this.assertValidHash(hash);
+    const key = chunkDataKey(hash);
     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);
+      p2 = this._tx.put(chunkMetaKey(hash), meta);
     }
-    this.#putChunks.add(hash2);
+    this.#putChunks.add(hash);
     await p1;
     await p2;
   }
-  setHead(name, hash2) {
-    return this.#setHead(name, hash2);
+  setHead(name, hash) {
+    return this.#setHead(name, hash);
   }
   removeHead(name) {
     return this.#setHead(name, void 0);
   }
-  async #setHead(name, hash2) {
+  async #setHead(name, hash) {
     const oldHash = await this.getHead(name);
     const hk = headKey(name);
     let p1;
-    if (hash2 === void 0) {
+    if (hash === void 0) {
       p1 = this._tx.del(hk);
     } else {
-      p1 = this._tx.put(hk, hash2);
+      p1 = this._tx.put(hk, hash);
     }
     const v2 = this.#changedHeads.get(name);
     if (v2 === void 0) {
-      this.#changedHeads.set(name, { new: hash2, old: oldHash });
+      this.#changedHeads.set(name, { new: hash, old: oldHash });
     } else {
-      v2.new = hash2;
+      v2.new = hash;
     }
     await p1;
   }
@@ -1354,8 +1308,8 @@ var WriteImpl2 = class extends ReadImpl2 {
     await this.#applyRefCountUpdates(refCountUpdates);
     await this._tx.commit();
   }
-  async getRefCount(hash2) {
-    const value = await this._tx.get(chunkRefCountKey(hash2));
+  async getRefCount(hash) {
+    const value = await this._tx.get(chunkRefCountKey(hash));
     if (value === void 0) {
       return void 0;
     }
@@ -1367,8 +1321,8 @@ var WriteImpl2 = class extends ReadImpl2 {
     }
     return value;
   }
-  async getRefs(hash2) {
-    const meta = await this._tx.get(chunkMetaKey(hash2));
+  async getRefs(hash) {
+    const meta = await this._tx.get(chunkMetaKey(hash));
     if (meta === void 0) {
       return [];
     }
@@ -1377,23 +1331,23 @@ var WriteImpl2 = class extends ReadImpl2 {
   }
   async #applyRefCountUpdates(refCountCache) {
     const ps = [];
-    for (const [hash2, count] of refCountCache) {
+    for (const [hash, count] of refCountCache) {
       if (count === 0) {
-        ps.push(this.#removeAllRelatedKeys(hash2));
+        ps.push(this.#removeAllRelatedKeys(hash));
       } else {
-        const refCountKey = chunkRefCountKey(hash2);
+        const refCountKey = chunkRefCountKey(hash);
         ps.push(this._tx.put(refCountKey, count));
       }
     }
     await Promise.all(ps);
   }
-  async #removeAllRelatedKeys(hash2) {
+  async #removeAllRelatedKeys(hash) {
     await Promise.all([
-      this._tx.del(chunkDataKey(hash2)),
-      this._tx.del(chunkMetaKey(hash2)),
-      this._tx.del(chunkRefCountKey(hash2))
+      this._tx.del(chunkDataKey(hash)),
+      this._tx.del(chunkMetaKey(hash)),
+      this._tx.del(chunkRefCountKey(hash))
     ]);
-    this.#putChunks.delete(hash2);
+    this.#putChunks.delete(hash);
   }
   release() {
     this._tx.release();
@@ -2151,28 +2105,28 @@ var LazyRead = class {
     this.#release = release;
     this.assertValidHash = assertValidHash;
   }
-  isMemOnlyChunkHash(hash2) {
-    return this._memOnlyChunks.has(hash2);
+  isMemOnlyChunkHash(hash) {
+    return this._memOnlyChunks.has(hash);
   }
-  async hasChunk(hash2) {
-    return await this.getChunk(hash2) !== void 0;
+  async hasChunk(hash) {
+    return await this.getChunk(hash) !== void 0;
   }
-  async getChunk(hash2) {
-    const memOnlyChunk = this._memOnlyChunks.get(hash2);
+  async getChunk(hash) {
+    const memOnlyChunk = this._memOnlyChunks.get(hash);
     if (memOnlyChunk !== void 0) {
       return memOnlyChunk;
     }
-    let chunk = this._sourceChunksCache.get(hash2);
+    let chunk = this._sourceChunksCache.get(hash);
     if (chunk === void 0) {
-      chunk = await (await this._getSourceRead()).getChunk(hash2);
+      chunk = await (await this._getSourceRead()).getChunk(hash);
       if (chunk !== void 0) {
         this._sourceChunksCache.put(chunk);
       }
     }
     return chunk;
   }
-  mustGetChunk(hash2) {
-    return mustGetChunk(this, hash2);
+  mustGetChunk(hash) {
+    return mustGetChunk(this, hash);
   }
   getHead(name) {
     return Promise.resolve(this._heads.get(name));
@@ -2222,54 +2176,54 @@ var LazyWrite = class extends LazyRead {
     return chunk;
   };
   putChunk(c, size) {
-    const { hash: hash2, meta } = c;
-    this.assertValidHash(hash2);
+    const { hash, meta } = c;
+    this.assertValidHash(hash);
     if (meta.length > 0) {
       for (const h of meta) {
         this.assertValidHash(h);
       }
     }
-    if (this.#createdChunks.has(hash2) || this.isMemOnlyChunkHash(hash2)) {
-      this._pendingMemOnlyChunks.set(hash2, c);
+    if (this.#createdChunks.has(hash) || this.isMemOnlyChunkHash(hash)) {
+      this._pendingMemOnlyChunks.set(hash, c);
     } else {
-      this._pendingCachedChunks.set(hash2, { chunk: c, size: size ?? -1 });
+      this._pendingCachedChunks.set(hash, { chunk: c, size: size ?? -1 });
     }
     return promiseVoid;
   }
-  async setHead(name, hash2) {
-    await this.#setHead(name, hash2);
+  async setHead(name, hash) {
+    await this.#setHead(name, hash);
   }
   async removeHead(name) {
     await this.#setHead(name, void 0);
   }
-  async #setHead(name, hash2) {
+  async #setHead(name, hash) {
     const oldHash = await this.getHead(name);
     const v2 = this._pendingHeadChanges.get(name);
     if (v2 === void 0) {
-      this._pendingHeadChanges.set(name, { new: hash2, old: oldHash });
+      this._pendingHeadChanges.set(name, { new: hash, old: oldHash });
     } else {
-      v2.new = hash2;
+      v2.new = hash;
     }
   }
-  isMemOnlyChunkHash(hash2) {
-    return this._pendingMemOnlyChunks.has(hash2) || super.isMemOnlyChunkHash(hash2);
+  isMemOnlyChunkHash(hash) {
+    return this._pendingMemOnlyChunks.has(hash) || super.isMemOnlyChunkHash(hash);
   }
-  async getChunk(hash2) {
-    const pendingMemOnlyChunk = this._pendingMemOnlyChunks.get(hash2);
+  async getChunk(hash) {
+    const pendingMemOnlyChunk = this._pendingMemOnlyChunks.get(hash);
     if (pendingMemOnlyChunk !== void 0) {
       return pendingMemOnlyChunk;
     }
-    const memOnlyChunk = this._memOnlyChunks.get(hash2);
+    const memOnlyChunk = this._memOnlyChunks.get(hash);
     if (memOnlyChunk !== void 0) {
       return memOnlyChunk;
     }
-    const pendingCachedChunk = this._pendingCachedChunks.get(hash2);
+    const pendingCachedChunk = this._pendingCachedChunks.get(hash);
     if (pendingCachedChunk !== void 0) {
       return pendingCachedChunk.chunk;
     }
-    let chunk = this._sourceChunksCache.get(hash2);
+    let chunk = this._sourceChunksCache.get(hash);
     if (chunk === void 0) {
-      chunk = await (await this._getSourceRead()).getChunk(hash2);
+      chunk = await (await this._getSourceRead()).getChunk(hash);
       if (chunk !== void 0) {
         this._pendingCachedChunks.set(chunk.hash, { chunk, size: -1 });
       }
@@ -2295,21 +2249,21 @@ var LazyWrite = class extends LazyRead {
       pendingChunks,
       this
     );
-    for (const [hash2, count] of refCountUpdates) {
-      if (this.isMemOnlyChunkHash(hash2)) {
+    for (const [hash, count] of refCountUpdates) {
+      if (this.isMemOnlyChunkHash(hash)) {
         if (count === 0) {
-          this.#refCounts.delete(hash2);
-          this._memOnlyChunks.delete(hash2);
-          this.#refs.delete(hash2);
+          this.#refCounts.delete(hash);
+          this._memOnlyChunks.delete(hash);
+          this.#refs.delete(hash);
         } else {
-          this.#refCounts.set(hash2, count);
-          const chunk = this._pendingMemOnlyChunks.get(hash2);
+          this.#refCounts.set(hash, count);
+          const chunk = this._pendingMemOnlyChunks.get(hash);
           if (chunk) {
-            this.#refs.set(hash2, chunk.meta);
-            this._memOnlyChunks.set(hash2, chunk);
+            this.#refs.set(hash, chunk.meta);
+            this._memOnlyChunks.set(hash, chunk);
           }
         }
-        refCountUpdates.delete(hash2);
+        refCountUpdates.delete(hash);
       }
     }
     this._sourceChunksCache.updateForCommit(
@@ -2328,26 +2282,26 @@ var LazyWrite = class extends LazyRead {
     this._pendingHeadChanges.clear();
     this.release();
   }
-  getRefCount(hash2) {
-    return this.#refCounts.get(hash2);
+  getRefCount(hash) {
+    return this.#refCounts.get(hash);
   }
-  getRefs(hash2) {
-    const pendingMemOnlyChunk = this._pendingMemOnlyChunks.get(hash2);
+  getRefs(hash) {
+    const pendingMemOnlyChunk = this._pendingMemOnlyChunks.get(hash);
     if (pendingMemOnlyChunk) {
       return pendingMemOnlyChunk.meta;
     }
-    const memOnlyChunk = this._memOnlyChunks.get(hash2);
+    const memOnlyChunk = this._memOnlyChunks.get(hash);
     if (memOnlyChunk) {
       return memOnlyChunk.meta;
     }
-    const pendingCachedChunk = this._pendingCachedChunks.get(hash2);
+    const pendingCachedChunk = this._pendingCachedChunks.get(hash);
     if (pendingCachedChunk !== void 0) {
       return pendingCachedChunk.chunk.meta;
     }
-    return this.#refs.get(hash2);
+    return this.#refs.get(hash);
   }
-  areRefsCounted(hash2) {
-    return this.#refs.has(hash2);
+  areRefsCounted(hash) {
+    return this.#refs.has(hash);
   }
   chunksPersisted(chunkHashes) {
     const chunksToCache = [];
@@ -2381,37 +2335,37 @@ var ChunksCache = class {
     this.#refCounts = refCounts;
     this.#refs = refs;
   }
-  get(hash2) {
-    const cacheEntry = this.cacheEntries.get(hash2);
+  get(hash) {
+    const cacheEntry = this.cacheEntries.get(hash);
     if (cacheEntry) {
-      this.cacheEntries.delete(hash2);
-      this.cacheEntries.set(hash2, cacheEntry);
+      this.cacheEntries.delete(hash);
+      this.cacheEntries.set(hash, cacheEntry);
     }
     return cacheEntry?.chunk;
   }
-  getWithoutUpdatingLRU(hash2) {
-    return this.cacheEntries.get(hash2)?.chunk;
+  getWithoutUpdatingLRU(hash) {
+    return this.cacheEntries.get(hash)?.chunk;
   }
   put(chunk) {
-    const { hash: hash2 } = chunk;
-    const oldCacheEntry = this.cacheEntries.get(hash2);
+    const { hash } = chunk;
+    const oldCacheEntry = this.cacheEntries.get(hash);
     if (oldCacheEntry) {
-      this.cacheEntries.delete(hash2);
-      this.cacheEntries.set(hash2, oldCacheEntry);
+      this.cacheEntries.delete(hash);
+      this.cacheEntries.set(hash, oldCacheEntry);
       return;
     }
-    const refCount = this.#refCounts.get(hash2);
+    const refCount = this.#refCounts.get(hash);
     if (refCount === void 0 || refCount < 1) {
       return;
     }
     if (!this.#cacheChunk(chunk)) {
       return;
     }
-    if (!this.#refs.has(hash2)) {
+    if (!this.#refs.has(hash)) {
       for (const refHash of chunk.meta) {
         this.#refCounts.set(refHash, (this.#refCounts.get(refHash) || 0) + 1);
       }
-      this.#refs.set(hash2, chunk.meta);
+      this.#refs.set(hash, chunk.meta);
     }
     this.#ensureCacheSizeLimit();
   }
@@ -2436,40 +2390,40 @@ var ChunksCache = class {
     return true;
   }
   #evict(cacheEntry) {
-    const { hash: hash2 } = cacheEntry.chunk;
+    const { hash } = cacheEntry.chunk;
     this.#size -= cacheEntry.size;
-    this.cacheEntries.delete(hash2);
+    this.cacheEntries.delete(hash);
   }
-  #deleteEntryByHash(hash2) {
-    this.#refCounts.delete(hash2);
-    this.#refs.delete(hash2);
-    const cacheEntry = this.cacheEntries.get(hash2);
+  #deleteEntryByHash(hash) {
+    this.#refCounts.delete(hash);
+    this.#refs.delete(hash);
+    const cacheEntry = this.cacheEntries.get(hash);
     if (cacheEntry) {
       this.#size -= cacheEntry.size;
-      this.cacheEntries.delete(hash2);
+      this.cacheEntries.delete(hash);
     }
   }
   updateForCommit(chunksToPut, refCountUpdates) {
-    for (const [hash2, count] of refCountUpdates) {
+    for (const [hash, count] of refCountUpdates) {
       if (count === 0) {
         if (!this.#evictsAndDeletesSuspended) {
-          this.#deleteEntryByHash(hash2);
+          this.#deleteEntryByHash(hash);
         } else {
-          this.#refCounts.set(hash2, 0);
-          this.#suspendedDeletes.push(hash2);
+          this.#refCounts.set(hash, 0);
+          this.#suspendedDeletes.push(hash);
         }
       } else {
-        this.#refCounts.set(hash2, count);
-        const chunkAndSize = chunksToPut.get(hash2);
+        this.#refCounts.set(hash, count);
+        const chunkAndSize = chunksToPut.get(hash);
         if (chunkAndSize) {
           const { chunk, size } = chunkAndSize;
-          const oldCacheEntry = this.cacheEntries.get(hash2);
+          const oldCacheEntry = this.cacheEntries.get(hash);
           if (oldCacheEntry) {
-            this.cacheEntries.delete(hash2);
-            this.cacheEntries.set(hash2, oldCacheEntry);
+            this.cacheEntries.delete(hash);
+            this.cacheEntries.set(hash, oldCacheEntry);
           } else {
             this.#cacheChunk(chunk, size !== -1 ? size : void 0);
-            this.#refs.set(hash2, chunk.meta);
+            this.#refs.set(hash, chunk.meta);
           }
         }
       }
@@ -2488,9 +2442,9 @@ var ChunksCache = class {
       return await fn();
     } finally {
       this.#evictsAndDeletesSuspended = false;
-      for (const hash2 of this.#suspendedDeletes) {
-        if (this.#refCounts.get(hash2) === 0) {
-          this.#deleteEntryByHash(hash2);
+      for (const hash of this.#suspendedDeletes) {
+        if (this.#refCounts.get(hash) === 0) {
+          this.#deleteEntryByHash(hash);
         }
       }
       this.#ensureCacheSizeLimit();
@@ -2600,15 +2554,15 @@ async function localMutationsGreaterThan(commit, mutationIDLimits, dagRead) {
   return commits;
 }
 async function baseSnapshotFromHead(name, dagRead) {
-  const hash2 = await dagRead.getHead(name);
-  assert(hash2, `Missing head ${name}`);
-  return baseSnapshotFromHash(hash2, dagRead);
+  const hash = await dagRead.getHead(name);
+  assert(hash, `Missing head ${name}`);
+  return baseSnapshotFromHash(hash, dagRead);
 }
-async function baseSnapshotHashFromHash(hash2, dagRead) {
-  return (await baseSnapshotFromHash(hash2, dagRead)).chunk.hash;
+async function baseSnapshotHashFromHash(hash, dagRead) {
+  return (await baseSnapshotFromHash(hash, dagRead)).chunk.hash;
 }
-async function baseSnapshotFromHash(hash2, dagRead) {
-  const commit = await commitFromHash(hash2, dagRead);
+async function baseSnapshotFromHash(hash, dagRead) {
+  const commit = await commitFromHash(hash, dagRead);
   return baseSnapshotFromCommit(commit, dagRead);
 }
 async function baseSnapshotFromCommit(commit, dagRead) {
@@ -2652,13 +2606,13 @@ async function commitChain(fromCommitHash, dagRead) {
   commits.push(commit);
   return commits;
 }
-async function commitFromHash(hash2, dagRead) {
-  const chunk = await dagRead.mustGetChunk(hash2);
+async function commitFromHash(hash, dagRead) {
+  const chunk = await dagRead.mustGetChunk(hash);
   return fromChunk(chunk);
 }
 async function commitFromHead(name, dagRead) {
-  const hash2 = await mustGetHeadHash(name, dagRead);
-  return commitFromHash(hash2, dagRead);
+  const hash = await mustGetHeadHash(name, dagRead);
+  return commitFromHash(hash, dagRead);
 }
 function assertIndexChangeMeta(v2) {
   assertNumber(v2.lastMutationID);
@@ -2950,8 +2904,8 @@ function makeNodeChunkData(level, entries, formatVersion) {
     formatVersion >= V7 ? entries : entries.map((e) => e.slice(0, 2))
   ]);
 }
-async function findLeaf(key, hash2, source, expectedRootHash) {
-  const node = await source.getNode(hash2);
+async function findLeaf(key, hash, source, expectedRootHash) {
+  const node = await source.getNode(hash);
   if (expectedRootHash !== source.rootHash) {
     return findLeaf(key, source.rootHash, source, source.rootHash);
   }
@@ -3015,9 +2969,9 @@ var NodeImpl = class {
   hash;
   isMutable;
   #childNodeSize = -1;
-  constructor(entries, hash2, isMutable) {
+  constructor(entries, hash, isMutable) {
     this.entries = entries;
-    this.hash = hash2;
+    this.hash = hash;
     this.isMutable = isMutable;
   }
   maxKey() {
@@ -3096,8 +3050,8 @@ function readonlySplice(array9, start, deleteCount, ...items) {
 }
 var InternalNodeImpl = class _InternalNodeImpl extends NodeImpl {
   level;
-  constructor(entries, hash2, level, isMutable) {
-    super(entries, hash2, isMutable);
+  constructor(entries, hash, level, isMutable) {
+    super(entries, hash, isMutable);
     this.level = level;
   }
   async set(key, value, entrySize, tree) {
@@ -3129,8 +3083,8 @@ var InternalNodeImpl = class _InternalNodeImpl extends NodeImpl {
     let startIndex;
     let removeCount;
     if (i > 0) {
-      const hash2 = thisEntries[i - 1][1];
-      const previousSibling = await tree.getNode(hash2);
+      const hash = thisEntries[i - 1][1];
+      const previousSibling = await tree.getNode(hash);
       values = joinIterables(
         previousSibling.entries,
         childNode.entries
@@ -3138,8 +3092,8 @@ var InternalNodeImpl = class _InternalNodeImpl extends NodeImpl {
       startIndex = i - 1;
       removeCount = 2;
     } else if (i < thisEntries.length - 1) {
-      const hash2 = thisEntries[i + 1][1];
-      const nextSibling = await tree.getNode(hash2);
+      const hash = thisEntries[i + 1][1];
+      const nextSibling = await tree.getNode(hash);
       values = joinIterables(
         childNode.entries,
         nextSibling.entries
@@ -3253,15 +3207,15 @@ var InternalNodeImpl = class _InternalNodeImpl extends NodeImpl {
     return new DataNodeImpl(entries, newRandomHash(), true);
   }
 };
-function newNodeImpl(entries, hash2, level, isMutable) {
+function newNodeImpl(entries, hash, level, isMutable) {
   if (level === 0) {
     return new DataNodeImpl(
       entries,
-      hash2,
+      hash,
       isMutable
     );
   }
-  return new InternalNodeImpl(entries, hash2, level, isMutable);
+  return new InternalNodeImpl(entries, hash, level, isMutable);
 }
 function isDataNodeImpl(node) {
   return node.level === 0;
@@ -3407,15 +3361,15 @@ var BTreeRead = class {
     this.getEntrySize = getEntrySize;
     this.chunkHeaderSize = chunkHeaderSize;
   }
-  async getNode(hash2) {
-    if (hash2 === emptyHash) {
+  async getNode(hash) {
+    if (hash === emptyHash) {
       return emptyDataNodeImpl;
     }
-    const cached = this._cache.get(hash2);
+    const cached = this._cache.get(hash);
     if (cached) {
       return cached;
     }
-    const chunk = await this._dagRead.mustGetChunk(hash2);
+    const chunk = await this._dagRead.mustGetChunk(hash);
     const data = parseBTreeNode(
       chunk.data,
       this._formatVersion,
@@ -3423,11 +3377,11 @@ var BTreeRead = class {
     );
     const impl = newNodeImpl(
       data[NODE_ENTRIES],
-      hash2,
+      hash,
       data[NODE_LEVEL],
       false
     );
-    this._cache.set(hash2, impl);
+    this._cache.set(hash, impl);
     return impl;
   }
   async get(key) {
@@ -3461,15 +3415,15 @@ var BTreeRead = class {
       () => this.rootHash,
       this.rootHash,
       fromKey,
-      async (hash2) => {
-        const cached = await this.getNode(hash2);
+      async (hash) => {
+        const cached = await this.getNode(hash);
         if (cached) {
           return [
             cached.level,
             cached.isMutable ? cached.entries.slice() : cached.entries
           ];
         }
-        const chunk = await this._dagRead.mustGetChunk(hash2);
+        const chunk = await this._dagRead.mustGetChunk(hash);
         return parseBTreeNode(
           chunk.data,
           this._formatVersion,
@@ -3593,11 +3547,11 @@ function* diffEntries(lastEntries, currentEntries) {
     };
   }
 }
-async function* scanForHash(expectedRootHash, getRootHash, hash2, fromKey, readNode) {
-  if (hash2 === emptyHash) {
+async function* scanForHash(expectedRootHash, getRootHash, hash, fromKey, readNode) {
+  if (hash === emptyHash) {
     return;
   }
-  const data = await readNode(hash2);
+  const data = await readNode(hash);
   const entries = data[NODE_ENTRIES];
   let i = 0;
   if (fromKey) {
@@ -4306,10 +4260,10 @@ var BTreeWrite = class extends BTreeRead {
     });
   }
 };
-function gatherNewChunks(hash2, newChunks, createChunk2, modified, formatVersion) {
-  const node = modified.get(hash2);
+function gatherNewChunks(hash, newChunks, createChunk2, modified, formatVersion) {
+  const node = modified.get(hash);
   if (node === void 0) {
-    return hash2;
+    return hash;
   }
   if (isDataNodeImpl(node)) {
     const chunk2 = createChunk2(toChunkData(node, formatVersion), []);
@@ -4984,16 +4938,16 @@ function clientGroupMapToChunkData(clientGroups, dagWrite) {
   }
   return deepFreeze(chunkData);
 }
-async function getClientGroupsAtHash(hash2, dagRead) {
-  const chunk = await dagRead.getChunk(hash2);
+async function getClientGroupsAtHash(hash, dagRead) {
+  const chunk = await dagRead.getChunk(hash);
   return chunkDataToClientGroupMap(chunk?.data);
 }
 async function getClientGroups(dagRead) {
-  const hash2 = await dagRead.getHead(CLIENT_GROUPS_HEAD_NAME);
-  if (!hash2) {
+  const hash = await dagRead.getHead(CLIENT_GROUPS_HEAD_NAME);
+  if (!hash) {
     return /* @__PURE__ */ new Map();
   }
-  return getClientGroupsAtHash(hash2, dagRead);
+  return getClientGroupsAtHash(hash, dagRead);
 }
 async function setClientGroups(clientGroups, dagWrite) {
   const currClientGroups = await getClientGroups(dagWrite);
@@ -5250,14 +5204,14 @@ function clientMapToChunkData(clients, dagWrite) {
   return deepFreeze(Object.fromEntries(clients));
 }
 async function getClients(dagRead) {
-  const hash2 = await dagRead.getHead(CLIENTS_HEAD_NAME);
-  return getClientsAtHash(hash2, dagRead);
+  const hash = await dagRead.getHead(CLIENTS_HEAD_NAME);
+  return getClientsAtHash(hash, dagRead);
 }
-async function getClientsAtHash(hash2, dagRead) {
-  if (!hash2) {
+async function getClientsAtHash(hash, dagRead) {
+  if (!hash) {
     return /* @__PURE__ */ new Map();
   }
-  const chunk = await dagRead.getChunk(hash2);
+  const chunk = await dagRead.getChunk(hash);
   return chunkDataToClientMap(chunk?.data);
 }
 var ClientStateNotFoundError = class extends Error {
@@ -5448,8 +5402,8 @@ function getRefsForClients(clients) {
   const refs = /* @__PURE__ */ new Set();
   for (const client of clients.values()) {
     if (isClientV6(client)) {
-      for (const hash2 of client.refreshHashes) {
-        refs.add(hash2);
+      for (const hash of client.refreshHashes) {
+        refs.add(hash);
       }
       if (client.persistHash) {
         refs.add(client.persistHash);
@@ -9227,12 +9181,156 @@ async function anyPendingMutationsInClientGroups(perdag) {
 // ../zql/src/zql/query/query-impl.ts
 import { resolver as resolver7 } from "@rocicorp/resolver";
 
-// ../shared/src/must.ts
-function must(v2, msg) {
-  if (v2 == null) {
-    throw new Error(msg ?? `Unexpected ${v2} value`);
+// ../shared/src/xxhash.ts
+import xxhash from "xxhash-wasm";
+var { create64, h32, h64 } = await xxhash();
+
+// ../zero-protocol/src/ast.ts
+import { compareUTF8 as compareUTF83 } from "compare-utf8";
+var selectorSchema = valita_exports.string();
+var orderingElementSchema = readonly(
+  valita_exports.tuple([selectorSchema, valita_exports.union(valita_exports.literal("asc"), valita_exports.literal("desc"))])
+);
+var orderingSchema = readonlyArray(orderingElementSchema);
+var primitiveSchema = valita_exports.union(
+  valita_exports.string(),
+  valita_exports.number(),
+  valita_exports.boolean(),
+  valita_exports.null()
+);
+var equalityOpsSchema = valita_exports.union(valita_exports.literal("="), valita_exports.literal("!="));
+var orderOpsSchema = valita_exports.union(
+  valita_exports.literal("<"),
+  valita_exports.literal(">"),
+  valita_exports.literal("<="),
+  valita_exports.literal(">=")
+);
+var likeOpsSchema = valita_exports.union(
+  valita_exports.literal("LIKE"),
+  valita_exports.literal("NOT LIKE"),
+  valita_exports.literal("ILIKE"),
+  valita_exports.literal("NOT ILIKE")
+);
+var inOpsSchema = valita_exports.union(valita_exports.literal("IN"), valita_exports.literal("NOT IN"));
+var simpleOperatorSchema = valita_exports.union(
+  equalityOpsSchema,
+  orderOpsSchema,
+  likeOpsSchema,
+  inOpsSchema
+);
+var simpleConditionSchema = valita_exports.object({
+  type: valita_exports.literal("simple"),
+  op: simpleOperatorSchema,
+  field: selectorSchema,
+  value: valita_exports.union(
+    valita_exports.string(),
+    valita_exports.number(),
+    valita_exports.boolean(),
+    readonlyArray(valita_exports.union(valita_exports.string(), valita_exports.number(), valita_exports.boolean())),
+    valita_exports.object({
+      type: valita_exports.literal("static"),
+      anchor: valita_exports.union(valita_exports.literal("authData"), valita_exports.literal("preMutationRow")),
+      field: valita_exports.string()
+    })
+  )
+});
+var conditionSchema = simpleConditionSchema;
+var correlatedSubquerySchemaOmitSubquery = valita_exports.object({
+  correlation: valita_exports.object({
+    parentField: valita_exports.string(),
+    childField: valita_exports.string(),
+    op: valita_exports.literal("=")
+  }),
+  hidden: valita_exports.boolean().optional()
+});
+var correlatedSubquerySchema = correlatedSubquerySchemaOmitSubquery.extend({
+  subquery: valita_exports.lazy(() => astSchema)
+});
+var astSchema = valita_exports.object({
+  schema: valita_exports.string().optional(),
+  table: valita_exports.string(),
+  alias: valita_exports.string().optional(),
+  where: readonlyArray(conditionSchema).optional(),
+  related: readonlyArray(correlatedSubquerySchema).optional(),
+  limit: valita_exports.number().optional(),
+  orderBy: orderingSchema.optional(),
+  start: valita_exports.object({
+    row: valita_exports.record(
+      valita_exports.union(valita_exports.string(), valita_exports.number(), valita_exports.boolean(), valita_exports.null(), valita_exports.undefined())
+    ),
+    exclusive: valita_exports.boolean()
+  }).optional()
+});
+var normalizeCache = /* @__PURE__ */ new WeakMap();
+function normalizeAST(ast) {
+  const cached = normalizeCache.get(ast);
+  if (cached) {
+    return cached;
+  }
+  const normalized = {
+    schema: ast.schema,
+    table: ast.table,
+    alias: ast.alias,
+    where: ast.where ? sortedWhere(ast.where) : void 0,
+    related: ast.related ? sortedRelated(
+      ast.related.map(
+        (r) => ({
+          correlation: {
+            parentField: r.correlation.parentField,
+            childField: r.correlation.childField,
+            op: r.correlation.op
+          },
+          hidden: r.hidden,
+          subquery: normalizeAST(r.subquery)
+        })
+      )
+    ) : void 0,
+    start: ast.start,
+    limit: ast.limit,
+    orderBy: ast.orderBy
+  };
+  normalizeCache.set(ast, normalized);
+  return normalized;
+}
+function sortedWhere(where) {
+  return [...where].sort(cmpCondition);
+}
+function sortedRelated(related) {
+  return related.sort(cmpRelated);
+}
+function cmpCondition(a, b) {
+  return compareUTF8MaybeNull(a.field, b.field) || compareUTF8MaybeNull(a.op, b.op) || // Comparing the same field with the same op more than once doesn't make logical
+  // sense, but is technically possible. Assume the values are of the same type and
+  // sort by their String forms.
+  compareUTF8MaybeNull(String(a.value), String(b.value));
+}
+function cmpRelated(a, b) {
+  return compareUTF83(must(a.subquery.alias), must(b.subquery.alias));
+}
+function compareUTF8MaybeNull(a, b) {
+  if (a !== null && b !== null) {
+    return compareUTF83(a, b);
+  }
+  if (b !== null) {
+    return -1;
+  }
+  if (a !== null) {
+    return 1;
+  }
+  return 0;
+}
+
+// ../zero-protocol/src/ast-hash.ts
+var hashCache = /* @__PURE__ */ new WeakMap();
+function hashOfAST(ast) {
+  const normalized = normalizeAST(ast);
+  const cached = hashCache.get(normalized);
+  if (cached) {
+    return cached;
   }
-  return v2;
+  const hash = h64(JSON.stringify(normalized)).toString(36);
+  hashCache.set(normalized, hash);
+  return hash;
 }
 
 // ../zql/src/zql/ivm/maybe-split-and-push-edit-change.ts
@@ -9315,7 +9413,7 @@ var Filter = class {
 };
 
 // ../zql/src/zql/ivm/data.ts
-import { compareUTF8 as compareUTF83 } from "compare-utf8";
+import { compareUTF8 as compareUTF84 } from "compare-utf8";
 function compareValues(a, b) {
   a = normalizeUndefined(a);
   b = normalizeUndefined(b);
@@ -9338,7 +9436,7 @@ function compareValues(a, b) {
   }
   if (typeof a === "string") {
     assertString(b);
-    return compareUTF83(a, b);
+    return compareUTF84(a, b);
   }
   throw new Error(`Unsupported type: ${a}`);
 }
@@ -10437,7 +10535,6 @@ var ArrayView = class {
     this.#format = format;
     this.#input.setOutput(this);
     this.#root = { "": format.singular ? void 0 : [] };
-    assertOrderingIncludesPK(this.#schema.sort, this.#schema.primaryKey);
     this.#hydrate();
   }
   get data() {
@@ -10457,7 +10554,6 @@ var ArrayView = class {
     }
   }
   destroy() {
-    this.#input.destroy();
     this.onDestroy?.();
   }
   #hydrate() {
@@ -10485,207 +10581,6 @@ var ArrayView = class {
     this.#fireListeners();
   }
 };
-function applyChange(parentEntry, change, schema, relationship, format) {
-  if (schema.isHidden) {
-    switch (change.type) {
-      case "add":
-      case "remove":
-        for (const [relationship2, children] of Object.entries(
-          change.node.relationships
-        )) {
-          const childSchema = must(schema.relationships[relationship2]);
-          for (const node of children) {
-            applyChange(
-              parentEntry,
-              { type: change.type, node },
-              childSchema,
-              relationship2,
-              format
-            );
-          }
-        }
-        return;
-      case "edit":
-        return;
-      case "child": {
-        const childSchema = must(
-          schema.relationships[change.child.relationshipName]
-        );
-        applyChange(
-          parentEntry,
-          change.child.change,
-          childSchema,
-          relationship,
-          format
-        );
-        return;
-      }
-      default:
-        unreachable(change);
-    }
-  }
-  const { singular, relationships: childFormats } = format;
-  switch (change.type) {
-    case "add": {
-      const newEntry = {
-        ...change.node.row
-      };
-      if (singular) {
-        assertUndefined(
-          parentEntry[relationship],
-          "single output already exists"
-        );
-        parentEntry[relationship] = newEntry;
-      } else {
-        const view = parentEntry[relationship];
-        assertArray(view);
-        const { pos, found } = binarySearch3(view, newEntry, schema.compareRows);
-        assert(!found, "node already exists");
-        view.splice(pos, 0, newEntry);
-      }
-      for (const [relationship2, children] of Object.entries(
-        change.node.relationships
-      )) {
-        const childSchema = must(schema.relationships[relationship2]);
-        const childFormat = must(childFormats[relationship2]);
-        const newView = childFormat.singular ? void 0 : [];
-        newEntry[relationship2] = newView;
-        for (const node of children) {
-          applyChange(
-            newEntry,
-            { type: "add", node },
-            childSchema,
-            relationship2,
-            childFormat
-          );
-        }
-      }
-      break;
-    }
-    case "remove": {
-      if (singular) {
-        assertObject(parentEntry[relationship]);
-        parentEntry[relationship] = void 0;
-      } else {
-        assertArray(parentEntry[relationship]);
-        const view = parentEntry[relationship];
-        const { pos, found } = binarySearch3(
-          view,
-          change.node.row,
-          schema.compareRows
-        );
-        assert(found, "node does not exist");
-        view.splice(pos, 1);
-      }
-      break;
-    }
-    case "child": {
-      let existing;
-      if (singular) {
-        assertObject(parentEntry[relationship]);
-        existing = parentEntry[relationship];
-      } else {
-        assertArray(parentEntry[relationship]);
-        const list = parentEntry[relationship];
-        const { pos, found } = binarySearch3(list, change.row, schema.compareRows);
-        assert(found, "node does not exist");
-        existing = list[pos];
-      }
-      const childSchema = must(
-        schema.relationships[change.child.relationshipName]
-      );
-      const childFormat = must(
-        format.relationships[change.child.relationshipName]
-      );
-      applyChange(
-        existing,
-        change.child.change,
-        childSchema,
-        change.child.relationshipName,
-        childFormat
-      );
-      break;
-    }
-    case "edit": {
-      if (singular) {
-        assertObject(parentEntry[relationship]);
-        parentEntry[relationship] = {
-          ...parentEntry[relationship],
-          ...change.row
-        };
-      } else {
-        assertArray(parentEntry[relationship]);
-        const view = parentEntry[relationship];
-        if (schema.compareRows(change.oldRow, change.row) === 0) {
-          const { pos, found } = binarySearch3(
-            view,
-            change.oldRow,
-            schema.compareRows
-          );
-          assert(found, "node does not exists");
-          view[pos] = makeEntryPreserveRelationships(
-            change.row,
-            view[pos],
-            schema.relationships
-          );
-        } else {
-          const { pos, found } = binarySearch3(
-            view,
-            change.oldRow,
-            schema.compareRows
-          );
-          assert(found, "node does not exists");
-          const oldEntry = view[pos];
-          view.splice(pos, 1);
-          {
-            const { pos: pos2, found: found2 } = binarySearch3(
-              view,
-              change.row,
-              schema.compareRows
-            );
-            assert(!found2, "node already exists");
-            view.splice(
-              pos2,
-              0,
-              makeEntryPreserveRelationships(
-                change.row,
-                oldEntry,
-                schema.relationships
-              )
-            );
-          }
-        }
-      }
-      break;
-    }
-    default:
-      unreachable(change);
-  }
-}
-function binarySearch3(view, target, comparator) {
-  let low = 0;
-  let high = view.length - 1;
-  while (low <= high) {
-    const mid = low + high >>> 1;
-    const comparison = comparator(view[mid], target);
-    if (comparison < 0) {
-      low = mid + 1;
-    } else if (comparison > 0) {
-      high = mid - 1;
-    } else {
-      return { pos: mid, found: true };
-    }
-  }
-  return { pos: low, found: false };
-}
-function makeEntryPreserveRelationships(row, entry, relationships) {
-  const result = { ...row };
-  for (const relationship in relationships) {
-    assert(!(relationship in row), "Relationship already exists");
-    result[relationship] = entry[relationship];
-  }
-  return result;
-}
 
 // ../shared/src/sorted-entries.ts
 function sortedEntries(object16) {
@@ -10856,15 +10751,22 @@ var AbstractQuery = class {
   #ast;
   #schema;
   #format;
+  #hash = "";
   constructor(schema, ast, format) {
-    this.#ast = ast ?? {
-      table: schema.tableName
-    };
+    this.#ast = ast;
     this.#format = format ?? { singular: false, relationships: {} };
     this.#schema = schema;
   }
-  get ast() {
-    return this.#ast;
+  get format() {
+    return this.#format;
+  }
+  hash() {
+    if (!this.#hash) {
+      const ast = this._completeAst();
+      const hash = hashOfAST(ast);
+      this.#hash = hash;
+    }
+    return this.#hash;
   }
   select(..._fields) {
     return this._newQuery(this.#schema, this.#ast, this.#format);
@@ -10911,7 +10813,7 @@ var AbstractQuery = class {
                 childField: related1.dest.field,
                 op: "="
               },
-              subquery: addPrimaryKeysToAst(destSchema, sq.ast)
+              subquery: addPrimaryKeysToAst(destSchema, sq.#ast)
             }
           ]
         },
@@ -10919,7 +10821,7 @@ var AbstractQuery = class {
           ...this.#format,
           relationships: {
             ...this.#format.relationships,
-            [relationship]: sq.format
+            [relationship]: sq.#format
           }
         }
       );
@@ -10961,7 +10863,7 @@ var AbstractQuery = class {
                       op: "="
                     },
                     hidden: true,
-                    subquery: addPrimaryKeysToAst(destSchema, sq.ast)
+                    subquery: addPrimaryKeysToAst(destSchema, sq.#ast)
                   }
                 ]
               }
@@ -10972,7 +10874,7 @@ var AbstractQuery = class {
           ...this.#format,
           relationships: {
             ...this.#format.relationships,
-            [relationship]: sq.format
+            [relationship]: sq.#format
           }
         }
       );
@@ -11043,42 +10945,46 @@ var AbstractQuery = class {
       this.#format
     );
   }
+  #completedAST;
   _completeAst() {
-    const finalOrderBy = addPrimaryKeys(this.#schema, this.#ast.orderBy);
-    if (this.#ast.start) {
-      const { row } = this.#ast.start;
-      const narrowedRow = {};
-      for (const [field] of finalOrderBy) {
-        narrowedRow[field] = row[field];
+    if (!this.#completedAST) {
+      const finalOrderBy = addPrimaryKeys(this.#schema, this.#ast.orderBy);
+      if (this.#ast.start) {
+        const { row } = this.#ast.start;
+        const narrowedRow = {};
+        for (const [field] of finalOrderBy) {
+          narrowedRow[field] = row[field];
+        }
+        this.#completedAST = {
+          ...this.#ast,
+          start: {
+            ...this.#ast.start,
+            row: narrowedRow
+          },
+          orderBy: finalOrderBy
+        };
+      } else {
+        this.#completedAST = {
+          ...this.#ast,
+          orderBy: addPrimaryKeys(this.#schema, this.#ast.orderBy)
+        };
       }
-      return {
-        ...this.#ast,
-        start: {
-          ...this.#ast.start,
-          row: narrowedRow
-        },
-        orderBy: finalOrderBy
-      };
     }
-    return {
-      ...this.#ast,
-      orderBy: addPrimaryKeys(this.#schema, this.#ast.orderBy)
-    };
+    return this.#completedAST;
   }
 };
+var astForTestingSymbol = Symbol();
 var QueryImpl = class extends AbstractQuery {
   #delegate;
-  #format;
-  constructor(delegate, schema, ast, format) {
+  #ast;
+  constructor(delegate, schema, ast = { table: schema.tableName }, format) {
     super(schema, ast, format);
-    this.#format = format ?? { singular: false, relationships: {} };
     this.#delegate = delegate;
+    this.#ast = ast;
   }
-  get format() {
-    return this.#format;
-  }
-  get singular() {
-    return this.#format.singular;
+  // Not part of Query or QueryInternal interface
+  get [astForTestingSymbol]() {
+    return this.#ast;
   }
   _newQuery(schema, ast, format) {
     return newQueryWithDetails(this.#delegate, schema, ast, format);
@@ -11089,13 +10995,14 @@ var QueryImpl = class extends AbstractQuery {
     const input = buildPipeline(ast, this.#delegate, void 0);
     let removeCommitObserver;
     const onDestroy = () => {
+      input.destroy();
       removeCommitObserver?.();
       removeServerQuery();
     };
-    const view = (factory ?? defaultMaterializeFactory)(
+    const view = (factory ?? arrayViewFactory)(
       this,
       input,
-      this.#format,
+      this.format,
       onDestroy,
       (cb) => {
         removeCommitObserver = this.#delegate.onTransactionCommit(cb);
@@ -11138,7 +11045,7 @@ function addPrimaryKeysToAst(schema, ast) {
     orderBy: addPrimaryKeys(schema, ast.orderBy)
   };
 }
-function defaultMaterializeFactory(_query, input, format, onDestroy, onTransactionCommit) {
+function arrayViewFactory(_query, input, format, onDestroy, onTransactionCommit) {
   const v2 = new ArrayView(input, format);
   v2.onDestroy = onDestroy;
   onTransactionCommit(() => {
@@ -11156,134 +11063,6 @@ function escapeLike(val) {
 import { LogContext as LogContext3 } from "@rocicorp/logger";
 import { resolver as resolver8 } from "@rocicorp/resolver";
 
-// ../zero-protocol/src/ast.ts
-import { compareUTF8 as compareUTF84 } from "compare-utf8";
-var selectorSchema = valita_exports.string();
-var orderingElementSchema = readonly(
-  valita_exports.tuple([selectorSchema, valita_exports.union(valita_exports.literal("asc"), valita_exports.literal("desc"))])
-);
-var orderingSchema = readonlyArray(orderingElementSchema);
-var primitiveSchema = valita_exports.union(
-  valita_exports.string(),
-  valita_exports.number(),
-  valita_exports.boolean(),
-  valita_exports.null()
-);
-var equalityOpsSchema = valita_exports.union(valita_exports.literal("="), valita_exports.literal("!="));
-var orderOpsSchema = valita_exports.union(
-  valita_exports.literal("<"),
-  valita_exports.literal(">"),
-  valita_exports.literal("<="),
-  valita_exports.literal(">=")
-);
-var likeOpsSchema = valita_exports.union(
-  valita_exports.literal("LIKE"),
-  valita_exports.literal("NOT LIKE"),
-  valita_exports.literal("ILIKE"),
-  valita_exports.literal("NOT ILIKE")
-);
-var inOpsSchema = valita_exports.union(valita_exports.literal("IN"), valita_exports.literal("NOT IN"));
-var simpleOperatorSchema = valita_exports.union(
-  equalityOpsSchema,
-  orderOpsSchema,
-  likeOpsSchema,
-  inOpsSchema
-);
-var simpleConditionSchema = valita_exports.object({
-  type: valita_exports.literal("simple"),
-  op: simpleOperatorSchema,
-  field: selectorSchema,
-  value: valita_exports.union(
-    valita_exports.string(),
-    valita_exports.number(),
-    valita_exports.boolean(),
-    readonlyArray(valita_exports.union(valita_exports.string(), valita_exports.number(), valita_exports.boolean())),
-    valita_exports.object({
-      type: valita_exports.literal("static"),
-      anchor: valita_exports.union(valita_exports.literal("authData"), valita_exports.literal("preMutationRow")),
-      field: valita_exports.string()
-    })
-  )
-});
-var conditionSchema = simpleConditionSchema;
-var correlatedSubquerySchemaOmitSubquery = valita_exports.object({
-  correlation: valita_exports.object({
-    parentField: valita_exports.string(),
-    childField: valita_exports.string(),
-    op: valita_exports.literal("=")
-  }),
-  hidden: valita_exports.boolean().optional()
-});
-var correlatedSubquerySchema = correlatedSubquerySchemaOmitSubquery.extend({
-  subquery: valita_exports.lazy(() => astSchema)
-});
-var astSchema = valita_exports.object({
-  schema: valita_exports.string().optional(),
-  table: valita_exports.string(),
-  alias: valita_exports.string().optional(),
-  where: readonlyArray(conditionSchema).optional(),
-  related: readonlyArray(correlatedSubquerySchema).optional(),
-  limit: valita_exports.number().optional(),
-  orderBy: orderingSchema.optional(),
-  start: valita_exports.object({
-    row: valita_exports.record(
-      valita_exports.union(valita_exports.string(), valita_exports.number(), valita_exports.boolean(), valita_exports.null(), valita_exports.undefined())
-    ),
-    exclusive: valita_exports.boolean()
-  }).optional()
-});
-function normalizeAST(ast) {
-  return {
-    schema: ast.schema,
-    table: ast.table,
-    alias: ast.alias,
-    where: ast.where ? sortedWhere(ast.where) : void 0,
-    related: ast.related ? sortedRelated(
-      ast.related.map(
-        (r) => ({
-          correlation: {
-            parentField: r.correlation.parentField,
-            childField: r.correlation.childField,
-            op: r.correlation.op
-          },
-          hidden: r.hidden,
-          subquery: normalizeAST(r.subquery)
-        })
-      )
-    ) : void 0,
-    start: ast.start,
-    limit: ast.limit,
-    orderBy: ast.orderBy
-  };
-}
-function sortedWhere(where) {
-  return [...where].sort(cmpCondition);
-}
-function sortedRelated(related) {
-  return related.sort(cmpRelated);
-}
-function cmpCondition(a, b) {
-  return compareUTF8MaybeNull(a.field, b.field) || compareUTF8MaybeNull(a.op, b.op) || // Comparing the same field with the same op more than once doesn't make logical
-  // sense, but is technically possible. Assume the values are of the same type and
-  // sort by their String forms.
-  compareUTF8MaybeNull(String(a.value), String(b.value));
-}
-function cmpRelated(a, b) {
-  return compareUTF84(must(a.subquery.alias), must(b.subquery.alias));
-}
-function compareUTF8MaybeNull(a, b) {
-  if (a !== null && b !== null) {
-    return compareUTF84(a, b);
-  }
-  if (b !== null) {
-    return -1;
-  }
-  if (a !== null) {
-    return 1;
-  }
-  return 0;
-}
-
 // ../zero-protocol/src/queries-patch.ts
 var putOpSchema = valita_exports.object({
   op: valita_exports.literal("put"),
@@ -13743,10 +13522,6 @@ function reverseString(str) {
   return reversed;
 }
 
-// ../shared/src/xxhash.ts
-import xxhash from "xxhash-wasm";
-var { create64, h32, h64 } = await xxhash();
-
 // ../shared/src/h64-with-reverse.ts
 function h64WithReverse(str) {
   const forward = h64(str);
@@ -13763,14 +13538,14 @@ var ENTITIES_KEY_PREFIX = "e/";
 function toClientsKey(clientID) {
   return CLIENTS_KEY_PREFIX + clientID;
 }
-function toDesiredQueriesKey(clientID, hash2) {
-  return DESIRED_QUERIES_KEY_PREFIX + clientID + "/" + hash2;
+function toDesiredQueriesKey(clientID, hash) {
+  return DESIRED_QUERIES_KEY_PREFIX + clientID + "/" + hash;
 }
 function desiredQueriesPrefixForClient(clientID) {
   return DESIRED_QUERIES_KEY_PREFIX + clientID + "/";
 }
-function toGotQueriesKey(hash2) {
-  return GOT_QUERIES_KEY_PREFIX + hash2;
+function toGotQueriesKey(hash) {
+  return GOT_QUERIES_KEY_PREFIX + hash;
 }
 function toPrimaryKeyString(tableName, primaryKey, value) {
   if (primaryKey.length === 1) {
@@ -14300,7 +14075,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.0.0";
+var version2 = "0.3.2024102800+3110cf";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -14669,26 +14444,26 @@ var QueryManager = class {
       existingQueryHashes.add(key.substring(prefix.length, key.length));
     }
     const patch = /* @__PURE__ */ new Map();
-    for (const hash2 of existingQueryHashes) {
-      if (!this.#queries.has(hash2)) {
-        patch.set(hash2, { op: "del", hash: hash2 });
+    for (const hash of existingQueryHashes) {
+      if (!this.#queries.has(hash)) {
+        patch.set(hash, { op: "del", hash });
       }
     }
-    for (const [hash2, { normalized }] of this.#queries) {
-      if (!existingQueryHashes.has(hash2)) {
-        patch.set(hash2, { op: "put", hash: hash2, ast: normalized });
+    for (const [hash, { normalized }] of this.#queries) {
+      if (!existingQueryHashes.has(hash)) {
+        patch.set(hash, { op: "put", hash, ast: normalized });
       }
     }
     if (lastPatch) {
-      for (const [hash2, { op }] of lastPatch) {
-        if (op === "put" && !patch.has(hash2)) {
-          patch.set(hash2, { op: "del", hash: hash2 });
+      for (const [hash, { op }] of lastPatch) {
+        if (op === "put" && !patch.has(hash)) {
+          patch.set(hash, { op: "del", hash });
         }
       }
-      for (const [hash2, { op }] of patch) {
-        const lastPatchOp = lastPatch.get(hash2);
+      for (const [hash, { op }] of patch) {
+        const lastPatchOp = lastPatch.get(hash);
         if (lastPatchOp && lastPatchOp.op === op) {
-          patch.delete(hash2);
+          patch.delete(hash);
         }
       }
     }
@@ -14696,7 +14471,7 @@ var QueryManager = class {
   }
   add(ast, gotCallback) {
     const normalized = normalizeAST(ast);
-    const astHash = hash(normalized);
+    const astHash = hashOfAST(normalized);
     let entry = this.#queries.get(astHash);
     if (!entry) {
       entry = {
@@ -14746,9 +14521,6 @@ var QueryManager = class {
     return true;
   }
 };
-function hash(normalized) {
-  return h64(JSON.stringify(normalized)).toString(36);
-}
 
 // ../zero-client/src/client/reload-error-handler.ts
 var RELOAD_REASON_STORAGE_KEY = "_zeroReloadReason";
@@ -15000,7 +14772,7 @@ function mergePokes(pokeBuffer, schema) {
             ...queriesPatch.map(
               (op) => queryPatchOpToReplicachePatchOp(
                 op,
-                (hash2) => toDesiredQueriesKey(clientID, hash2)
+                (hash) => toDesiredQueriesKey(clientID, hash)
               )
             )
           );