@rocicorp/zero 0.14.2025021101 → 0.14.2025021202

package/out/{chunk-5GWP7BBD.js → chunk-JMAJNHHI.js}

@@ -397,8 +397,6 @@ var promiseTrue = Promise.resolve(true);
 var promiseFalse = Promise.resolve(false);
 var promiseUndefined = Promise.resolve(void 0);
 var promiseVoid = Promise.resolve();
-var promiseNever = new Promise(() => {
-});
 
 // ../replicache/src/frozen-json.ts
 var deepFrozenObjects = /* @__PURE__ */ new WeakSet();
@@ -725,7 +723,7 @@ var AbortError = class extends Error {
 // ../shared/src/sleep.ts
 import { resolver as resolver2 } from "@rocicorp/resolver";
 var promiseVoid2 = Promise.resolve();
-var promiseNever2 = new Promise(() => void 0);
+var promiseNever = new Promise(() => void 0);
 function sleep(ms, signal) {
   const newAbortError = () => new AbortError("Aborted");
   if (signal?.aborted) {
@@ -751,7 +749,7 @@ function sleep(ms, signal) {
 }
 function sleepWithAbort(ms, signal) {
   if (ms === 0) {
-    return [promiseVoid2, promiseNever2];
+    return [promiseVoid2, promiseNever];
   }
   const { promise: abortedPromise, resolve: abortedResolve } = resolver2();
   const sleepPromise = new Promise((resolve) => {
@@ -1418,53 +1416,6 @@ var WriteImpl2 = class extends ReadImpl2 {
   }
 };
 
-// ../replicache/src/deleted-clients.ts
-var DELETED_CLIENTS_HEAD_NAME = "deleted-clients";
-var deletedClientsSchema = readonlyObject({
-  clientIDs: readonlyArray(valita_exports.string()),
-  clientGroupIDs: readonlyArray(valita_exports.string())
-});
-async function setDeletedClients(dagWrite, clientIDs, clientGroupIDs) {
-  const data = {
-    clientIDs: normalize(clientIDs),
-    clientGroupIDs: normalize(clientGroupIDs)
-  };
-  const chunkData = deepFreeze(data);
-  const chunk = dagWrite.createChunk(chunkData, []);
-  await dagWrite.putChunk(chunk);
-  await dagWrite.setHead(DELETED_CLIENTS_HEAD_NAME, chunk.hash);
-  return data;
-}
-async function getDeletedClients(dagRead) {
-  const hash2 = await dagRead.getHead(DELETED_CLIENTS_HEAD_NAME);
-  if (hash2 === void 0) {
-    return { clientIDs: [], clientGroupIDs: [] };
-  }
-  const chunk = await dagRead.mustGetChunk(hash2);
-  return parse(chunk.data, deletedClientsSchema);
-}
-async function addDeletedClients(dagWrite, clientIDs, clientGroupIDs) {
-  const { clientIDs: oldClientIDs, clientGroupIDs: oldClientGroupIDs } = await getDeletedClients(dagWrite);
-  return setDeletedClients(
-    dagWrite,
-    [...oldClientIDs, ...clientIDs],
-    [...oldClientGroupIDs, ...clientGroupIDs]
-  );
-}
-async function removeDeletedClients(dagWrite, clientIDs, clientGroupIDs) {
-  const { clientIDs: oldClientIDs, clientGroupIDs: oldClientGroupIDs } = await getDeletedClients(dagWrite);
-  const newDeletedClients = oldClientIDs.filter(
-    (clientID) => !clientIDs.includes(clientID)
-  );
-  const newDeletedClientGroups = oldClientGroupIDs.filter(
-    (clientGroupID) => !clientGroupIDs.includes(clientGroupID)
-  );
-  return setDeletedClients(dagWrite, newDeletedClients, newDeletedClientGroups);
-}
-function normalize(arr) {
-  return [...new Set(arr)].sort();
-}
-
 // ../replicache/src/format-version-enum.ts
 var DD31 = 5;
 var V6 = 6;
@@ -5785,7 +5736,7 @@ async function mustGetClient(id, dagRead) {
   return client;
 }
 function initClientV6(newClientID, lc, perdag, mutatorNames, indexes, formatVersion, enableClientGroupForking) {
-  return withWrite(perdag, async (dagWrite) => {
+  return withWriteNoImplicitCommit(perdag, async (dagWrite) => {
     async function setClientsAndClientGroupAndCommit(basisHash, cookieJSON, valueHash2, indexRecords2) {
       const newSnapshotData = newSnapshotCommitDataDD31(
         basisHash,
@@ -5819,6 +5770,7 @@ function initClientV6(newClientID, lc, perdag, mutatorNames, indexes, formatVers
         setClients(newClients, dagWrite),
         setClientGroup(newClientGroupID, clientGroup, dagWrite)
       ]);
+      await dagWrite.commit();
       return [newClient, chunk.hash, newClients, true];
     }
     const clients = await getClients(dagWrite);
@@ -5833,6 +5785,7 @@ function initClientV6(newClientID, lc, perdag, mutatorNames, indexes, formatVers
       };
       const newClients = new Map(clients).set(newClientID, newClient);
       await setClients(newClients, dagWrite);
+      await dagWrite.commit();
       return [newClient, headHash, newClients, false];
     }
     if (!enableClientGroupForking || res.type === FIND_MATCHING_CLIENT_TYPE_NEW) {
@@ -6020,13 +5973,7 @@ function gcClients(clientID, dagStore, clientMaxInactiveTime, onClientsDeleted)
       return clients;
     }
     await setClients(newClients, dagWrite);
-    const { clientIDs, clientGroupIDs } = await addDeletedClients(
-      dagWrite,
-      deletedClients,
-      // gcClients does not delete client groups
-      []
-    );
-    onClientsDeleted(clientIDs, clientGroupIDs);
+    onClientsDeleted(deletedClients);
     return newClients;
   });
 }
@@ -6034,15 +5981,11 @@ function gcClients(clientID, dagStore, clientMaxInactiveTime, onClientsDeleted)
 // ../replicache/src/persist/client-group-gc.ts
 var GC_INTERVAL_MS = 5 * 60 * 1e3;
 var latestGCUpdate2;
-function initClientGroupGC(dagStore, enableMutationRecovery, onClientsDeleted, lc, signal) {
+function initClientGroupGC(dagStore, lc, signal) {
   initBgIntervalProcess(
     "ClientGroupGC",
     () => {
-      latestGCUpdate2 = gcClientGroups(
-        dagStore,
-        enableMutationRecovery,
-        onClientsDeleted
-      );
+      latestGCUpdate2 = gcClientGroups(dagStore);
       return latestGCUpdate2;
     },
     () => GC_INTERVAL_MS,
@@ -6050,24 +5993,21 @@ function initClientGroupGC(dagStore, enableMutationRecovery, onClientsDeleted, l
     signal
   );
 }
-function gcClientGroups(dagStore, enableMutationRecovery, onClientsDeleted) {
+function gcClientGroups(dagStore) {
   return withWrite(dagStore, async (tx) => {
     const clients = await getClients(tx);
     const clientGroupIDs = /* @__PURE__ */ new Set();
     for (const client of clients.values()) {
+      assertClientV6(client);
       clientGroupIDs.add(client.clientGroupID);
     }
     const clientGroups = /* @__PURE__ */ new Map();
-    const removeClientGroups = /* @__PURE__ */ new Set();
     for (const [clientGroupID, clientGroup] of await getClientGroups(tx)) {
-      if (clientGroupIDs.has(clientGroupID) || enableMutationRecovery && clientGroupHasPendingMutations(clientGroup)) {
+      if (clientGroupIDs.has(clientGroupID) || clientGroupHasPendingMutations(clientGroup)) {
         clientGroups.set(clientGroupID, clientGroup);
-      } else {
-        removeClientGroups.add(clientGroupID);
       }
     }
     await setClientGroups(clientGroups, tx);
-    onClientsDeleted([], [...removeClientGroups].sort());
     return clientGroups;
   });
 }
@@ -7304,7 +7244,8 @@ var ReplicacheImpl = class {
       enableScheduledRefresh = true,
       enablePullAndPushInOpen = true,
       enableClientGroupForking = true,
-      onClientsDeleted = () => {
+      onClientsDeleted = (clientIDs) => {
+        this.#lc.info?.("ClientIDs deleted", clientIDs);
       }
     } = implOptions;
     this.auth = auth ?? "";
@@ -7448,13 +7389,7 @@ var ReplicacheImpl = class {
       this.#lc,
       signal
     );
-    initClientGroupGC(
-      this.perdag,
-      enableMutationRecovery,
-      onClientsDeleted,
-      this.#lc,
-      signal
-    );
+    initClientGroupGC(this.perdag, this.#lc, signal);
     initNewClientChannel(
       this.name,
       this.idbName,
@@ -8316,19 +8251,11 @@ async function collectIDBDatabases(idbDatabasesStore, now, maxAge, kvDropStore,
     )
   );
   const dbNamesToRemove = [];
-  const dbNamesToKeep = [];
   const clientIDsToRemove = [];
-  const clientGroupIDsToRemove = [];
-  for (const [
-    dbName,
-    [canCollect, clientIDs, clientGroupIDs]
-  ] of collectResults) {
+  for (const [dbName, [canCollect, clientIDs]] of collectResults) {
     if (canCollect) {
       dbNamesToRemove.push(dbName);
       clientIDsToRemove.push(...clientIDs);
-      clientGroupIDsToRemove.push(...clientGroupIDs);
-    } else {
-      dbNamesToKeep.push(dbName);
     }
   }
   const { errors } = await dropDatabases(
@@ -8339,24 +8266,8 @@ async function collectIDBDatabases(idbDatabasesStore, now, maxAge, kvDropStore,
   if (errors.length) {
     throw errors[0];
   }
-  if (clientIDsToRemove.length || clientGroupIDsToRemove.length) {
-    const newClientIDsToRemove = clientIDsToRemove;
-    const newClientGroupIDsToRemove = clientGroupIDsToRemove;
-    for (const name of dbNamesToKeep) {
-      await withWrite(newDagStore(name), async (dagWrite) => {
-        const { clientIDs, clientGroupIDs } = await addDeletedClients(
-          dagWrite,
-          clientIDsToRemove,
-          clientGroupIDsToRemove
-        );
-        newClientIDsToRemove.push(...clientIDs);
-        newClientGroupIDsToRemove.push(...clientGroupIDs);
-      });
-    }
-    onClientsDeleted(
-      normalize(newClientIDsToRemove),
-      normalize(newClientGroupIDsToRemove)
-    );
+  if (clientIDsToRemove.length) {
+    onClientsDeleted(clientIDsToRemove);
   }
 }
 async function dropDatabaseInternal(name, idbDatabasesStore, kvDropStore) {
@@ -8434,14 +8345,7 @@ function canDatabaseBeCollectedAndGetDeletedClientIDs(enableMutationRecovery, pe
       }
     }
     const clients = await getClients(read);
-    const { clientIDs, clientGroupIDs } = await getDeletedClients(read);
-    const newClientIDs = [...clientIDs];
-    const newClientGroupIDs = [...clientGroupIDs];
-    for (const [clientID, client] of clients) {
-      newClientIDs.push(clientID);
-      newClientGroupIDs.push(client.clientGroupID);
-    }
-    return [true, newClientIDs, newClientGroupIDs];
+    return [true, [...clients.keys()]];
   });
 }
 
@@ -8470,6 +8374,87 @@ function one(...args) {
   }));
 }
 
+// ../zero-schema/src/name-mapper.ts
+function clientToServer(tables) {
+  return createMapperFrom("client", tables);
+}
+function serverToClient(tables) {
+  return createMapperFrom("server", tables);
+}
+function createMapperFrom(src, tables) {
+  const mapping = new Map(
+    Object.entries(tables).map(
+      ([tableName, { serverName: serverTableName, columns }]) => {
+        let allColumnsSame = true;
+        const names = {};
+        for (const [name, { serverName }] of Object.entries(columns)) {
+          if (serverName && serverName !== name) {
+            allColumnsSame = false;
+          }
+          if (src === "client") {
+            names[name] = serverName ?? name;
+          } else {
+            names[serverName ?? name] = name;
+          }
+        }
+        return [
+          src === "client" ? tableName : serverTableName ?? tableName,
+          {
+            tableName: src === "client" ? serverTableName ?? tableName : tableName,
+            columns: names,
+            allColumnsSame
+          }
+        ];
+      }
+    )
+  );
+  return new NameMapper(mapping);
+}
+var NameMapper = class {
+  #tables = /* @__PURE__ */ new Map();
+  constructor(tables) {
+    this.#tables = tables;
+  }
+  #getTable(src, ctx) {
+    const table2 = this.#tables.get(src);
+    if (!table2) {
+      throw new Error(
+        `unknown table "${src}" ${!ctx ? "" : `in ${JSON.stringify(ctx)}`}`
+      );
+    }
+    return table2;
+  }
+  tableName(src, context) {
+    return this.#getTable(src, context).tableName;
+  }
+  columnName(table2, src, ctx) {
+    const dst = this.#getTable(table2, ctx).columns[src];
+    if (!dst) {
+      throw new Error(
+        `unknown column "${src}" of "${table2}" table ${!ctx ? "" : `in ${JSON.stringify(ctx)}`}`
+      );
+    }
+    return dst;
+  }
+  row(table2, row) {
+    const dest = this.#getTable(table2);
+    const { allColumnsSame, columns } = dest;
+    if (allColumnsSame) {
+      return row;
+    }
+    const clientRow = {};
+    for (const col in row) {
+      clientRow[columns[col] ?? col] = row[col];
+    }
+    return clientRow;
+  }
+  columns(table2, cols) {
+    const dest = this.#getTable(table2);
+    const { allColumnsSame, columns } = dest;
+    return cols === void 0 || allColumnsSame ? cols : cols.map((col) => columns[col] ?? col);
+  }
+};
+
 // ../zero-schema/src/builder/table-builder.ts
 function table(name) {
   return new TableBuilder({
@@ -8478,7 +8463,7 @@ function table(name) {
     primaryKey: []
   });
 }
-function string8() {
+function string7() {
   return new ColumnBuilder({
     type: "string",
     optional: false,
@@ -8986,122 +8971,267 @@ function compareUTF8MaybeNull(a, b) {
   return 0;
 }
 
-// ../zero-protocol/src/protocol-version.ts
-var PROTOCOL_VERSION = 5;
-var MIN_SERVER_SUPPORTED_SYNC_PROTOCOL = 2;
-assert(MIN_SERVER_SUPPORTED_SYNC_PROTOCOL < PROTOCOL_VERSION);
-var MIN_SERVER_SUPPORTED_PERMISSIONS_PROTOCOL = 4;
-assert(MIN_SERVER_SUPPORTED_PERMISSIONS_PROTOCOL < PROTOCOL_VERSION);
-
-// ../zql/src/query/query-impl.ts
-import { resolver as resolver7 } from "@rocicorp/resolver";
-
-// ../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-hash.ts
-var hashCache = /* @__PURE__ */ new WeakMap();
-function hashOfAST(ast) {
-  const normalized = normalizeAST(ast);
-  const cached = hashCache.get(normalized);
-  if (cached) {
-    return cached;
+// ../zql/src/query/expression.ts
+var ExpressionBuilder = class {
+  #exists;
+  constructor(exists) {
+    this.#exists = exists;
+    this.exists = this.exists.bind(this);
   }
-  const hash2 = h64(JSON.stringify(normalized)).toString(36);
-  hashCache.set(normalized, hash2);
-  return hash2;
-}
-
-// ../zero-schema/src/table-schema.ts
-function isOneHop(r) {
-  return r.length === 1;
-}
-function isTwoHop(r) {
-  return r.length === 2;
-}
-
-// ../zql/src/ivm/operator.ts
-var throwOutput = {
-  push(_change) {
-    throw new Error("Output not set");
+  get eb() {
+    return this;
   }
-};
-
-// ../zql/src/ivm/stream.ts
-function* take(stream, limit) {
-  if (limit < 1) {
-    return;
+  cmp(field, opOrValue, value) {
+    return cmp(field, opOrValue, value);
   }
-  let count = 0;
-  for (const v2 of stream) {
-    yield v2;
-    if (++count === limit) {
-      break;
-    }
+  cmpLit(left, op, right) {
+    return {
+      type: "simple",
+      left: isParameterReference(left) ? left[toStaticParam]() : { type: "literal", value: left },
+      right: isParameterReference(right) ? right[toStaticParam]() : { type: "literal", value: right },
+      op
+    };
   }
-}
-function first(stream) {
-  const it = stream[Symbol.iterator]();
-  const { value } = it.next();
-  it.return?.();
-  return value;
-}
-
-// ../zql/src/ivm/exists.ts
-var Exists = class {
-  #input;
-  #relationshipName;
-  #storage;
-  #not;
-  #parentJoinKey;
-  #skipCache;
-  #output = throwOutput;
-  constructor(input, storage, relationshipName, parentJoinKey, type) {
-    this.#input = input;
-    this.#relationshipName = relationshipName;
-    this.#input.setOutput(this);
-    this.#storage = storage;
-    assert(this.#input.getSchema().relationships[relationshipName]);
-    this.#not = type === "NOT EXISTS";
-    this.#parentJoinKey = parentJoinKey;
-    this.#skipCache = areEqual(
-      parentJoinKey,
-      this.#input.getSchema().primaryKey
-    );
+  and = and;
+  or = or;
+  not = not;
+  exists(relationship, cb) {
+    return this.#exists(relationship, cb);
   }
-  setOutput(output) {
-    this.#output = output;
+};
+function and(...conditions) {
+  const expressions = filterTrue(filterUndefined(conditions));
+  if (expressions.length === 1) {
+    return expressions[0];
   }
-  destroy() {
-    this.#input.destroy();
+  if (expressions.some(isAlwaysFalse)) {
+    return FALSE;
   }
-  getSchema() {
-    return this.#input.getSchema();
+  return { type: "and", conditions: expressions };
+}
+function or(...conditions) {
+  const expressions = filterFalse(filterUndefined(conditions));
+  if (expressions.length === 1) {
+    return expressions[0];
   }
-  *fetch(req) {
-    for (const node of this.#input.fetch(req)) {
-      if (this.#filter(node)) {
-        yield node;
-      }
-    }
+  if (expressions.some(isAlwaysTrue)) {
+    return TRUE;
   }
-  *cleanup(req) {
-    for (const node of this.#input.cleanup(req)) {
-      if (this.#filter(node)) {
-        yield node;
-      } else {
-        drainStreams(node);
-      }
-      this.#delSize(node);
+  return { type: "or", conditions: expressions };
+}
+function not(expression) {
+  switch (expression.type) {
+    case "and":
+      return {
+        type: "or",
+        conditions: expression.conditions.map(not)
+      };
+    case "or":
+      return {
+        type: "and",
+        conditions: expression.conditions.map(not)
+      };
+    case "correlatedSubquery":
+      return {
+        type: "correlatedSubquery",
+        related: expression.related,
+        op: negateOperator(expression.op)
+      };
+    case "simple":
+      return {
+        type: "simple",
+        op: negateOperator(expression.op),
+        left: expression.left,
+        right: expression.right
+      };
+  }
+}
+function cmp(field, opOrValue, value) {
+  let op;
+  if (value === void 0) {
+    value = opOrValue;
+    op = "=";
+  } else {
+    op = opOrValue;
+  }
+  return {
+    type: "simple",
+    left: { type: "column", name: field },
+    right: isParameterReference(value) ? value[toStaticParam]() : { type: "literal", value },
+    op
+  };
+}
+function isParameterReference(value) {
+  return value !== null && typeof value === "object" && value[toStaticParam];
+}
+var TRUE = {
+  type: "and",
+  conditions: []
+};
+var FALSE = {
+  type: "or",
+  conditions: []
+};
+function isAlwaysTrue(condition) {
+  return condition.type === "and" && condition.conditions.length === 0;
+}
+function isAlwaysFalse(condition) {
+  return condition.type === "or" && condition.conditions.length === 0;
+}
+function flatten(type, conditions) {
+  const flattened2 = [];
+  for (const c of conditions) {
+    if (c.type === type) {
+      flattened2.push(...c.conditions);
+    } else {
+      flattened2.push(c);
+    }
+  }
+  return flattened2;
+}
+var negateSimpleOperatorMap = {
+  ["="]: "!=",
+  ["!="]: "=",
+  ["<"]: ">=",
+  [">"]: "<=",
+  [">="]: "<",
+  ["<="]: ">",
+  ["IN"]: "NOT IN",
+  ["NOT IN"]: "IN",
+  ["LIKE"]: "NOT LIKE",
+  ["NOT LIKE"]: "LIKE",
+  ["ILIKE"]: "NOT ILIKE",
+  ["NOT ILIKE"]: "ILIKE",
+  ["IS"]: "IS NOT",
+  ["IS NOT"]: "IS"
+};
+var negateOperatorMap = {
+  ...negateSimpleOperatorMap,
+  ["EXISTS"]: "NOT EXISTS",
+  ["NOT EXISTS"]: "EXISTS"
+};
+function negateOperator(op) {
+  return must(negateOperatorMap[op]);
+}
+function filterUndefined(array9) {
+  return array9.filter((e) => e !== void 0);
+}
+function filterTrue(conditions) {
+  return conditions.filter((c) => !isAlwaysTrue(c));
+}
+function filterFalse(conditions) {
+  return conditions.filter((c) => !isAlwaysFalse(c));
+}
+
+// ../zql/src/query/query-impl.ts
+import { resolver as resolver7 } from "@rocicorp/resolver";
+
+// ../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-hash.ts
+var hashCache = /* @__PURE__ */ new WeakMap();
+function hashOfAST(ast) {
+  const normalized = normalizeAST(ast);
+  const cached = hashCache.get(normalized);
+  if (cached) {
+    return cached;
+  }
+  const hash2 = h64(JSON.stringify(normalized)).toString(36);
+  hashCache.set(normalized, hash2);
+  return hash2;
+}
+
+// ../zero-schema/src/table-schema.ts
+function isOneHop(r) {
+  return r.length === 1;
+}
+function isTwoHop(r) {
+  return r.length === 2;
+}
+
+// ../zql/src/ivm/operator.ts
+var throwOutput = {
+  push(_change) {
+    throw new Error("Output not set");
+  }
+};
+
+// ../zql/src/ivm/stream.ts
+function* take(stream, limit) {
+  if (limit < 1) {
+    return;
+  }
+  let count = 0;
+  for (const v2 of stream) {
+    yield v2;
+    if (++count === limit) {
+      break;
+    }
+  }
+}
+function first(stream) {
+  const it = stream[Symbol.iterator]();
+  const { value } = it.next();
+  it.return?.();
+  return value;
+}
+
+// ../zql/src/ivm/exists.ts
+var Exists = class {
+  #input;
+  #relationshipName;
+  #storage;
+  #not;
+  #parentJoinKey;
+  #skipCache;
+  #output = throwOutput;
+  constructor(input, storage, relationshipName, parentJoinKey, type) {
+    this.#input = input;
+    this.#relationshipName = relationshipName;
+    this.#input.setOutput(this);
+    this.#storage = storage;
+    assert(this.#input.getSchema().relationships[relationshipName]);
+    this.#not = type === "NOT EXISTS";
+    this.#parentJoinKey = parentJoinKey;
+    this.#skipCache = areEqual(
+      parentJoinKey,
+      this.#input.getSchema().primaryKey
+    );
+  }
+  setOutput(output) {
+    this.#output = output;
+  }
+  destroy() {
+    this.#input.destroy();
+  }
+  getSchema() {
+    return this.#input.getSchema();
+  }
+  *fetch(req) {
+    for (const node of this.#input.fetch(req)) {
+      if (this.#filter(node)) {
+        yield node;
+      }
+    }
+  }
+  *cleanup(req) {
+    for (const node of this.#input.cleanup(req)) {
+      if (this.#filter(node)) {
+        yield node;
+      } else {
+        drainStreams(node);
+      }
+      this.#delSize(node);
     }
   }
   push(change) {
@@ -9489,11 +9619,11 @@ var Join = class {
     const childSchema = child.getSchema();
     this.#schema = {
       ...parentSchema,
+      isHidden: hidden,
       relationships: {
         ...parentSchema.relationships,
         [relationshipName]: {
           ...childSchema,
-          isHidden: hidden,
           system
         }
       }
@@ -9556,15 +9686,7 @@ var Join = class {
         });
         break;
       case "child":
-        this.#output.push({
-          type: "child",
-          node: this.#processParentNode(
-            change.node.row,
-            change.node.relationships,
-            "fetch"
-          ),
-          child: change.child
-        });
+        this.#output.push(change);
         break;
       case "edit": {
         if (rowEqualsForCompoundKey(
@@ -10442,11 +10564,11 @@ function createPredicateImpl(rhs, operator) {
     case "LIKE":
       return getLikePredicate(rhs, "");
     case "NOT LIKE":
-      return not(getLikePredicate(rhs, ""));
+      return not2(getLikePredicate(rhs, ""));
     case "ILIKE":
       return getLikePredicate(rhs, "i");
     case "NOT ILIKE":
-      return not(getLikePredicate(rhs, "i"));
+      return not2(getLikePredicate(rhs, "i"));
     case "IN": {
       assert(Array.isArray(rhs));
       const set = new Set(rhs);
@@ -10462,7 +10584,7 @@ function createPredicateImpl(rhs, operator) {
       throw new Error(`Unexpected operator: ${operator}`);
   }
 }
-function not(f) {
+function not2(f) {
   return (lhs) => !f(lhs);
 }
 function transformFilters(filters) {
@@ -10798,192 +10920,40 @@ var ArrayView = class {
       this.#fireListener(listener);
     }
   }
-  #fireListener(listener) {
-    listener(
-      this.data,
-      this.#complete ? "complete" : "unknown"
-    );
-  }
-  destroy() {
-    this.onDestroy?.();
-  }
-  #hydrate() {
-    this.#dirty = true;
-    for (const node of this.#input.fetch({})) {
-      applyChange(
-        this.#root,
-        { type: "add", node },
-        this.#schema,
-        "",
-        this.#format
-      );
-    }
-    this.flush();
-  }
-  push(change) {
-    this.#dirty = true;
-    applyChange(this.#root, change, this.#schema, "", this.#format);
-  }
-  flush() {
-    if (!this.#dirty) {
-      return;
-    }
-    this.#dirty = false;
-    this.#fireListeners();
-  }
-};
-
-// ../zql/src/query/expression.ts
-var ExpressionBuilder = class {
-  #exists;
-  constructor(exists) {
-    this.#exists = exists;
-    this.exists = this.exists.bind(this);
-  }
-  get eb() {
-    return this;
-  }
-  cmp(field, opOrValue, value) {
-    return cmp(field, opOrValue, value);
-  }
-  cmpLit(left, op, right) {
-    return {
-      type: "simple",
-      left: isParameterReference(left) ? left[toStaticParam]() : { type: "literal", value: left },
-      right: isParameterReference(right) ? right[toStaticParam]() : { type: "literal", value: right },
-      op
-    };
-  }
-  and = and;
-  or = or;
-  not = not2;
-  exists(relationship, cb) {
-    return this.#exists(relationship, cb);
-  }
-};
-function and(...conditions) {
-  const expressions = filterTrue(filterUndefined(conditions));
-  if (expressions.length === 1) {
-    return expressions[0];
-  }
-  if (expressions.some(isAlwaysFalse)) {
-    return FALSE;
-  }
-  return { type: "and", conditions: expressions };
-}
-function or(...conditions) {
-  const expressions = filterFalse(filterUndefined(conditions));
-  if (expressions.length === 1) {
-    return expressions[0];
-  }
-  if (expressions.some(isAlwaysTrue)) {
-    return TRUE;
-  }
-  return { type: "or", conditions: expressions };
-}
-function not2(expression) {
-  switch (expression.type) {
-    case "and":
-      return {
-        type: "or",
-        conditions: expression.conditions.map(not2)
-      };
-    case "or":
-      return {
-        type: "and",
-        conditions: expression.conditions.map(not2)
-      };
-    case "correlatedSubquery":
-      return {
-        type: "correlatedSubquery",
-        related: expression.related,
-        op: negateOperator(expression.op)
-      };
-    case "simple":
-      return {
-        type: "simple",
-        op: negateOperator(expression.op),
-        left: expression.left,
-        right: expression.right
-      };
+  #fireListener(listener) {
+    listener(
+      this.data,
+      this.#complete ? "complete" : "unknown"
+    );
   }
-}
-function cmp(field, opOrValue, value) {
-  let op;
-  if (value === void 0) {
-    value = opOrValue;
-    op = "=";
-  } else {
-    op = opOrValue;
+  destroy() {
+    this.onDestroy?.();
   }
-  return {
-    type: "simple",
-    left: { type: "column", name: field },
-    right: isParameterReference(value) ? value[toStaticParam]() : { type: "literal", value },
-    op
-  };
-}
-function isParameterReference(value) {
-  return value !== null && typeof value === "object" && value[toStaticParam];
-}
-var TRUE = {
-  type: "and",
-  conditions: []
-};
-var FALSE = {
-  type: "or",
-  conditions: []
-};
-function isAlwaysTrue(condition) {
-  return condition.type === "and" && condition.conditions.length === 0;
-}
-function isAlwaysFalse(condition) {
-  return condition.type === "or" && condition.conditions.length === 0;
-}
-function flatten(type, conditions) {
-  const flattened2 = [];
-  for (const c of conditions) {
-    if (c.type === type) {
-      flattened2.push(...c.conditions);
-    } else {
-      flattened2.push(c);
+  #hydrate() {
+    this.#dirty = true;
+    for (const node of this.#input.fetch({})) {
+      applyChange(
+        this.#root,
+        { type: "add", node },
+        this.#schema,
+        "",
+        this.#format
+      );
     }
+    this.flush();
+  }
+  push(change) {
+    this.#dirty = true;
+    applyChange(this.#root, change, this.#schema, "", this.#format);
+  }
+  flush() {
+    if (!this.#dirty) {
+      return;
+    }
+    this.#dirty = false;
+    this.#fireListeners();
   }
-  return flattened2;
-}
-var negateSimpleOperatorMap = {
-  ["="]: "!=",
-  ["!="]: "=",
-  ["<"]: ">=",
-  [">"]: "<=",
-  [">="]: "<",
-  ["<="]: ">",
-  ["IN"]: "NOT IN",
-  ["NOT IN"]: "IN",
-  ["LIKE"]: "NOT LIKE",
-  ["NOT LIKE"]: "LIKE",
-  ["ILIKE"]: "NOT ILIKE",
-  ["NOT ILIKE"]: "ILIKE",
-  ["IS"]: "IS NOT",
-  ["IS NOT"]: "IS"
-};
-var negateOperatorMap = {
-  ...negateSimpleOperatorMap,
-  ["EXISTS"]: "NOT EXISTS",
-  ["NOT EXISTS"]: "EXISTS"
 };
-function negateOperator(op) {
-  return must(negateOperatorMap[op]);
-}
-function filterUndefined(array9) {
-  return array9.filter((e) => e !== void 0);
-}
-function filterTrue(conditions) {
-  return conditions.filter((c) => !isAlwaysTrue(c));
-}
-function filterFalse(conditions) {
-  return conditions.filter((c) => !isAlwaysFalse(c));
-}
 
 // ../zql/src/query/dnf.ts
 function dnf(condition) {
@@ -11039,7 +11009,6 @@ function unwrap(c) {
 }
 
 // ../zql/src/query/query-impl.ts
-var astForTestingSymbol = Symbol();
 function newQuery(delegate, schema, table2) {
   return new QueryImpl(delegate, schema, table2);
 }
@@ -11070,10 +11039,6 @@ var AbstractQuery = class {
   get format() {
     return this.#format;
   }
-  // Not part of Query or QueryInternal interface
-  get [astForTestingSymbol]() {
-    return this.#ast;
-  }
   hash() {
     if (!this.#hash) {
       const ast = this._completeAst();
@@ -11201,7 +11166,6 @@ var AbstractQuery = class {
                 parentField: firstRelation.sourceField,
                 childField: firstRelation.destField
               },
-              hidden: true,
               subquery: {
                 table: junctionSchema,
                 alias: relationship,
@@ -11216,6 +11180,7 @@ var AbstractQuery = class {
                       parentField: secondRelation.sourceField,
                       childField: secondRelation.destField
                     },
+                    hidden: true,
                     subquery: addPrimaryKeysToAst(
                       this.#schema.tables[destSchema],
                       sq.#ast
@@ -11428,14 +11393,21 @@ var AbstractQuery = class {
     return this.#completedAST;
   }
 };
+var astForTestingSymbol = Symbol();
 var completedAstSymbol = Symbol();
 var QueryImpl = class extends AbstractQuery {
   #delegate;
+  #ast;
   constructor(delegate, schema, tableName, ast = { table: tableName }, format) {
     super(schema, tableName, ast, format);
     this.#delegate = delegate;
+    this.#ast = ast;
   }
   _system = "client";
+  // Not part of Query or QueryInternal interface
+  get [astForTestingSymbol]() {
+    return this.#ast;
+  }
   get [completedAstSymbol]() {
     return this._completeAst();
   }
@@ -11526,8 +11498,8 @@ function isCompoundKey(field) {
   return Array.isArray(field) && field.length >= 1;
 }
 
-// ../zql/src/query/static-query.ts
-var StaticQuery = class _StaticQuery extends AbstractQuery {
+// ../zql/src/query/auth-query.ts
+var AuthQuery = class _AuthQuery extends AbstractQuery {
   constructor(schema, tableName, ast = { table: tableName }, format) {
     super(schema, tableName, ast, format);
   }
@@ -11536,7 +11508,7 @@ var StaticQuery = class _StaticQuery extends AbstractQuery {
   }
   _system = "permissions";
   _newQuery(schema, tableName, ast, format) {
-    return new _StaticQuery(schema, tableName, ast, format);
+    return new _AuthQuery(schema, tableName, ast, format);
   }
   get ast() {
     return this._completeAst();
@@ -11552,97 +11524,13 @@ var StaticQuery = class _StaticQuery extends AbstractQuery {
   }
 };
 
-// ../zero-schema/src/name-mapper.ts
-function clientToServer(tables) {
-  return createMapperFrom("client", tables);
-}
-function serverToClient(tables) {
-  return createMapperFrom("server", tables);
-}
-function createMapperFrom(src, tables) {
-  const mapping = new Map(
-    Object.entries(tables).map(
-      ([tableName, { serverName: serverTableName, columns }]) => {
-        let allColumnsSame = true;
-        const names = {};
-        for (const [name, { serverName }] of Object.entries(columns)) {
-          if (serverName && serverName !== name) {
-            allColumnsSame = false;
-          }
-          if (src === "client") {
-            names[name] = serverName ?? name;
-          } else {
-            names[serverName ?? name] = name;
-          }
-        }
-        return [
-          src === "client" ? tableName : serverTableName ?? tableName,
-          {
-            tableName: src === "client" ? serverTableName ?? tableName : tableName,
-            columns: names,
-            allColumnsSame
-          }
-        ];
-      }
-    )
-  );
-  return new NameMapper(mapping);
-}
-var NameMapper = class {
-  #tables = /* @__PURE__ */ new Map();
-  constructor(tables) {
-    this.#tables = tables;
-  }
-  #getTable(src, ctx) {
-    const table2 = this.#tables.get(src);
-    if (!table2) {
-      throw new Error(
-        `unknown table "${src}" ${!ctx ? "" : `in ${JSON.stringify(ctx)}`}`
-      );
-    }
-    return table2;
-  }
-  tableName(src, context) {
-    return this.#getTable(src, context).tableName;
-  }
-  columnName(table2, src, ctx) {
-    const dst = this.#getTable(table2, ctx).columns[src];
-    if (!dst) {
-      throw new Error(
-        `unknown column "${src}" of "${table2}" table ${!ctx ? "" : `in ${JSON.stringify(ctx)}`}`
-      );
-    }
-    return dst;
-  }
-  row(table2, row) {
-    const dest = this.#getTable(table2);
-    const { allColumnsSame, columns } = dest;
-    if (allColumnsSame) {
-      return row;
-    }
-    const clientRow = {};
-    for (const col in row) {
-      clientRow[columns[col] ?? col] = row[col];
-    }
-    return clientRow;
-  }
-  columns(table2, cols) {
-    const dest = this.#getTable(table2);
-    const { allColumnsSame, columns } = dest;
-    return cols === void 0 || allColumnsSame ? cols : cols.map((col) => columns[col] ?? col);
-  }
-};
-
 // ../zero-schema/src/permissions.ts
 var ANYONE_CAN = void 0;
 var NOBODY_CAN = [];
 async function definePermissions(schema, definer) {
   const expressionBuilders = {};
   for (const name of Object.keys(schema.tables)) {
-    expressionBuilders[name] = new StaticQuery(
-      schema,
-      name
-    ).expressionBuilder();
+    expressionBuilders[name] = new AuthQuery(schema, name).expressionBuilder();
   }
   const config = await definer();
   return compilePermissions(schema, config, expressionBuilders);
@@ -11652,13 +11540,10 @@ function compilePermissions(schema, authz, expressionBuilders) {
     return void 0;
   }
   const nameMapper = clientToServer(schema.tables);
-  const ret = {
-    protocolVersion: PROTOCOL_VERSION,
-    tables: {}
-  };
+  const ret = {};
   for (const [tableName, tableConfig] of Object.entries(authz)) {
     const serverName = schema.tables[tableName].serverName ?? tableName;
-    ret.tables[serverName] = {
+    ret[serverName] = {
       row: compileRowConfig(
         nameMapper,
         tableName,
@@ -11809,18 +11694,6 @@ function escapeLike(val) {
 import { LogContext as LogContext4 } from "@rocicorp/logger";
 import { resolver as resolver8 } from "@rocicorp/resolver";
 
-// ../zero-protocol/src/delete-clients.ts
-var deleteClientsBodySchema = valita_exports.union(
-  readonlyObject({
-    clientIDs: readonlyArray(valita_exports.string()).optional(),
-    clientGroupIDs: readonlyArray(valita_exports.string()).optional()
-  })
-);
-var deleteClientsMessageSchema = valita_exports.tuple([
-  valita_exports.literal("deleteClients"),
-  deleteClientsBodySchema
-]);
-
 // ../zero-protocol/src/queries-patch.ts
 var putOpSchema = valita_exports.object({
   op: valita_exports.literal("put"),
@@ -11847,8 +11720,7 @@ var connectedMessageSchema = valita_exports.tuple([
   connectedBodySchema
 ]);
 var initConnectionBodySchema = valita_exports.object({
-  desiredQueriesPatch: queriesPatchSchema,
-  deleted: deleteClientsBodySchema.optional()
+  desiredQueriesPatch: queriesPatchSchema
 });
 var initConnectionMessageSchema = valita_exports.tuple([
   valita_exports.literal("initConnection"),
@@ -12023,10 +11895,6 @@ var pokePartBodySchema = valita_exports.object({
 });
 var pokeEndBodySchema = valita_exports.object({
   pokeID: valita_exports.string(),
-  // If present, this should be the cookie stored with the client,
-  // instead of the cookie presented in pokeStart.
-  // TODO: Consider making this required and removing it from pokeStart.
-  cookie: versionSchema.optional(),
   // If `true`, the poke with id `pokeID` should be discarded without
   // applying it.
   cancel: valita_exports.boolean().optional()
@@ -12086,14 +11954,18 @@ var downstreamSchema = valita_exports.union(
   pokeStartMessageSchema,
   pokePartMessageSchema,
   pokeEndMessageSchema,
-  pullResponseMessageSchema,
-  deleteClientsMessageSchema
+  pullResponseMessageSchema
 );
 
 // ../zero-protocol/src/mutation-type-enum.ts
 var CRUD = "crud";
 var Custom = "custom";
 
+// ../zero-protocol/src/protocol-version.ts
+var PROTOCOL_VERSION = 4;
+var MIN_SERVER_SUPPORTED_PROTOCOL_VERSION = 2;
+assert(MIN_SERVER_SUPPORTED_PROTOCOL_VERSION < PROTOCOL_VERSION);
+
 // ../zero-protocol/src/push.ts
 var CRUD_MUTATION_NAME = "_zero_crud";
 var insertOpSchema = valita_exports.object({
@@ -13436,28 +13308,48 @@ var ZeroContext = class {
 // ../zero-client/src/client/crud.ts
 function makeCRUDMutate(schema, repMutate) {
   const { [CRUD_MUTATION_NAME]: zeroCRUD } = repMutate;
+  let inBatch = false;
   const mutateBatch = async (body) => {
-    const ops = [];
-    const m = {};
-    for (const name of Object.keys(schema.tables)) {
-      m[name] = makeBatchCRUDMutate(name, schema, ops);
+    if (inBatch) {
+      throw new Error("Cannot call mutate inside a batch");
+    }
+    inBatch = true;
+    try {
+      const ops = [];
+      const m = {};
+      for (const name of Object.keys(schema.tables)) {
+        m[name] = makeBatchCRUDMutate(name, schema, ops);
+      }
+      const rv = await body(m);
+      await zeroCRUD({ ops });
+      return rv;
+    } finally {
+      inBatch = false;
+    }
+  };
+  const assertNotInBatch = (tableName, op) => {
+    if (inBatch) {
+      throw new Error(`Cannot call mutate.${tableName}.${op} inside a batch`);
     }
-    const rv = await body(m);
-    await zeroCRUD({ ops });
-    return rv;
   };
   const mutate = {};
   for (const [name, tableSchema] of Object.entries(schema.tables)) {
-    mutate[name] = makeEntityCRUDMutate(name, tableSchema.primaryKey, zeroCRUD);
+    mutate[name] = makeEntityCRUDMutate(
+      name,
+      tableSchema.primaryKey,
+      zeroCRUD,
+      assertNotInBatch
+    );
   }
   return {
     mutate,
     mutateBatch
   };
 }
-function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD) {
+function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD, assertNotInBatch) {
   return {
     insert: (value) => {
+      assertNotInBatch(tableName, "insert");
       const op = {
         op: "insert",
         tableName,
@@ -13467,6 +13359,7 @@ function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD) {
       return zeroCRUD({ ops: [op] });
     },
     upsert: (value) => {
+      assertNotInBatch(tableName, "upsert");
       const op = {
         op: "upsert",
         tableName,
@@ -13476,6 +13369,7 @@ function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD) {
       return zeroCRUD({ ops: [op] });
     },
     update: (value) => {
+      assertNotInBatch(tableName, "update");
       const op = {
         op: "update",
         tableName,
@@ -13485,6 +13379,7 @@ function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD) {
       return zeroCRUD({ ops: [op] });
     },
     delete: (id) => {
+      assertNotInBatch(tableName, "delete");
       const op = {
         op: "delete",
         tableName,
@@ -13735,57 +13630,6 @@ function makeTableCRUD(schema, tableName, tx, ivmBranch) {
   };
 }
 
-// ../zero-client/src/client/delete-clients-manager.ts
-var DeleteClientsManager = class {
-  #send;
-  #lc;
-  #dagStore;
-  constructor(send2, dagStore, lc) {
-    this.#send = send2;
-    this.#dagStore = dagStore;
-    this.#lc = lc;
-  }
-  /**
-   * This gets called by Replicache when it deletes clients from the persistent
-   * storage.
-   */
-  onClientsDeleted(clientIDs, clientGroupIDs) {
-    this.#lc.debug?.("DeletedClientsManager, send:", clientIDs);
-    this.#send(["deleteClients", { clientIDs, clientGroupIDs }]);
-  }
-  /**
-   * Zero calls this after it connects to ensure that the server knows about all
-   * the clients that might have been deleted locally since the last connection.
-   */
-  async sendDeletedClientsToServer() {
-    const deleted = await withRead(
-      this.#dagStore,
-      (dagRead) => getDeletedClients(dagRead)
-    );
-    if (deleted.clientIDs.length > 0 || deleted.clientGroupIDs.length > 0) {
-      this.#send(["deleteClients", deleted]);
-      this.#lc.debug?.("DeletedClientsManager, send:", deleted);
-    }
-  }
-  /**
-   * This is called as a response to the server telling us which clients it
-   * actually deleted.
-   */
-  clientsDeletedOnServer(deletedClients) {
-    const { clientIDs = [], clientGroupIDs = [] } = deletedClients;
-    if (clientIDs.length > 0 || clientGroupIDs.length > 0) {
-      return withWrite(this.#dagStore, async (dagWrite) => {
-        this.#lc.debug?.("clientsDeletedOnServer:", clientIDs, clientGroupIDs);
-        await removeDeletedClients(dagWrite, clientIDs, clientGroupIDs);
-      });
-    }
-    return promiseVoid;
-  }
-  getDeletedClients() {
-    return withRead(this.#dagStore, getDeletedClients);
-  }
-};
-
 // ../zero-client/src/client/enable-analytics.ts
 var IPV4_ADDRESS_REGEX = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
 var IPV6_ADDRESS_HOSTNAME_REGEX = /^\[[a-fA-F0-9:]*:[a-fA-F0-9:]*\]$/;
@@ -14034,7 +13878,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.14.2025021101";
+var version2 = "0.14.2025021202";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -14724,7 +14568,7 @@ var PokeHandler = class {
       this.#receivingPoke = void 0;
       return;
     }
-    this.#pokeBuffer.push({ ...this.#receivingPoke, pokeEnd });
+    this.#pokeBuffer.push(this.#receivingPoke);
     this.#receivingPoke = void 0;
     if (!this.#pokePlaybackLoopRunning) {
       this.#startPlaybackLoop();
@@ -14800,8 +14644,7 @@ function mergePokes(pokeBuffer, schema, serverToClient2) {
     return void 0;
   }
   const { baseCookie } = pokeBuffer[0].pokeStart;
-  const lastPoke = pokeBuffer[pokeBuffer.length - 1];
-  const cookie = lastPoke.pokeEnd.cookie ?? lastPoke.pokeStart.cookie;
+  const { cookie } = pokeBuffer[pokeBuffer.length - 1].pokeStart;
   const mergedPatch = [];
   const mergedLastMutationIDChanges = {};
   let prevPokeStart = void 0;
@@ -15007,7 +14850,6 @@ var Zero = class {
   #queryManager;
   #ivmSources;
   #clientToServer;
-  #deleteClientsManager;
   /**
    * The queries we sent when inside the sec-protocol header when establishing a connection.
    * More queries could be registered while we're waiting for the 'connected' message
@@ -15018,13 +14860,6 @@ var Zero = class {
    * and an `initConnection` message must be sent to the server after receiving the `connected` message.
    */
   #initConnectionQueries;
-  /**
-   * We try to send the deleted clients and (client groups) as part of the
-   * sec-protocol header. If we can't because the header would get too large we
-   * keep track of the deleted clients and send them after the connection is
-   * established.
-   */
-  #deletedClients;
   #lastMutationIDSent = NULL_LAST_MUTATION_ID_SENT;
   #onPong = () => void 0;
   #online = false;
@@ -15160,8 +14995,7 @@ var Zero = class {
     };
     const replicacheImplOptions = {
       enableClientGroupForking: false,
-      enableMutationRecovery: false,
-      onClientsDeleted: (clientIDs, clientGroupIDs) => this.#deleteClientsManager.onClientsDeleted(clientIDs, clientGroupIDs)
+      enableMutationRecovery: false
     };
     const rep = new ReplicacheImpl(replicacheOptions, replicacheImplOptions);
     this.#rep = rep;
@@ -15220,11 +15054,6 @@ var Zero = class {
       maxRecentQueries
     );
     this.#clientToServer = clientToServer(schema.tables);
-    this.#deleteClientsManager = new DeleteClientsManager(
-      (msg) => this.#send(msg),
-      rep.perdag,
-      this.#lc
-    );
     this.#zeroContext = new ZeroContext(
       this.#ivmSources.main,
       (ast, gotCallback) => this.#queryManager.add(ast, gotCallback),
@@ -15275,9 +15104,6 @@ var Zero = class {
     }
   }
   #sendChangeDesiredQueries(msg) {
-    this.#send(msg);
-  }
-  #send(msg) {
     if (this.#socket && this.#connectionState === Connected) {
       send(this.#socket, msg);
     }
@@ -15424,10 +15250,6 @@ var Zero = class {
         return this.#handlePullResponse(lc, downMessage);
       case "warm":
         break;
-      case "deleteClients":
-        return this.#deleteClientsManager.clientsDeletedOnServer(
-          downMessage[1]
-        );
       default:
         msgType;
         rejectInvalidMessage();
@@ -15498,8 +15320,8 @@ var Zero = class {
     this.#metrics.lastConnectError.clear();
     const proceedingConnectErrorCount = this.#connectErrorCount;
     this.#connectErrorCount = 0;
-    let timeToConnectMs;
-    let connectMsgLatencyMs;
+    let timeToConnectMs = void 0;
+    let connectMsgLatencyMs = void 0;
     if (this.#connectStart === void 0) {
       lc.error?.(
         "Got connected message but connect start time is undefined. This should not happen."
@@ -15510,7 +15332,7 @@ var Zero = class {
       connectMsgLatencyMs = connectBody.timestamp !== void 0 ? now - connectBody.timestamp : void 0;
       this.#connectStart = void 0;
     }
-    let totalTimeToConnectMs;
+    let totalTimeToConnectMs = void 0;
     if (this.#totalToConnectStart === void 0) {
       lc.error?.(
         "Got connected message but total to connect start time is undefined. This should not happen."
@@ -15530,37 +15352,26 @@ var Zero = class {
     });
     this.#lastMutationIDSent = NULL_LAST_MUTATION_ID_SENT;
     lc.debug?.("Resolving connect resolver");
-    const socket = must(this.#socket);
+    assert(this.#socket);
     const queriesPatch = await this.#rep.query(
       (tx) => this.#queryManager.getQueriesPatch(tx, this.#initConnectionQueries)
     );
-    const hasDeletedClients = () => skipEmptyArray(this.#deletedClients?.clientIDs) || skipEmptyArray(this.#deletedClients?.clientGroupIDs);
-    const maybeSendDeletedClients = () => {
-      if (hasDeletedClients()) {
-        send(socket, ["deleteClients", this.#deletedClients]);
-        this.#deletedClients = void 0;
-      }
-    };
     if (queriesPatch.size > 0 && this.#initConnectionQueries !== void 0) {
-      maybeSendDeletedClients();
-      send(socket, [
+      send(this.#socket, [
         "changeDesiredQueries",
         {
           desiredQueriesPatch: [...queriesPatch.values()]
         }
       ]);
     } else if (this.#initConnectionQueries === void 0) {
-      send(socket, [
+      send(this.#socket, [
         "initConnection",
         {
-          desiredQueriesPatch: [...queriesPatch.values()],
-          deleted: skipEmptyDeletedClients(this.#deletedClients)
+          desiredQueriesPatch: [...queriesPatch.values()]
         }
       ]);
-      this.#deletedClients = void 0;
     }
     this.#initConnectionQueries = void 0;
-    maybeSendDeletedClients();
     this.#setConnectionState(Connected);
     this.#connectResolver.resolve();
   }
@@ -15614,10 +15425,9 @@ var Zero = class {
       clearTimeout(timeoutID);
     };
     this.#closeAbortController.signal.addEventListener("abort", abortHandler);
-    const [ws, initConnectionQueries, deletedClients] = await createSocket(
+    const [ws, initConnectionQueries] = await createSocket(
       this.#rep,
       this.#queryManager,
-      this.#deleteClientsManager,
       toWSString(this.#server),
       this.#connectCookie,
       this.clientID,
@@ -15636,7 +15446,6 @@ var Zero = class {
       return;
     }
     this.#initConnectionQueries = initConnectionQueries;
-    this.#deletedClients = deletedClients;
     ws.addEventListener("message", this.#onMessage);
     ws.addEventListener("open", this.#onOpen);
     ws.addEventListener("close", this.#onClose);
@@ -16092,7 +15901,7 @@ var Zero = class {
     return rv;
   }
 };
-async function createSocket(rep, queryManager, deleteClientsManager, socketOrigin, baseCookie, clientID, clientGroupID, schemaVersion, userID, auth, lmid, wsid, debugPerf, lc, maxHeaderLength = 1024 * 8, additionalConnectParams) {
+async function createSocket(rep, queryManager, socketOrigin, baseCookie, clientID, clientGroupID, schemaVersion, userID, auth, lmid, wsid, debugPerf, lc, maxHeaderLength = 1024 * 8, additionalConnectParams) {
   const url = new URL(
     appendPath(socketOrigin, `/sync/v${PROTOCOL_VERSION}/connect`)
   );
@@ -16119,24 +15928,16 @@ async function createSocket(rep, queryManager, deleteClientsManager, socketOrigi
   }
   lc.info?.("Connecting to", url.toString());
   const WS = mustGetBrowserGlobal("WebSocket");
-  const queriesPatchP = rep.query((tx) => queryManager.getQueriesPatch(tx));
-  let deletedClients = await deleteClientsManager.getDeletedClients();
-  let queriesPatch = await queriesPatchP;
+  let queriesPatch = await rep.query(
+    (tx) => queryManager.getQueriesPatch(tx)
+  );
   let secProtocol = encodeSecProtocols(
-    [
-      "initConnection",
-      {
-        desiredQueriesPatch: [...queriesPatch.values()],
-        deleted: skipEmptyDeletedClients(deletedClients)
-      }
-    ],
+    ["initConnection", { desiredQueriesPatch: [...queriesPatch.values()] }],
     auth
   );
   if (secProtocol.length > maxHeaderLength) {
     secProtocol = encodeSecProtocols(void 0, auth);
     queriesPatch = void 0;
-  } else {
-    deletedClients = void 0;
   }
   return [
     new WS(
@@ -16144,26 +15945,9 @@ async function createSocket(rep, queryManager, deleteClientsManager, socketOrigi
       url.toString(),
       secProtocol
     ),
-    queriesPatch,
-    skipEmptyDeletedClients(deletedClients)
+    queriesPatch
   ];
 }
-function skipEmptyArray(arr) {
-  return arr && arr.length > 0 ? arr : void 0;
-}
-function skipEmptyDeletedClients(deletedClients) {
-  if (!deletedClients) {
-    return void 0;
-  }
-  const { clientIDs, clientGroupIDs } = deletedClients;
-  if ((!clientIDs || clientIDs.length === 0) && (!clientGroupIDs || clientGroupIDs.length === 0)) {
-    return void 0;
-  }
-  const data = {};
-  data.clientIDs = skipEmptyArray(clientIDs);
-  data.clientGroupIDs = skipEmptyArray(clientGroupIDs);
-  return data;
-}
 function addWebSocketIDFromSocketToLogContext({ url }, lc) {
   const wsid = new URL(url).searchParams.get("wsid") ?? nanoid();
   return addWebSocketIDToLogContext(wsid, lc);
@@ -16194,7 +15978,7 @@ export {
   dropAllDatabases,
   relationships,
   table,
-  string8 as string,
+  string7 as string,
   number4 as number,
   boolean3 as boolean,
   json,
@@ -16206,4 +15990,4 @@ export {
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-5GWP7BBD.js.map
+//# sourceMappingURL=chunk-JMAJNHHI.js.map