@rocicorp/zero 0.14.2025021001 → 0.14.2025021101

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

@@ -1420,33 +1420,46 @@ var WriteImpl2 = class extends ReadImpl2 {
 
 // ../replicache/src/deleted-clients.ts
 var DELETED_CLIENTS_HEAD_NAME = "deleted-clients";
-async function setDeletedClients(dagWrite, deletedClients) {
-  const normalized = normalize(deletedClients);
-  const chunkData = deepFreeze(normalized);
+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 normalized;
+  return data;
 }
-var deletedClientsSchema = valita_exports.array(valita_exports.string());
 async function getDeletedClients(dagRead) {
   const hash2 = await dagRead.getHead(DELETED_CLIENTS_HEAD_NAME);
   if (hash2 === void 0) {
-    return [];
+    return { clientIDs: [], clientGroupIDs: [] };
   }
   const chunk = await dagRead.mustGetChunk(hash2);
   return parse(chunk.data, deletedClientsSchema);
 }
-async function addDeletedClients(dagWrite, clientIDs) {
-  const deletedClients = await getDeletedClients(dagWrite);
-  return setDeletedClients(dagWrite, [...deletedClients, ...clientIDs]);
+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) {
-  const deletedClients = await getDeletedClients(dagWrite);
-  const newDeletedClients = deletedClients.filter(
+async function removeDeletedClients(dagWrite, clientIDs, clientGroupIDs) {
+  const { clientIDs: oldClientIDs, clientGroupIDs: oldClientGroupIDs } = await getDeletedClients(dagWrite);
+  const newDeletedClients = oldClientIDs.filter(
     (clientID) => !clientIDs.includes(clientID)
   );
-  return setDeletedClients(dagWrite, newDeletedClients);
+  const newDeletedClientGroups = oldClientGroupIDs.filter(
+    (clientGroupID) => !clientGroupIDs.includes(clientGroupID)
+  );
+  return setDeletedClients(dagWrite, newDeletedClients, newDeletedClientGroups);
 }
 function normalize(arr) {
   return [...new Set(arr)].sort();
@@ -3095,13 +3108,13 @@ var DataNodeImpl = class extends NodeImpl {
     }
   }
 };
-function readonlySplice(array12, start, deleteCount, ...items) {
-  const arr = array12.slice(0, start);
+function readonlySplice(array9, start, deleteCount, ...items) {
+  const arr = array9.slice(0, start);
   for (let i = 0; i < items.length; i++) {
     arr.push(items[i]);
   }
-  for (let i = start + deleteCount; i < array12.length; i++) {
-    arr.push(array12[i]);
+  for (let i = start + deleteCount; i < array9.length; i++) {
+    arr.push(array9[i]);
   }
   return arr;
 }
@@ -5772,7 +5785,7 @@ async function mustGetClient(id, dagRead) {
   return client;
 }
 function initClientV6(newClientID, lc, perdag, mutatorNames, indexes, formatVersion, enableClientGroupForking) {
-  return withWriteNoImplicitCommit(perdag, async (dagWrite) => {
+  return withWrite(perdag, async (dagWrite) => {
     async function setClientsAndClientGroupAndCommit(basisHash, cookieJSON, valueHash2, indexRecords2) {
       const newSnapshotData = newSnapshotCommitDataDD31(
         basisHash,
@@ -5806,7 +5819,6 @@ 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);
@@ -5821,7 +5833,6 @@ 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) {
@@ -6009,8 +6020,13 @@ function gcClients(clientID, dagStore, clientMaxInactiveTime, onClientsDeleted)
       return clients;
     }
     await setClients(newClients, dagWrite);
-    const normalized = await addDeletedClients(dagWrite, deletedClients);
-    onClientsDeleted(normalized);
+    const { clientIDs, clientGroupIDs } = await addDeletedClients(
+      dagWrite,
+      deletedClients,
+      // gcClients does not delete client groups
+      []
+    );
+    onClientsDeleted(clientIDs, clientGroupIDs);
     return newClients;
   });
 }
@@ -6018,11 +6034,15 @@ 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, lc, signal) {
+function initClientGroupGC(dagStore, enableMutationRecovery, onClientsDeleted, lc, signal) {
   initBgIntervalProcess(
     "ClientGroupGC",
     () => {
-      latestGCUpdate2 = gcClientGroups(dagStore, enableMutationRecovery);
+      latestGCUpdate2 = gcClientGroups(
+        dagStore,
+        enableMutationRecovery,
+        onClientsDeleted
+      );
       return latestGCUpdate2;
     },
     () => GC_INTERVAL_MS,
@@ -6030,7 +6050,7 @@ function initClientGroupGC(dagStore, enableMutationRecovery, lc, signal) {
     signal
   );
 }
-function gcClientGroups(dagStore, enableMutationRecovery) {
+function gcClientGroups(dagStore, enableMutationRecovery, onClientsDeleted) {
   return withWrite(dagStore, async (tx) => {
     const clients = await getClients(tx);
     const clientGroupIDs = /* @__PURE__ */ new Set();
@@ -6038,12 +6058,16 @@ function gcClientGroups(dagStore, enableMutationRecovery) {
       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)) {
         clientGroups.set(clientGroupID, clientGroup);
+      } else {
+        removeClientGroups.add(clientGroupID);
       }
     }
     await setClientGroups(clientGroups, tx);
+    onClientsDeleted([], [...removeClientGroups].sort());
     return clientGroups;
   });
 }
@@ -7056,14 +7080,14 @@ function diffBinarySearch(diff2, prefix, compareKey) {
 }
 
 // ../shared/src/random-values.ts
-function getNonCryptoRandomValues(array12) {
-  if (array12 === null) {
+function getNonCryptoRandomValues(array9) {
+  if (array9 === null) {
     throw new TypeError("array cannot be null");
   }
-  for (let i = 0; i < array12.length; i++) {
-    array12[i] = Math.floor(Math.random() * 256);
+  for (let i = 0; i < array9.length; i++) {
+    array9[i] = Math.floor(Math.random() * 256);
   }
-  return array12;
+  return array9;
 }
 
 // ../replicache/src/sync/request-id.ts
@@ -7424,7 +7448,13 @@ var ReplicacheImpl = class {
       this.#lc,
       signal
     );
-    initClientGroupGC(this.perdag, enableMutationRecovery, this.#lc, signal);
+    initClientGroupGC(
+      this.perdag,
+      enableMutationRecovery,
+      onClientsDeleted,
+      this.#lc,
+      signal
+    );
     initNewClientChannel(
       this.name,
       this.idbName,
@@ -8288,10 +8318,15 @@ async function collectIDBDatabases(idbDatabasesStore, now, maxAge, kvDropStore,
   const dbNamesToRemove = [];
   const dbNamesToKeep = [];
   const clientIDsToRemove = [];
-  for (const [dbName, [canCollect, clientIDs]] of collectResults) {
+  const clientGroupIDsToRemove = [];
+  for (const [
+    dbName,
+    [canCollect, clientIDs, clientGroupIDs]
+  ] of collectResults) {
     if (canCollect) {
       dbNamesToRemove.push(dbName);
       clientIDsToRemove.push(...clientIDs);
+      clientGroupIDsToRemove.push(...clientGroupIDs);
     } else {
       dbNamesToKeep.push(dbName);
     }
@@ -8304,16 +8339,24 @@ async function collectIDBDatabases(idbDatabasesStore, now, maxAge, kvDropStore,
   if (errors.length) {
     throw errors[0];
   }
-  if (clientIDsToRemove.length) {
-    const toRemoveIncludingOld = clientIDsToRemove;
+  if (clientIDsToRemove.length || clientGroupIDsToRemove.length) {
+    const newClientIDsToRemove = clientIDsToRemove;
+    const newClientGroupIDsToRemove = clientGroupIDsToRemove;
     for (const name of dbNamesToKeep) {
       await withWrite(newDagStore(name), async (dagWrite) => {
-        toRemoveIncludingOld.push(
-          ...await addDeletedClients(dagWrite, clientIDsToRemove)
+        const { clientIDs, clientGroupIDs } = await addDeletedClients(
+          dagWrite,
+          clientIDsToRemove,
+          clientGroupIDsToRemove
         );
+        newClientIDsToRemove.push(...clientIDs);
+        newClientGroupIDsToRemove.push(...clientGroupIDs);
       });
     }
-    onClientsDeleted(normalize(toRemoveIncludingOld));
+    onClientsDeleted(
+      normalize(newClientIDsToRemove),
+      normalize(newClientGroupIDsToRemove)
+    );
   }
 }
 async function dropDatabaseInternal(name, idbDatabasesStore, kvDropStore) {
@@ -8391,8 +8434,14 @@ function canDatabaseBeCollectedAndGetDeletedClientIDs(enableMutationRecovery, pe
       }
     }
     const clients = await getClients(read);
-    const oldDeletedClients = await getDeletedClients(read);
-    return [true, [...clients.keys(), ...oldDeletedClients]];
+    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];
   });
 }
 
@@ -8937,157 +8986,12 @@ function compareUTF8MaybeNull(a, b) {
   return 0;
 }
 
-// ../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 = not;
-  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 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(array12) {
-  return array12.filter((e) => e !== void 0);
-}
-function filterTrue(conditions) {
-  return conditions.filter((c) => !isAlwaysTrue(c));
-}
-function filterFalse(conditions) {
-  return conditions.filter((c) => !isAlwaysFalse(c));
-}
+// ../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";
@@ -10538,11 +10442,11 @@ function createPredicateImpl(rhs, operator) {
     case "LIKE":
       return getLikePredicate(rhs, "");
     case "NOT LIKE":
-      return not2(getLikePredicate(rhs, ""));
+      return not(getLikePredicate(rhs, ""));
     case "ILIKE":
       return getLikePredicate(rhs, "i");
     case "NOT ILIKE":
-      return not2(getLikePredicate(rhs, "i"));
+      return not(getLikePredicate(rhs, "i"));
     case "IN": {
       assert(Array.isArray(rhs));
       const set = new Set(rhs);
@@ -10558,7 +10462,7 @@ function createPredicateImpl(rhs, operator) {
       throw new Error(`Unexpected operator: ${operator}`);
   }
 }
-function not2(f) {
+function not(f) {
   return (lhs) => !f(lhs);
 }
 function transformFilters(filters) {
@@ -10929,6 +10833,158 @@ var ArrayView = class {
   }
 };
 
+// ../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
+      };
+  }
+}
+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/dnf.ts
 function dnf(condition) {
   return unwrap(dnfInner(condition));
@@ -11596,10 +11652,13 @@ function compilePermissions(schema, authz, expressionBuilders) {
     return void 0;
   }
   const nameMapper = clientToServer(schema.tables);
-  const ret = {};
+  const ret = {
+    protocolVersion: PROTOCOL_VERSION,
+    tables: {}
+  };
   for (const [tableName, tableConfig] of Object.entries(authz)) {
     const serverName = schema.tables[tableName].serverName ?? tableName;
-    ret[serverName] = {
+    ret.tables[serverName] = {
       row: compileRowConfig(
         nameMapper,
         tableName,
@@ -11750,6 +11809,18 @@ 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"),
@@ -11777,7 +11848,7 @@ var connectedMessageSchema = valita_exports.tuple([
 ]);
 var initConnectionBodySchema = valita_exports.object({
   desiredQueriesPatch: queriesPatchSchema,
-  deletedClients: valita_exports.array(valita_exports.string()).optional()
+  deleted: deleteClientsBodySchema.optional()
 });
 var initConnectionMessageSchema = valita_exports.tuple([
   valita_exports.literal("initConnection"),
@@ -11791,15 +11862,6 @@ function encodeSecProtocols(initConnectionMessage, authToken) {
   return encodeURIComponent(btoa(JSON.stringify(protocols)));
 }
 
-// ../zero-protocol/src/delete-clients.ts
-var deleteClientsBodySchema = valita_exports.object({
-  clientIDs: valita_exports.array(valita_exports.string())
-});
-var deleteClientsMessageSchema = valita_exports.tuple([
-  valita_exports.literal("deleteClients"),
-  deleteClientsBodySchema
-]);
-
 // ../zero-protocol/src/error-kind-enum.ts
 var AuthInvalidated = "AuthInvalidated";
 var ClientNotFound = "ClientNotFound";
@@ -12032,11 +12094,6 @@ var downstreamSchema = valita_exports.union(
 var CRUD = "crud";
 var Custom = "custom";
 
-// ../zero-protocol/src/protocol-version.ts
-var PROTOCOL_VERSION = 5;
-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({
@@ -13379,48 +13436,28 @@ 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) => {
-    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 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;
   };
   const mutate = {};
   for (const [name, tableSchema] of Object.entries(schema.tables)) {
-    mutate[name] = makeEntityCRUDMutate(
-      name,
-      tableSchema.primaryKey,
-      zeroCRUD,
-      assertNotInBatch
-    );
+    mutate[name] = makeEntityCRUDMutate(name, tableSchema.primaryKey, zeroCRUD);
   }
   return {
     mutate,
     mutateBatch
   };
 }
-function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD, assertNotInBatch) {
+function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD) {
   return {
     insert: (value) => {
-      assertNotInBatch(tableName, "insert");
       const op = {
         op: "insert",
         tableName,
@@ -13430,7 +13467,6 @@ function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD, assertNotInBatch)
       return zeroCRUD({ ops: [op] });
     },
     upsert: (value) => {
-      assertNotInBatch(tableName, "upsert");
       const op = {
         op: "upsert",
         tableName,
@@ -13440,7 +13476,6 @@ function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD, assertNotInBatch)
       return zeroCRUD({ ops: [op] });
     },
     update: (value) => {
-      assertNotInBatch(tableName, "update");
       const op = {
         op: "update",
         tableName,
@@ -13450,7 +13485,6 @@ function makeEntityCRUDMutate(tableName, primaryKey, zeroCRUD, assertNotInBatch)
       return zeroCRUD({ ops: [op] });
     },
     delete: (id) => {
-      assertNotInBatch(tableName, "delete");
       const op = {
         op: "delete",
         tableName,
@@ -13715,33 +13749,37 @@ var DeleteClientsManager = class {
    * This gets called by Replicache when it deletes clients from the persistent
    * storage.
    */
-  onClientsDeleted(clientIDs) {
+  onClientsDeleted(clientIDs, clientGroupIDs) {
     this.#lc.debug?.("DeletedClientsManager, send:", clientIDs);
-    this.#send(["deleteClients", { 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 deletedClients = await withRead(
+    const deleted = await withRead(
       this.#dagStore,
       (dagRead) => getDeletedClients(dagRead)
     );
-    if (deletedClients.length > 0) {
-      this.#send(["deleteClients", { clientIDs: deletedClients }]);
-      this.#lc.debug?.("DeletedClientsManager, send:", deletedClients);
+    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(clientIDs) {
-    return withWrite(this.#dagStore, async (dagWrite) => {
-      this.#lc.debug?.("clientsDeletedOnServer:", clientIDs);
-      await removeDeletedClients(dagWrite, clientIDs);
-    });
+  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);
@@ -13996,7 +14034,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.14.2025021001";
+var version2 = "0.14.2025021101";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -14981,9 +15019,10 @@ var Zero = class {
    */
   #initConnectionQueries;
   /**
-   * We try to send the deleted clients as part of the sec-protocol header. If we can't
-   * because the header would get to long we keep track of the deleted clients and send
-   * them after the connection is established.
+   * 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;
@@ -15122,7 +15161,7 @@ var Zero = class {
     const replicacheImplOptions = {
       enableClientGroupForking: false,
       enableMutationRecovery: false,
-      onClientsDeleted: (clientIDs) => this.#deleteClientsManager.onClientsDeleted(clientIDs)
+      onClientsDeleted: (clientIDs, clientGroupIDs) => this.#deleteClientsManager.onClientsDeleted(clientIDs, clientGroupIDs)
     };
     const rep = new ReplicacheImpl(replicacheOptions, replicacheImplOptions);
     this.#rep = rep;
@@ -15387,7 +15426,7 @@ var Zero = class {
         break;
       case "deleteClients":
         return this.#deleteClientsManager.clientsDeletedOnServer(
-          downMessage[1].clientIDs
+          downMessage[1]
         );
       default:
         msgType;
@@ -15495,11 +15534,10 @@ var Zero = class {
     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 (this.#deletedClients) {
-        if (this.#deletedClients.length > 0) {
-          send(socket, ["deleteClients", { clientIDs: this.#deletedClients }]);
-        }
+      if (hasDeletedClients()) {
+        send(socket, ["deleteClients", this.#deletedClients]);
         this.#deletedClients = void 0;
       }
     };
@@ -15516,7 +15554,7 @@ var Zero = class {
         "initConnection",
         {
           desiredQueriesPatch: [...queriesPatch.values()],
-          deletedClients: this.#deletedClients && this.#deletedClients.length > 0 ? this.#deletedClients : void 0
+          deleted: skipEmptyDeletedClients(this.#deletedClients)
         }
       ]);
       this.#deletedClients = void 0;
@@ -16089,7 +16127,7 @@ async function createSocket(rep, queryManager, deleteClientsManager, socketOrigi
       "initConnection",
       {
         desiredQueriesPatch: [...queriesPatch.values()],
-        deletedClients: deletedClients.length > 0 ? deletedClients : void 0
+        deleted: skipEmptyDeletedClients(deletedClients)
       }
     ],
     auth
@@ -16107,9 +16145,25 @@ async function createSocket(rep, queryManager, deleteClientsManager, socketOrigi
       secProtocol
     ),
     queriesPatch,
-    deletedClients
+    skipEmptyDeletedClients(deletedClients)
   ];
 }
+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);
@@ -16152,4 +16206,4 @@ export {
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-MVLDKRBK.js.map
+//# sourceMappingURL=chunk-5GWP7BBD.js.map