@rocicorp/zero 0.22.2025063000 → 0.22.2025070600

package/out/{chunk-WOYR3FAT.js → chunk-ZGVTOORV.js}

@@ -126,7 +126,7 @@ import {
   withWrite,
   withWriteNoImplicitCommit,
   wrapIterable
-} from "./chunk-CESYRWV4.js";
+} from "./chunk-U52OBQ2U.js";
 import {
   __export
 } from "./chunk-424PT5DM.js";
@@ -5841,7 +5841,7 @@ var SchemaVersionNotSupported2 = "SchemaVersionNotSupported";
 
 // ../zero-client/src/client/zero.ts
 import "@rocicorp/logger";
-import { resolver as resolver8 } from "@rocicorp/resolver";
+import { resolver as resolver9 } from "@rocicorp/resolver";
 
 // ../zero-protocol/src/delete-clients.ts
 var deleteClientsBodySchema = valita_exports.union(
@@ -5900,7 +5900,14 @@ var initConnectionBodySchema = valita_exports.object({
   desiredQueriesPatch: upQueriesPatchSchema,
   clientSchema: clientSchemaSchema.optional(),
   deleted: deleteClientsBodySchema.optional(),
-  userPushParams: userPushParamsSchema.optional()
+  userPushParams: userPushParamsSchema.optional(),
+  /**
+   * `activeClients` is an optional array of client IDs that are currently active
+   * in the client group. This is used to inform the server about the clients
+   * that are currently active (aka running, aka alive), so it can inactive
+   * queries from inactive clients.
+   */
+  activeClients: valita_exports.array(valita_exports.string()).optional()
 });
 var initConnectionMessageSchema = valita_exports.tuple([
   valita_exports.literal("initConnection"),
@@ -6241,7 +6248,7 @@ var downstreamSchema = valita_exports.union(
 );
 
 // ../zero-protocol/src/protocol-version.ts
-var PROTOCOL_VERSION = 18;
+var PROTOCOL_VERSION = 20;
 var MIN_SERVER_SUPPORTED_SYNC_PROTOCOL = 6;
 assert(MIN_SERVER_SUPPORTED_SYNC_PROTOCOL < PROTOCOL_VERSION);
 
@@ -6338,6 +6345,201 @@ function send(ws, data) {
   ws.send(JSON.stringify(data));
 }
 
+// ../zero-client/src/client/active-clients-manager.ts
+import { resolver as resolver7 } from "@rocicorp/resolver";
+var keyPrefix = "zero-active";
+function toLockName(clientGroupID, clientID) {
+  return `${keyPrefix}/${clientGroupID}/${clientID}`;
+}
+function toBroadcastChannelName(clientGroupID) {
+  return `${keyPrefix}/${clientGroupID}`;
+}
+function fromLockName(lockKey) {
+  if (!lockKey || !lockKey.startsWith(keyPrefix)) {
+    return void 0;
+  }
+  const parts = lockKey.slice(keyPrefix.length).split("/");
+  if (parts.length !== 3) {
+    return void 0;
+  }
+  return {
+    clientGroupID: parts[1],
+    clientID: parts[2]
+  };
+}
+function ignoreAbortError(e) {
+  if (e instanceof Error && e.name === "AbortError") {
+    return;
+  }
+  throw e;
+}
+var ActiveClientsManager = class _ActiveClientsManager {
+  clientGroupID;
+  clientID;
+  #resolver = resolver7();
+  #lockManager;
+  #activeClients = /* @__PURE__ */ new Set();
+  /**
+   * A callback that is called when a client is added to the client group.
+   * It receives the client ID of the added client.
+   */
+  onAdd;
+  /**
+   * A callback that is called when a client is deleted from the client group.
+   * It receives the client ID of the deleted client.
+   */
+  onDelete;
+  /**
+   * Creates an instance of `ActiveClientsManager` for the specified client
+   * group and client ID. It will return a promise that resolves when the
+   * instance is ready to use, which means that it has successfully acquired the
+   * exclusive lock for the client and has retrieved the list of active clients.
+   */
+  static async create(clientGroupID, clientID, signal) {
+    const instance = new _ActiveClientsManager(clientGroupID, clientID, signal);
+    await instance.#init(clientGroupID, clientID, signal);
+    return instance;
+  }
+  constructor(clientGroupID, clientID, signal) {
+    this.clientGroupID = clientGroupID;
+    this.clientID = clientID;
+    this.#lockManager = getClientLockManager(signal);
+    this.#activeClients.add(clientID);
+  }
+  async #init(clientGroupID, clientID, signal) {
+    const name = toLockName(clientGroupID, clientID);
+    const channel = new bc(toBroadcastChannelName(clientGroupID));
+    channel.addEventListener(
+      "message",
+      (e) => {
+        const client = fromLockName(e.data);
+        if (client?.clientGroupID === this.clientGroupID) {
+          this.#addClient(client.clientID);
+        }
+      },
+      { signal }
+    );
+    this.#lockManager.request(name, "exclusive", () => this.#resolver.promise).catch(ignoreAbortError);
+    signal.addEventListener(
+      "abort",
+      () => {
+        this.#lockManager.release(name, () => this.#resolver.resolve());
+        channel.close();
+      },
+      { once: true }
+    );
+    for (const clientID2 of await this.#getActiveClients()) {
+      if (clientID2 !== this.clientID) {
+        this.#addClient(clientID2);
+      }
+    }
+    if (!signal.aborted) {
+      channel.postMessage(name);
+    }
+  }
+  get activeClients() {
+    return this.#activeClients;
+  }
+  async #getActiveClients() {
+    const activeClients = /* @__PURE__ */ new Set();
+    for await (const lockName of this.#lockManager.queryExclusive()) {
+      const client = fromLockName(lockName);
+      if (client?.clientGroupID === this.clientGroupID) {
+        activeClients.add(client.clientID);
+      }
+    }
+    return activeClients;
+  }
+  /**
+   * This gets called when a new client is added to the client group.
+   *
+   * It will request a shared lock for the client, and when the exclusive lock
+   * is released, it will notify that the client has been deactivated.
+   */
+  #addSharedLockForOtherClient(clientID) {
+    const name = toLockName(this.clientGroupID, clientID);
+    this.#lockManager.request(name, "shared", () => this.#removeClient(clientID)).catch(ignoreAbortError);
+  }
+  #addClient(clientID) {
+    if (!this.#activeClients.has(clientID)) {
+      this.#activeClients.add(clientID);
+      this.#addSharedLockForOtherClient(clientID);
+      this.onAdd?.(clientID);
+    }
+  }
+  #removeClient(clientID) {
+    if (this.#activeClients.delete(clientID)) {
+      this.onDelete?.(clientID);
+    }
+  }
+};
+function getClientLockManager(signal) {
+  const locks = getBrowserGlobal("navigator")?.locks;
+  if (locks) {
+    return new NativeClientLockManager(locks, signal);
+  }
+  return new MockClientLockManager();
+}
+var NativeClientLockManager = class {
+  #locks;
+  #signal;
+  constructor(locks, signal) {
+    this.#locks = locks;
+    this.#signal = signal;
+  }
+  request(name, mode, fn) {
+    return this.#locks.request(name, { mode, signal: this.#signal }, fn);
+  }
+  release(_name, fn) {
+    fn();
+  }
+  async *queryExclusive() {
+    const snapshot = await this.#locks.query();
+    for (const lock of [
+      ...snapshot.held ?? [],
+      ...snapshot.pending ?? []
+    ]) {
+      if (lock.mode === "exclusive" && lock.name) {
+        yield lock.name;
+      }
+    }
+  }
+};
+var mockLockNames = /* @__PURE__ */ new Set();
+var mockListeners = /* @__PURE__ */ new Set();
+var MockClientLockManager = class {
+  #listeners = /* @__PURE__ */ new Set();
+  request(name, mode, fn) {
+    if (mode === "exclusive") {
+      mockLockNames.add(name);
+    } else {
+      mode;
+      const listener = (removed) => {
+        if (removed === name) {
+          mockListeners.delete(listener);
+          return fn();
+        }
+      };
+      mockListeners.add(listener);
+      this.#listeners.add(listener);
+    }
+    return Promise.resolve();
+  }
+  release(name, fn) {
+    mockLockNames.delete(name);
+    for (const listener of mockListeners) {
+      listener(name);
+    }
+    for (const listener of this.#listeners) {
+      mockListeners.delete(listener);
+    }
+    fn();
+  }
+  async *queryExclusive() {
+    yield* mockLockNames;
+  }
+};
+
 // ../zero-client/src/client/connection-state-enum.ts
 var Disconnected = 0;
 var Connecting = 1;
@@ -7580,6 +7782,7 @@ var ZeroContext = class {
   #addCustomQuery;
   #updateQuery;
   #updateCustomQuery;
+  #flushQueryChanges;
   #batchViewUpdates;
   #commitListeners = /* @__PURE__ */ new Set();
   #slowMaterializeThreshold;
@@ -7590,7 +7793,7 @@ var ZeroContext = class {
    * "complete" once the server has sent back the query result.
    */
   defaultQueryComplete = false;
-  constructor(lc, mainSources, addQuery, addCustomQuery, updateQuery, updateCustomQuery, batchViewUpdates, slowMaterializeThreshold, assertValidRunOptions3) {
+  constructor(lc, mainSources, addQuery, addCustomQuery, updateQuery, updateCustomQuery, flushQueryChanges, batchViewUpdates, slowMaterializeThreshold, assertValidRunOptions3) {
     this.#mainSources = mainSources;
     this.#addQuery = addQuery;
     this.#updateQuery = updateQuery;
@@ -7600,6 +7803,7 @@ var ZeroContext = class {
     this.#slowMaterializeThreshold = slowMaterializeThreshold;
     this.assertValidRunOptions = assertValidRunOptions3;
     this.#addCustomQuery = addCustomQuery;
+    this.#flushQueryChanges = flushQueryChanges;
   }
   getSource(name) {
     return this.#mainSources.getSource(name);
@@ -7621,6 +7825,9 @@ var ZeroContext = class {
   updateCustomQuery(customQueryID, ttl) {
     this.#updateCustomQuery(customQueryID.name, customQueryID.args, ttl);
   }
+  flushQueryChanges() {
+    this.#flushQueryChanges();
+  }
   onQueryMaterialized(hash, ast, duration) {
     if (this.#slowMaterializeThreshold !== void 0 && duration > this.#slowMaterializeThreshold) {
       this.#lc.warn?.(
@@ -7984,6 +8191,7 @@ function makeSchemaQuery(lc, schema, ivmBranch, slowMaterializeThreshold) {
     () => emptyFunction,
     emptyFunction,
     emptyFunction,
+    emptyFunction,
     (applyViewUpdates) => applyViewUpdates(),
     slowMaterializeThreshold,
     assertValidRunOptions
@@ -8331,7 +8539,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.22.2025063000";
+var version2 = "0.22.2025070600";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -8626,7 +8834,7 @@ var State = class {
 };
 
 // ../zero-client/src/client/mutation-tracker.ts
-import { resolver as resolver7 } from "@rocicorp/resolver";
+import { resolver as resolver8 } from "@rocicorp/resolver";
 var transientPushErrorTypes = [
   "zeroPusher",
   "http",
@@ -8656,7 +8864,7 @@ var MutationTracker = class {
   }
   trackMutation() {
     const id = nextEphemeralID();
-    const mutationResolver = resolver7();
+    const mutationResolver = resolver8();
     this.#outstandingMutations.set(id, {
       resolver: mutationResolver
     });
@@ -8820,13 +9028,17 @@ var QueryManager = class {
   #recentQueries = /* @__PURE__ */ new Set();
   #gotQueries = /* @__PURE__ */ new Set();
   #mutationTracker;
+  #pendingQueryChanges = [];
+  #queryChangeThrottleMs;
   #pendingRemovals = [];
-  constructor(mutationTracker, clientID, tables, send2, experimentalWatch, recentQueriesMaxSize) {
+  #batchTimer;
+  constructor(mutationTracker, clientID, tables, send2, experimentalWatch, recentQueriesMaxSize, queryChangeThrottleMs) {
     this.#clientID = clientID;
     this.#clientToServer = clientToServer(tables);
     this.#recentQueriesMaxSize = recentQueriesMaxSize;
     this.#send = send2;
     this.#mutationTracker = mutationTracker;
+    this.#queryChangeThrottleMs = queryChangeThrottleMs;
     this.#mutationTracker.onAllMutationsConfirmed(() => {
       if (this.#pendingRemovals.length === 0) {
         return;
@@ -8965,21 +9177,14 @@ var QueryManager = class {
         ttl
       };
       this.#queries.set(queryId, entry);
-      this.#send([
-        "changeDesiredQueries",
-        {
-          desiredQueriesPatch: [
-            {
-              op: "put",
-              hash: queryId,
-              ast: normalized,
-              name,
-              args,
-              ttl: parseTTL(ttl)
-            }
-          ]
-        }
-      ]);
+      this.#queueQueryChange({
+        op: "put",
+        hash: queryId,
+        ast: normalized,
+        name,
+        args,
+        ttl: parseTTL(ttl)
+      });
     } else {
       ++entry.count;
       this.#updateEntry(entry, queryId, ttl);
@@ -9019,21 +9224,41 @@ var QueryManager = class {
   #updateEntry(entry, hash, ttl) {
     if (compareTTL(ttl, entry.ttl) > 0) {
       entry.ttl = ttl;
+      this.#queueQueryChange({
+        op: "put",
+        hash,
+        ast: entry.normalized,
+        name: entry.name,
+        args: entry.args,
+        ttl: parseTTL(ttl)
+      });
+    }
+  }
+  #queueQueryChange(op) {
+    this.#pendingQueryChanges.push(op);
+    this.#scheduleBatch();
+  }
+  #scheduleBatch() {
+    if (this.#batchTimer === void 0) {
+      this.#batchTimer = setTimeout(
+        () => this.flushBatch(),
+        this.#queryChangeThrottleMs
+      );
+    }
+  }
+  flushBatch() {
+    if (this.#batchTimer !== void 0) {
+      clearTimeout(this.#batchTimer);
+      this.#batchTimer = void 0;
+    }
+    if (this.#pendingQueryChanges.length > 0) {
       this.#send([
         "changeDesiredQueries",
         {
-          desiredQueriesPatch: [
-            {
-              op: "put",
-              hash,
-              ast: entry.normalized,
-              name: entry.name,
-              args: entry.args,
-              ttl: parseTTL(ttl)
-            }
-          ]
+          desiredQueriesPatch: [...this.#pendingQueryChanges]
         }
       ]);
+      this.#pendingQueryChanges.length = 0;
     }
   }
   #remove(entry, astHash, gotCallback) {
@@ -9049,12 +9274,7 @@ var QueryManager = class {
         assert(lruAstHash);
         this.#queries.delete(lruAstHash);
         this.#recentQueries.delete(lruAstHash);
-        this.#send([
-          "changeDesiredQueries",
-          {
-            desiredQueriesPatch: [{ op: "del", hash: lruAstHash }]
-          }
-        ]);
+        this.#queueQueryChange({ op: "del", hash: lruAstHash });
       }
     }
   }
@@ -9600,6 +9820,7 @@ var DEFAULT_DISCONNECT_HIDDEN_DELAY_MS = 5e3;
 var CONNECT_TIMEOUT_MS = 1e4;
 var CHECK_CONNECTIVITY_ON_ERROR_FREQUENCY = 6;
 var NULL_LAST_MUTATION_ID_SENT = { clientID: "", id: -1 };
+var DEFAULT_QUERY_CHANGE_THROTTLE_MS = 10;
 function convertOnUpdateNeededReason(reason) {
   return { type: reason.type };
 }
@@ -9684,12 +9905,12 @@ var Zero = class _Zero {
   };
   #zeroContext;
   queryDelegate;
-  #connectResolver = resolver8();
+  #connectResolver = resolver9();
   #pendingPullsByRequestID = /* @__PURE__ */ new Map();
   #lastMutationIDReceived = 0;
   #socket = void 0;
-  #socketResolver = resolver8();
-  #connectionStateChangeResolver = resolver8();
+  #socketResolver = resolver9();
+  #connectionStateChangeResolver = resolver9();
   /**
    * This resolver is only used for rejections. It is awaited in the connected
    * state (including when waiting for a pong). It is rejected when we get an
@@ -9700,13 +9921,14 @@ var Zero = class _Zero {
   #visibilityWatcher;
   // We use an accessor pair to allow the subclass to override the setter.
   #connectionState = Disconnected;
+  #activeClientsManager;
   #setConnectionState(state) {
     if (state === this.#connectionState) {
       return;
     }
     this.#connectionState = state;
     this.#connectionStateChangeResolver.resolve(state);
-    this.#connectionStateChangeResolver = resolver8();
+    this.#connectionStateChangeResolver = resolver9();
     if (false) {
       asTestZero(this)[onSetConnectionStateSymbol]?.(state);
     }
@@ -9866,6 +10088,7 @@ var Zero = class _Zero {
       (queryName, queryArgs, ttl, gotCallback) => this.#queryManager.addCustom(queryName, queryArgs, ttl, gotCallback),
       (ast, ttl) => this.#queryManager.updateLegacy(ast, ttl),
       (name, args, ttl) => this.#queryManager.updateCustom(name, args, ttl),
+      () => this.#queryManager.flushBatch(),
       batchViewUpdates,
       slowMaterializeThreshold,
       assertValidRunOptions2
@@ -9893,6 +10116,12 @@ var Zero = class _Zero {
     this.userID = userID;
     this.#lc = lc.withContext("clientID", rep.clientID);
     this.#mutationTracker.clientID = rep.clientID;
+    this.#activeClientsManager = makeActiveClientsManager(
+      rep.clientGroupID,
+      this.clientID,
+      this.#closeAbortController.signal,
+      (clientID) => this.#deleteClientsManager.onClientsDeleted([clientID], [])
+    );
     const onUpdateNeededCallback = (reason, serverErrorMsg) => {
       if (onUpdateNeeded) {
         onUpdateNeeded(reason);
@@ -9948,7 +10177,8 @@ var Zero = class _Zero {
       schema.tables,
       (msg) => this.#send(msg),
       rep.experimentalWatch.bind(rep),
-      maxRecentQueries
+      maxRecentQueries,
+      options.queryChangeThrottleMs ?? DEFAULT_QUERY_CHANGE_THROTTLE_MS
     );
     this.#clientToServer = clientToServer(schema.tables);
     this.#deleteClientsManager = new DeleteClientsManager(
@@ -10124,21 +10354,12 @@ var Zero = class _Zero {
     const lc = this.#lc.withContext("close");
     lc.debug?.("Closing Zero instance. Stack:", new Error().stack);
     if (this.#connectionState !== Disconnected) {
-      let closeReason = JSON.stringify([
-        "closeConnection",
-        []
-      ]);
-      if (closeReason.length > 123) {
-        lc.warn?.("Close reason is too long. Removing it.");
-        closeReason = "";
-      }
       this.#disconnect(
         lc,
         {
           client: "ClientClosed"
         },
-        CLOSE_CODE_NORMAL,
-        closeReason
+        CLOSE_CODE_NORMAL
       );
     }
     lc.debug?.("Aborting closeAbortController due to close()");
@@ -10148,15 +10369,6 @@ var Zero = class _Zero {
     this.#unexpose();
     return ret;
   }
-  #onPageHide = (e) => {
-    if (e.persisted) {
-      this.#lc.debug?.("Ignoring pagehide event because it was persisted");
-    } else {
-      this.#lc.debug?.("Closing client because we got a clean close");
-      this.close().catch(() => {
-      });
-    }
-  };
   #onMessage = (e) => {
     const lc = this.#lc;
     lc.debug?.("received message", e.data);
@@ -10417,7 +10629,8 @@ var Zero = class _Zero {
       lc,
       this.#options.push,
       this.#options.maxHeaderLength,
-      additionalConnectParams
+      additionalConnectParams,
+      await this.#activeClientsManager
     );
     if (this.closed) {
       return;
@@ -10429,10 +10642,6 @@ var Zero = class _Zero {
     ws.addEventListener("close", this.#onClose);
     this.#socket = ws;
     this.#socketResolver.resolve(ws);
-    getBrowserGlobal("window")?.addEventListener?.(
-      "pagehide",
-      this.#onPageHide
-    );
     try {
       lc.debug?.("Waiting for connection to be acknowledged");
       await this.#connectResolver.promise;
@@ -10447,7 +10656,7 @@ var Zero = class _Zero {
       );
     }
   }
-  #disconnect(lc, reason, closeCode, closeReason) {
+  #disconnect(lc, reason, closeCode) {
     if (this.#connectionState === Connecting) {
       this.#connectErrorCount++;
     }
@@ -10491,9 +10700,9 @@ var Zero = class _Zero {
         lc.error?.("disconnect() called while disconnected");
         break;
     }
-    this.#socketResolver = resolver8();
+    this.#socketResolver = resolver9();
     lc.debug?.("Creating new connect resolver");
-    this.#connectResolver = resolver8();
+    this.#connectResolver = resolver9();
     this.#setConnectionState(Disconnected);
     this.#messageCount = 0;
     this.#connectStart = void 0;
@@ -10501,14 +10710,10 @@ var Zero = class _Zero {
     this.#socket?.removeEventListener("message", this.#onMessage);
     this.#socket?.removeEventListener("open", this.#onOpen);
     this.#socket?.removeEventListener("close", this.#onClose);
-    this.#socket?.close(closeCode, closeReason);
+    this.#socket?.close(closeCode);
     this.#socket = void 0;
     this.#lastMutationIDSent = NULL_LAST_MUTATION_ID_SENT;
     this.#pokeHandler.handleDisconnect();
-    getBrowserGlobal("window")?.removeEventListener?.(
-      "pagehide",
-      this.#onPageHide
-    );
   }
   #handlePokeStart(_lc, pokeMessage) {
     this.#abortPingTimeout();
@@ -10544,12 +10749,12 @@ var Zero = class _Zero {
     const body = pullResponseMessage[1];
     lc = lc.withContext("requestID", body.requestID);
     lc.debug?.("Handling pull response", body);
-    const resolver9 = this.#pendingPullsByRequestID.get(body.requestID);
-    if (!resolver9) {
+    const resolver10 = this.#pendingPullsByRequestID.get(body.requestID);
+    if (!resolver10) {
       lc.debug?.("No resolver found");
       return;
     }
-    resolver9.resolve(pullResponseMessage[1]);
+    resolver10.resolve(pullResponseMessage[1]);
   }
   async #pusher(req, requestID) {
     assert(req.pushVersion === 1);
@@ -10680,7 +10885,7 @@ var Zero = class _Zero {
               PING_INTERVAL_MS,
               controller.signal
             );
-            this.#rejectMessageError = resolver8();
+            this.#rejectMessageError = resolver9();
             const PING = 0;
             const HIDDEN = 2;
             const raceResult = await promiseRace([
@@ -10790,7 +10995,7 @@ var Zero = class _Zero {
       }
     ];
     send(socket, pullRequestMessage);
-    const pullResponseResolver = resolver8();
+    const pullResponseResolver = resolver9();
     this.#pendingPullsByRequestID.set(requestID, pullResponseResolver);
     try {
       const TIMEOUT = 0;
@@ -10848,7 +11053,7 @@ var Zero = class _Zero {
    */
   async #ping(lc, messageErrorRejectionPromise) {
     lc.debug?.("pinging");
-    const { promise, resolve } = resolver8();
+    const { promise, resolve } = resolver9();
     this.#onPong = resolve;
     const pingMessage = ["ping", {}];
     const t0 = performance.now();
@@ -10894,7 +11099,7 @@ var Zero = class _Zero {
    */
   async inspect() {
     BUNDLE_SIZE: {
-      const m = await import("./inspector-LF6RTN44.js");
+      const m = await import("./inspector-XJ4IL4MG.js");
       return m.newInspector(this.#rep, this.#schema, async () => {
         await this.#connectResolver.promise;
         return this.#socket;
@@ -10902,7 +11107,7 @@ var Zero = class _Zero {
     }
   }
 };
-async function createSocket(rep, queryManager, deleteClientsManager, socketOrigin, baseCookie, clientID, clientGroupID, clientSchema, userID, auth, lmid, wsid, debugPerf, lc, userPushParams, maxHeaderLength = 1024 * 8, additionalConnectParams) {
+async function createSocket(rep, queryManager, deleteClientsManager, socketOrigin, baseCookie, clientID, clientGroupID, clientSchema, userID, auth, lmid, wsid, debugPerf, lc, userPushParams, maxHeaderLength = 1024 * 8, additionalConnectParams, activeClientsManager) {
   const url = new URL(
     appendPath(socketOrigin, `/sync/v${PROTOCOL_VERSION}/connect`)
   );
@@ -10931,6 +11136,7 @@ async function createSocket(rep, queryManager, deleteClientsManager, socketOrigi
   const queriesPatchP = rep.query((tx) => queryManager.getQueriesPatch(tx));
   let deletedClients = await deleteClientsManager.getDeletedClients();
   let queriesPatch = await queriesPatchP;
+  const { activeClients } = activeClientsManager;
   let secProtocol = encodeSecProtocols(
     [
       "initConnection",
@@ -10940,7 +11146,8 @@ async function createSocket(rep, queryManager, deleteClientsManager, socketOrigi
         // The clientSchema only needs to be sent for the very first request.
         // Henceforth it is stored with the CVR and verified automatically.
         ...baseCookie === null ? { clientSchema } : {},
-        userPushParams
+        userPushParams,
+        activeClients: [...activeClients]
       }
     ],
     auth
@@ -11001,6 +11208,15 @@ var CloseError = class extends Error {
 };
 function assertValidRunOptions2(_options) {
 }
+async function makeActiveClientsManager(clientGroupID, clientID, signal, onDelete) {
+  const manager = await ActiveClientsManager.create(
+    await clientGroupID,
+    clientID,
+    signal
+  );
+  manager.onDelete = onDelete;
+  return manager;
+}
 
 export {
   getDefaultPuller,
@@ -11021,4 +11237,4 @@ export {
   update_needed_reason_type_enum_exports,
   Zero
 };
-//# sourceMappingURL=chunk-WOYR3FAT.js.map
+//# sourceMappingURL=chunk-ZGVTOORV.js.map