@fluidframework/presence 2.70.0-361248 → 2.70.0

package/dist/presenceDatastoreManager.d.ts

@@ -30,10 +30,32 @@ export declare function isValueDirectory<T>(obj: ValidatableValueDirectory<T> |
  */
 export interface PresenceDatastoreManager {
     joinSession(clientId: ClientConnectionId): void;
+    onDisconnected(): void;
     getWorkspace<TSchema extends StatesWorkspaceSchema>(internalWorkspaceAddress: `s:${WorkspaceAddress}`, requestedContent: TSchema, controls?: BroadcastControlSettings): StatesWorkspace<TSchema>;
     getWorkspace<TSchema extends NotificationsWorkspaceSchema>(internalWorkspaceAddress: `n:${WorkspaceAddress}`, requestedContent: TSchema): NotificationsWorkspace<TSchema>;
     processSignal(message: InboundExtensionMessage<SignalMessages>, local: boolean, optional: boolean): void;
 }
+/**
+ * Delays used for broadcasting join responses to clients.
+ *
+ * @remarks
+ * Exported for test coordination.
+ * These could be made customizable in the future to accommodate different
+ * session configurations.
+ */
+export declare const broadcastJoinResponseDelaysMs: {
+    /**
+     * The delay in milliseconds before a join response is sent to any client.
+     * This is used to accumulate other join response requests and reduce
+     * network traffic.
+     */
+    readonly namedResponder: 200;
+    /**
+     * The additional delay in milliseconds a backup responder waits before sending
+     * a join response to allow others to respond first.
+     */
+    readonly backupResponderIncrement: 40;
+};
 /**
  * Manages singleton datastore for all Presence.
  */
@@ -46,15 +68,47 @@ export declare class PresenceDatastoreManagerImpl implements PresenceDatastoreMa
     private readonly datastore;
     private averageLatency;
     private returnedMessages;
-    private refreshBroadcastRequested;
-    private readonly timer;
+    private readonly sendMessageTimer;
     private readonly workspaces;
     private readonly targetedSignalSupport;
+    /**
+     * Tracks whether this client has complete snapshot level knowledge and
+     * how that determination was reached.
+     * - "alone": no other audience members detected at join
+     * - "join response": another client has responded to our join request
+     * - "full requests": all others have requested response from us
+     *
+     * @remarks
+     * Only applies when not using targeted join responses.
+     *
+     * Without a complete snapshot, we cannot fully onboard any other clients.
+     * One exception to this is if this client is the only participant in the
+     * session. In such a case, there is no one to respond to the join request.
+     * Another exception is multiple clients attempting to join at the same
+     * time and thus expecting that someone has full knowledge, yet none have
+     * received a complete update to think they are qualified to respond.
+     * Generically if the number of outstanding requestors meets or exceeds the
+     * count of other audience members, then we can consider the snapshot
+     * complete (as all will have provided their own complete information in
+     * their join responses).
+     */
+    private reasonForCompleteSnapshot?;
+    /**
+     * Map of outstanding broadcast (join response) requests.
+     */
+    private readonly broadcastRequests;
+    /**
+     * Timer for managing broadcast (join response) request timing.
+     */
+    private readonly broadcastRequestsTimer;
     constructor(attendeeId: AttendeeId, runtime: IEphemeralRuntime, logger: ITelemetryLoggerExt | undefined, events: IEmitter<PresenceEvents>, presence: Presence, systemWorkspaceDatastore: SystemWorkspaceDatastore, systemWorkspace: AnyWorkspaceEntry<StatesWorkspaceSchema>);
-    joinSession(clientId: ClientConnectionId): void;
+    private getInteractiveMembersExcludingSelf;
+    joinSession(selfClientId: ClientConnectionId): void;
+    onDisconnected(): void;
     getWorkspace<TSchema extends StatesWorkspaceSchema>(internalWorkspaceAddress: InternalWorkspaceAddress, requestedContent: TSchema, controls?: BroadcastControlSettings): AnyWorkspace<TSchema>;
     /**
-     * The combined contents of all queued updates. Will be undefined when no messages are queued.
+     * The combined contents of all queued updates. Will be `"sendAll"` when a
+     * full broadcast is pending or `undefined` when no messages are queued.
      */
     private queuedData;
     /**
@@ -77,6 +131,11 @@ export declare class PresenceDatastoreManagerImpl implements PresenceDatastoreMa
     private stripValidationFromValueData;
     private broadcastAllKnownState;
     processSignal(message: InboundExtensionMessage<SignalMessages>, local: boolean, optional: boolean): void;
+    /**
+     * Broadcasts a join response (complete datastore update message)
+     * if there is an outstanding join response request.
+     */
+    private readonly sendJoinResponseIfStillNeeded;
     /**
      * Handles responding to another client joining the session.
      *

package/dist/presenceDatastoreManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"presenceDatastoreManager.d.ts","sourceRoot":"","sources":["../src/presenceDatastoreManager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"presenceDatastoreManager.d.ts","sourceRoot":"","sources":["../src/presenceDatastoreManager.ts"],"names":[],"mappings":"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"}

package/dist/presenceDatastoreManager.js

@@ -4,7 +4,7 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PresenceDatastoreManagerImpl = exports.isValueDirectory = void 0;
+exports.PresenceDatastoreManagerImpl = exports.broadcastJoinResponseDelaysMs = exports.isValueDirectory = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const internalUtils_js_1 = require("./internalUtils.js");
 const presenceStates_js_1 = require("./presenceStates.js");
@@ -57,6 +57,27 @@ function mergeGeneralDatastoreMessageContent(base, newData) {
     }
     return queueDatastore;
 }
+/**
+ * Delays used for broadcasting join responses to clients.
+ *
+ * @remarks
+ * Exported for test coordination.
+ * These could be made customizable in the future to accommodate different
+ * session configurations.
+ */
+exports.broadcastJoinResponseDelaysMs = {
+    /**
+     * The delay in milliseconds before a join response is sent to any client.
+     * This is used to accumulate other join response requests and reduce
+     * network traffic.
+     */
+    namedResponder: 200,
+    /**
+     * The additional delay in milliseconds a backup responder waits before sending
+     * a join response to allow others to respond first.
+     */
+    backupResponderIncrement: 40,
+};
 /**
  * Manages singleton datastore for all Presence.
  */
@@ -69,17 +90,92 @@ class PresenceDatastoreManagerImpl {
         this.presence = presence;
         this.averageLatency = 0;
         this.returnedMessages = 0;
-        this.refreshBroadcastRequested = false;
-        this.timer = new timerManager_js_1.TimerManager();
+        this.sendMessageTimer = new timerManager_js_1.TimerManager();
         this.workspaces = new Map();
+        /**
+         * Map of outstanding broadcast (join response) requests.
+         */
+        this.broadcastRequests = new Map();
+        /**
+         * Timer for managing broadcast (join response) request timing.
+         */
+        this.broadcastRequestsTimer = new timerManager_js_1.TimerManager();
+        /**
+         * Broadcasts a join response (complete datastore update message)
+         * if there is an outstanding join response request.
+         */
+        this.sendJoinResponseIfStillNeeded = () => {
+            // Make sure we are currently connected and a broadcast is still needed.
+            // If not connected, nothing we can do.
+            if (this.runtime.getJoinedStatus() !== "disconnected" && this.broadcastRequests.size > 0) {
+                // Confirm that of remaining requests, now is the time to respond.
+                const now = Date.now();
+                let minResponseTime = Number.POSITIVE_INFINITY;
+                for (const { deadlineTime } of this.broadcastRequests.values()) {
+                    minResponseTime = Math.min(minResponseTime, deadlineTime);
+                }
+                if (minResponseTime <= now) {
+                    if (this.reasonForCompleteSnapshot) {
+                        this.broadcastAllKnownState();
+                    }
+                }
+                else {
+                    // No response needed yet - schedule a later attempt
+                    this.broadcastRequestsTimer.setTimeout(this.sendJoinResponseIfStillNeeded, minResponseTime - now);
+                }
+            }
+        };
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         this.datastore = { "system:presence": systemWorkspaceDatastore };
         this.workspaces.set("system:presence", systemWorkspace);
         this.targetedSignalSupport = this.runtime.supportedFeatures.has("submit_signals_v2");
+        // If audience member is removed, they won't need a broadcast response.
+        this.runtime.getAudience().on("removeMember", (clientId) => {
+            this.broadcastRequests.delete(clientId);
+        });
+    }
+    getInteractiveMembersExcludingSelf(selfClientId) {
+        const audience = this.runtime.getAudience();
+        const members = audience.getMembers();
+        const all = new Set();
+        const writers = new Set();
+        // Remove self (if present)
+        members.delete(selfClientId);
+        // Gather interactive client IDs
+        for (const [id, client] of members) {
+            if (client.details.capabilities.interactive) {
+                all.add(id);
+                if (client.mode === "write") {
+                    writers.add(id);
+                }
+            }
+        }
+        return {
+            all,
+            writers,
+        };
     }
-    joinSession(clientId) {
+    joinSession(selfClientId) {
+        const interactiveMembersExcludingSelf = this.getInteractiveMembersExcludingSelf(selfClientId);
+        // If there aren't any others connected, then this client must have
+        // complete information.
+        if (interactiveMembersExcludingSelf.all.size === 0) {
+            this.reasonForCompleteSnapshot = "alone";
+            // It would be possible to return at this time and skip ClientJoin
+            // signal. Instead continue in case audience information is
+            // inaccurate. This client might temporarily erroneously believe it
+            // has complete information, but the other(s) should respond to
+            // ClientJoin soon rectifying that and covering for bad incomplete
+            // responses this client sent in the meantime.
+        }
         // Broadcast join message to all clients
-        const updateProviders = [...this.runtime.getQuorum().getMembers().keys()].filter((quorumClientId) => quorumClientId !== clientId);
+        // Select primary update providers
+        // Use write members if any, then fallback to read-only members.
+        const updateProviders = [
+            ...(interactiveMembersExcludingSelf.writers.size > 0
+                ? interactiveMembersExcludingSelf.writers
+                : interactiveMembersExcludingSelf.all),
+        ];
         // Limit to three providers to prevent flooding the network.
         // If none respond, others present will (should) after a delay.
         if (updateProviders.length > 3) {
@@ -94,6 +190,18 @@ class PresenceDatastoreManagerImpl {
                 updateProviders,
             },
         });
+        this.logger?.sendTelemetryEvent({
+            eventName: "JoinRequested",
+            details: {
+                attendeeId: this.attendeeId,
+                connectionId: selfClientId,
+                // Empty updateProviders is indicative of join when alone.
+                updateProviders: JSON.stringify(updateProviders),
+            },
+        });
+    }
+    onDisconnected() {
+        delete this.reasonForCompleteSnapshot;
     }
     getWorkspace(internalWorkspaceAddress, requestedContent, controls) {
         const existing = this.workspaces.get(internalWorkspaceAddress);
@@ -130,9 +238,14 @@ class PresenceDatastoreManagerImpl {
      * the send timer, other messages in the queue, the configured allowed latency, etc.
      */
     enqueueMessage(data, options) {
-        // Merging the message with any queued messages effectively queues the message.
-        // It is OK to queue all incoming messages as long as when we send, we send the queued data.
-        this.queuedData = mergeGeneralDatastoreMessageContent(this.queuedData, data);
+        if (this.queuedData !== "sendAll") {
+            this.queuedData =
+                data === "sendAll"
+                    ? "sendAll"
+                    : // Merging the message with any queued messages effectively queues the message.
+                        // It is OK to queue all incoming messages as long as when we send, we send the queued data.
+                        mergeGeneralDatastoreMessageContent(this.queuedData, data);
+        }
         const { allowableUpdateLatencyMs } = options;
         const now = Date.now();
         const thisMessageDeadline = now + allowableUpdateLatencyMs;
@@ -140,20 +253,20 @@ class PresenceDatastoreManagerImpl {
         // If the timer has not expired, we can short-circuit because the timer will fire
         // and cover this update. In other words, queuing this will be fast enough to
         // meet its deadline, because a timer is already scheduled to fire before its deadline.
-        !this.timer.hasExpired() &&
+        !this.sendMessageTimer.hasExpired() &&
             // If the deadline for this message is later than the overall send deadline, then
             // we can exit early since a timer will take care of sending it.
-            thisMessageDeadline >= this.timer.expireTime) {
+            thisMessageDeadline >= this.sendMessageTimer.expireTime) {
             return;
         }
         // Either we need to send this message immediately, or we need to schedule a timer
         // to fire at the send deadline that will take care of it.
-        // Note that timeoutInMs === allowableUpdateLatency, but the calculation is done this way for clarity.
+        // Note that timeoutInMs === allowableUpdateLatencyMs, but the calculation is done this way for clarity.
         const timeoutInMs = thisMessageDeadline - now;
         const scheduleForLater = timeoutInMs > 0;
         if (scheduleForLater) {
             // Schedule the queued messages to be sent at the updateDeadline
-            this.timer.setTimeout(this.sendQueuedMessage.bind(this), timeoutInMs);
+            this.sendMessageTimer.setTimeout(this.sendQueuedMessage.bind(this), timeoutInMs);
         }
         else {
             this.sendQueuedMessage();
@@ -163,7 +276,7 @@ class PresenceDatastoreManagerImpl {
      * Send any queued signal immediately. Does nothing if no message is queued.
      */
     sendQueuedMessage() {
-        this.timer.clearTimeout();
+        this.sendMessageTimer.clearTimeout();
         if (this.queuedData === undefined) {
             return;
         }
@@ -174,12 +287,16 @@ class PresenceDatastoreManagerImpl {
             this.queuedData = undefined;
             return;
         }
+        if (this.queuedData === "sendAll") {
+            this.broadcastAllKnownState();
+            return;
+        }
         const clientConnectionId = this.runtime.getClientId();
         (0, internal_1.assert)(clientConnectionId !== undefined, 0xa59 /* Client connected without clientId */);
         const currentClientToSessionValueState = 
         // When connected, `clientToSessionId` must always have current connection entry.
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         this.datastore["system:presence"].clientToSessionId[clientConnectionId];
+        (0, internal_1.assert)(currentClientToSessionValueState !== undefined, "Client connection update missing");
         const newMessage = {
             sendTimestamp: Date.now(),
             avgLatency: this.averageLatency,
@@ -252,16 +369,50 @@ class PresenceDatastoreManagerImpl {
         return valueData;
     }
     broadcastAllKnownState() {
+        const content = {
+            sendTimestamp: Date.now(),
+            avgLatency: this.averageLatency,
+            isComplete: true,
+            data: this.stripValidationMetadata(this.datastore),
+        };
+        const primaryRequestors = [];
+        const secondaryRequestors = [];
+        if (this.broadcastRequests.size > 0) {
+            content.joinResponseFor = [...this.broadcastRequests.keys()];
+            if (this.logger) {
+                // Build telemetry data
+                for (const [requestor, { responseOrder }] of this.broadcastRequests.entries()) {
+                    if (responseOrder === undefined) {
+                        primaryRequestors.push(requestor);
+                    }
+                    else {
+                        secondaryRequestors.push([requestor, responseOrder]);
+                    }
+                }
+            }
+            this.broadcastRequests.clear();
+        }
+        // This broadcast will satisfy all requests; clear any remaining timer.
+        this.broadcastRequestsTimer.clearTimeout();
+        this.sendMessageTimer.clearTimeout();
         this.runtime.submitSignal({
             type: protocol_js_1.datastoreUpdateMessageType,
-            content: {
-                sendTimestamp: Date.now(),
-                avgLatency: this.averageLatency,
-                isComplete: true,
-                data: this.stripValidationMetadata(this.datastore),
-            },
+            content,
         });
-        this.refreshBroadcastRequested = false;
+        if (content.joinResponseFor) {
+            this.logger?.sendTelemetryEvent({
+                eventName: "JoinResponse",
+                details: {
+                    type: "broadcastAll",
+                    attendeeId: this.attendeeId,
+                    connectionId: this.runtime.getClientId(),
+                    primaryResponses: JSON.stringify(primaryRequestors),
+                    secondaryResponses: JSON.stringify(secondaryRequestors),
+                },
+            });
+        }
+        // Sending all must account for anything queued before.
+        this.queuedData = undefined;
     }
     processSignal(message, local, optional) {
         const received = Date.now();
@@ -282,8 +433,11 @@ class PresenceDatastoreManagerImpl {
                     this.returnedMessages;
             return;
         }
+        const selfClientId = this.runtime.getClientId();
+        (0, internal_1.assert)(selfClientId !== undefined, "Received signal without clientId");
         const timeModifier = received -
             (this.averageLatency + message.content.avgLatency + message.content.sendTimestamp);
+        const postUpdateActions = [];
         if (message.type === protocol_js_1.joinMessageType) {
             // It is possible for some signals to come in while client is not connected due
             // to how work is scheduled. If we are not connected, we can't respond to the
@@ -295,8 +449,48 @@ class PresenceDatastoreManagerImpl {
             // connected.
         }
         else {
-            if (message.content.isComplete) {
-                this.refreshBroadcastRequested = false;
+            // Update join response requests that are now satisfied.
+            const joinResponseFor = message.content.joinResponseFor;
+            if (joinResponseFor) {
+                let justGainedCompleteSnapshot = false;
+                if (joinResponseFor.includes(selfClientId)) {
+                    if (this.reasonForCompleteSnapshot) {
+                        if (this.reasonForCompleteSnapshot === "alone") {
+                            // No response was expected. This might happen when
+                            // either cautionary ClientJoin signal is received
+                            // by audience member that was unknown.
+                            this.logger?.sendTelemetryEvent({
+                                eventName: "JoinResponseWhenAlone",
+                                details: {
+                                    attendeeId: this.attendeeId,
+                                    connectionId: this.runtime.getClientId(),
+                                },
+                            });
+                        }
+                    }
+                    else {
+                        // If we are the intended recipient of the join response,
+                        // we can consider our knowledge complete and can respond
+                        // to others join requests.
+                        justGainedCompleteSnapshot = true;
+                    }
+                    this.reasonForCompleteSnapshot = "join response";
+                }
+                if (this.broadcastRequests.size > 0) {
+                    for (const responseFor of joinResponseFor) {
+                        this.broadcastRequests.delete(responseFor);
+                    }
+                    if (this.broadcastRequests.size === 0) {
+                        // If no more requests are pending, clear any timer.
+                        this.broadcastRequestsTimer.clearTimeout();
+                    }
+                    else if (justGainedCompleteSnapshot) {
+                        // May or may not be time to respond to remaining requests.
+                        // Clear the timer and recheck after processing.
+                        this.broadcastRequestsTimer.clearTimeout();
+                        postUpdateActions.push(this.sendJoinResponseIfStillNeeded);
+                    }
+                }
             }
             // If the message requests an acknowledgement, we will send a targeted acknowledgement message back to just the requestor.
             if (message.content.acknowledgementId !== undefined) {
@@ -326,7 +520,6 @@ class PresenceDatastoreManagerImpl {
             const internalWorkspaceType = internalWorkspaceTypes[prefix] ?? "Unknown";
             this.events.emit("workspaceActivated", publicWorkspaceAddress, internalWorkspaceType);
         }
-        const postUpdateActions = [];
         // While the system workspace is processed here too, it is declared as
         // conforming to the general schema. So drop its override.
         const data = message.content.data;
@@ -362,67 +555,86 @@ class PresenceDatastoreManagerImpl {
      * correlation with other telemetry where it is often called just `clientId`.
      */
     prepareJoinResponse(updateProviders, requestor) {
-        this.refreshBroadcastRequested = true;
         // We must be connected to receive this message, so clientId should be defined.
-        // If it isn't then, not really a problem; just won't be in provider or quorum list.
+        // If it isn't then, not really a problem; just won't be in provider or audience list.
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const clientId = this.runtime.getClientId();
-        // const requestor = message.clientId;
-        if (updateProviders.includes(clientId)) {
-            // Send all current state to the new client
-            this.broadcastAllKnownState();
-            this.logger?.sendTelemetryEvent({
-                eventName: "JoinResponse",
-                details: {
-                    type: "broadcastAll",
-                    requestor,
-                    role: "primary",
-                },
-            });
-        }
-        else {
+        const selfClientId = this.runtime.getClientId();
+        let joinResponseDelayMs = exports.broadcastJoinResponseDelaysMs.namedResponder;
+        let relativeResponseOrder;
+        if (!updateProviders.includes(selfClientId)) {
             // Schedule a broadcast to the new client after a delay only to send if
-            // another broadcast hasn't been seen in the meantime. The delay is based
-            // on the position in the quorum list. It doesn't have to be a stable
-            // list across all clients. We need something to provide suggested order
-            // to prevent a flood of broadcasts.
-            let relativeResponseOrder;
+            // another broadcast satisfying the request hasn't been seen in the
+            // meantime. The delay is based on the position in the quorum list. It
+            // doesn't have to be a stable list across all clients. We need
+            // something to provide suggested order to prevent a flood of broadcasts.
             const quorumMembers = this.runtime.getQuorum().getMembers();
-            const self = quorumMembers.get(clientId);
+            const self = quorumMembers.get(selfClientId);
             if (self) {
                 // Compute order quorum join order (indicated by sequenceNumber)
                 relativeResponseOrder = 0;
-                for (const { sequenceNumber } of quorumMembers.values()) {
-                    if (sequenceNumber < self.sequenceNumber) {
+                for (const { client, sequenceNumber } of quorumMembers.values()) {
+                    if (sequenceNumber < self.sequenceNumber &&
+                        client.details.capabilities.interactive) {
                         relativeResponseOrder++;
                     }
                 }
             }
             else {
                 // Order past quorum members + arbitrary additional offset up to 10
-                relativeResponseOrder = quorumMembers.size + Math.random() * 10;
-            }
-            // These numbers have been chosen arbitrarily to start with.
-            // 20 is minimum wait time, 20 is the additional wait time per provider
-            // given an chance before us with named providers given more time.
-            const waitTime = 20 + 20 * (3 * updateProviders.length + relativeResponseOrder);
-            setTimeout(() => {
-                // Make sure a broadcast is still needed and we are currently connected.
-                // If not connected, nothing we can do.
-                if (this.refreshBroadcastRequested &&
-                    this.runtime.getJoinedStatus() !== "disconnected") {
-                    this.broadcastAllKnownState();
-                    this.logger?.sendTelemetryEvent({
-                        eventName: "JoinResponse",
-                        details: {
-                            type: "broadcastAll",
-                            requestor,
-                            role: "secondary",
-                            order: relativeResponseOrder,
-                        },
-                    });
+                let possibleQuorumRespondents = 0;
+                for (const { client } of quorumMembers.values()) {
+                    if (client.details.capabilities.interactive) {
+                        possibleQuorumRespondents++;
+                    }
                 }
-            }, waitTime);
+                relativeResponseOrder = possibleQuorumRespondents + Math.random() * 10;
+            }
+            // When not named to provide update, wait an additional amount
+            // of time for those named or others to respond.
+            joinResponseDelayMs +=
+                exports.broadcastJoinResponseDelaysMs.backupResponderIncrement *
+                    (3 * updateProviders.length + relativeResponseOrder);
+        }
+        // Add the requestor to the list of clients that will receive the broadcast.
+        const deadlineTime = Date.now() + joinResponseDelayMs;
+        this.broadcastRequests.set(requestor, {
+            deadlineTime,
+            responseOrder: relativeResponseOrder,
+        });
+        if (!this.reasonForCompleteSnapshot) {
+            // Check if requestor count meets or exceeds count of other audience
+            // members indicating that we effectively have a complete snapshot
+            // (once the current message being processed is processed).
+            const interactiveMembersExcludingSelf = this.getInteractiveMembersExcludingSelf(selfClientId);
+            if (this.broadcastRequests.size >= interactiveMembersExcludingSelf.all.size) {
+                // Note that no action is taken here specifically.
+                // We want action to be queued so that it takes place after
+                // current message is completely processed. All of the actions
+                // below should be delayed (not immediate).
+                this.reasonForCompleteSnapshot = "full requests";
+            }
+        }
+        // Check if capable of full primary response. If requested to provide
+        // primary response, but do not yet have complete snapshot, we need to
+        // delay a full response, until we think we have complete snapshot. In
+        // the meantime we will send partial updates as usual.
+        if (this.reasonForCompleteSnapshot && updateProviders.includes(selfClientId)) {
+            // Use regular message queue to handle timing of the broadcast.
+            // Any more immediate broadcasts will accelerate the response time.
+            // As a primary responder, it is expected that broadcast will happen and
+            // using the regular queue allows other updates to avoid merge work.
+            this.enqueueMessage("sendAll", {
+                allowableUpdateLatencyMs: joinResponseDelayMs,
+            });
+        }
+        else {
+            // Check if there isn't already a timer scheduled to send a join
+            // response with in this request's deadline.
+            if (this.broadcastRequestsTimer.hasExpired() ||
+                deadlineTime < this.broadcastRequestsTimer.expireTime) {
+                // Set or update the timer.
+                this.broadcastRequestsTimer.setTimeout(this.sendJoinResponseIfStillNeeded, joinResponseDelayMs);
+            }
         }
     }
 }