@fluidframework/container-loader 2.0.0-dev.5.3.2.178189 → 2.0.0-dev.6.4.0.191258

package/dist/connectionManager.js

@@ -3,14 +3,10 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectionManager = void 0;
-const abort_controller_1 = __importDefault(require("abort-controller"));
-const common_utils_1 = require("@fluidframework/common-utils");
-const container_utils_1 = require("@fluidframework/container-utils");
+const core_utils_1 = require("@fluidframework/core-utils");
+const client_utils_1 = require("@fluid-internal/client-utils");
 const driver_utils_1 = require("@fluidframework/driver-utils");
 const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
@@ -18,7 +14,6 @@ const contracts_1 = require("./contracts");
 const deltaQueue_1 = require("./deltaQueue");
 const protocol_1 = require("./protocol");
 const utils_1 = require("./utils");
-const MaxReconnectDelayInMs = 8000;
 const InitialReconnectDelayInMs = 1000;
 const DefaultChunkSize = 16 * 1024;
 const fatalConnectErrorProp = { fatalConnectError: true };
@@ -40,7 +35,7 @@ const clientNoDeltaStream = {
     scopes: [],
 };
 const clientIdNoDeltaStream = "storage-only client";
-class NoDeltaStream extends common_utils_1.TypedEventEmitter {
+class NoDeltaStream extends client_utils_1.TypedEventEmitter {
     constructor(storageOnlyReason) {
         super();
         this.storageOnlyReason = storageOnlyReason;
@@ -89,9 +84,8 @@ function isNoDeltaStreamConnection(connection) {
     return connection instanceof NoDeltaStream;
 }
 const waitForOnline = async () => {
-    var _a;
     // Only wait if we have a strong signal that we're offline - otherwise assume we're online.
-    if (((_a = globalThis.navigator) === null || _a === void 0 ? void 0 : _a.onLine) === false && globalThis.addEventListener !== undefined) {
+    if (globalThis.navigator?.onLine === false && globalThis.addEventListener !== undefined) {
         return new Promise((resolve) => {
             const resolveAndRemoveListener = () => {
                 resolve();
@@ -175,15 +169,13 @@ class ConnectionManager {
      * The current connection mode, initially read.
      */
     get connectionMode() {
-        var _a, _b;
-        return (_b = (_a = this.connection) === null || _a === void 0 ? void 0 : _a.mode) !== null && _b !== void 0 ? _b : "read";
+        return this.connection?.mode ?? "read";
     }
     get connected() {
         return this.connection !== undefined;
     }
     get clientId() {
-        var _a;
-        return (_a = this.connection) === null || _a === void 0 ? void 0 : _a.clientId;
+        return this.connection?.clientId;
     }
     /**
      * Automatic reconnecting enabled or disabled.
@@ -193,8 +185,7 @@ class ConnectionManager {
         return this._reconnectMode;
     }
     get maxMessageSize() {
-        var _a, _b, _c;
-        return (_c = (_b = (_a = this.connection) === null || _a === void 0 ? void 0 : _a.serviceConfiguration) === null || _b === void 0 ? void 0 : _b.maxMessageSize) !== null && _c !== void 0 ? _c : DefaultChunkSize;
+        return this.connection?.serviceConfiguration?.maxMessageSize ?? DefaultChunkSize;
     }
     get version() {
         if (this.connection === undefined) {
@@ -203,12 +194,10 @@ class ConnectionManager {
         return this.connection.version;
     }
     get serviceConfiguration() {
-        var _a;
-        return (_a = this.connection) === null || _a === void 0 ? void 0 : _a.serviceConfiguration;
+        return this.connection?.serviceConfiguration;
     }
     get scopes() {
-        var _a;
-        return (_a = this.connection) === null || _a === void 0 ? void 0 : _a.claims.scopes;
+        return this.connection?.claims.scopes;
     }
     get outbound() {
         return this._outbound;
@@ -220,9 +209,11 @@ class ConnectionManager {
     get connectionProps() {
         return this.connection !== undefined
             ? this._connectionProps
-            : Object.assign(Object.assign({}, this._connectionProps), { 
+            : {
+                ...this._connectionProps,
                 // Report how many ops this client sent in last disconnected session
-                sentOps: this.clientSequenceNumber });
+                sentOps: this.clientSequenceNumber,
+            };
     }
     shouldJoinWrite() {
         // We don't have to wait for ack for topmost NoOps. So subtract those.
@@ -292,26 +283,30 @@ class ConnectionManager {
         // Ensure that things like triggerConnect() will short circuit
         this._reconnectMode = contracts_1.ReconnectMode.Never;
         this._outbound.clear();
-        const disconnectReason = "Closing DeltaManager";
+        const disconnectReason = {
+            text: "Closing DeltaManager",
+            error,
+        };
+        const oldReadonlyValue = this.readonly;
         // This raises "disconnect" event if we have active connection.
         this.disconnectFromDeltaStream(disconnectReason);
         if (switchToReadonly) {
             // Notify everyone we are in read-only state.
             // Useful for data stores in case we hit some critical error,
             // to switch to a mode where user edits are not accepted
-            this.set_readonlyPermissions(true);
+            this.set_readonlyPermissions(true, oldReadonlyValue);
         }
     }
     /**
      * Enables or disables automatic reconnecting.
      * Will throw an error if reconnectMode set to Never.
      */
-    setAutoReconnect(mode) {
-        (0, common_utils_1.assert)(mode !== contracts_1.ReconnectMode.Never && this._reconnectMode !== contracts_1.ReconnectMode.Never, 0x278 /* "API is not supported for non-connecting or closed container" */);
+    setAutoReconnect(mode, reason) {
+        (0, core_utils_1.assert)(mode !== contracts_1.ReconnectMode.Never && this._reconnectMode !== contracts_1.ReconnectMode.Never, 0x278 /* "API is not supported for non-connecting or closed container" */);
         this._reconnectMode = mode;
         if (mode !== contracts_1.ReconnectMode.Enabled) {
             // immediately disconnect - do not rely on service eventually dropping connection.
-            this.disconnectFromDeltaStream("setAutoReconnect");
+            this.disconnectFromDeltaStream(reason);
         }
     }
     /**
@@ -342,7 +337,7 @@ class ConnectionManager {
         this._forceReadonly = readonly;
         if (oldValue !== this.readonly) {
             if (this._reconnectMode === contracts_1.ReconnectMode.Never) {
-                throw new container_utils_1.UsageError("API is not supported for non-connecting or closed container");
+                throw new telemetry_utils_1.UsageError("API is not supported for non-connecting or closed container");
             }
             let reconnect = false;
             if (this.readonly === true) {
@@ -354,31 +349,29 @@ class ConnectionManager {
                     // host logic error.
                     this.logger.sendErrorEvent({ eventName: "ForceReadonlyPendingChanged" });
                 }
-                reconnect = this.disconnectFromDeltaStream("Force readonly");
+                reconnect = this.disconnectFromDeltaStream({ text: "Force readonly" });
             }
             this.props.readonlyChangeHandler(this.readonly);
             if (reconnect) {
                 // reconnect if we disconnected from before.
-                this.triggerConnect("Force Readonly", "read");
+                this.triggerConnect({ text: "Force Readonly" }, "read");
             }
         }
     }
-    set_readonlyPermissions(readonly) {
-        const oldValue = this.readonly;
-        this._readonlyPermissions = readonly;
-        if (oldValue !== this.readonly) {
+    set_readonlyPermissions(newReadonlyValue, oldReadonlyValue) {
+        this._readonlyPermissions = newReadonlyValue;
+        if (oldReadonlyValue !== this.readonly) {
             this.props.readonlyChangeHandler(this.readonly);
         }
     }
     connect(reason, connectionMode) {
-        this.connectCore(reason, connectionMode).catch((error) => {
-            const normalizedError = (0, telemetry_utils_1.normalizeError)(error, { props: fatalConnectErrorProp });
+        this.connectCore(reason, connectionMode).catch((e) => {
+            const normalizedError = (0, telemetry_utils_1.normalizeError)(e, { props: fatalConnectErrorProp });
             this.props.closeHandler(normalizedError);
         });
     }
     async connectCore(reason, connectionMode) {
-        var _a, _b, _c;
-        (0, common_utils_1.assert)(!this._disposed, 0x26a /* "not closed" */);
+        (0, core_utils_1.assert)(!this._disposed, 0x26a /* "not closed" */);
         if (this.connection !== undefined) {
             return; // Connection attempt already completed successfully
         }
@@ -386,10 +379,10 @@ class ConnectionManager {
         if (this.pendingConnection !== undefined) {
             pendingConnectionMode = this.pendingConnection.connectionMode;
             this.cancelConnection(reason); // Throw out in-progress connection attempt in favor of new attempt
-            (0, common_utils_1.assert)(this.pendingConnection === undefined, 0x344 /* this.pendingConnection should be undefined */);
+            (0, core_utils_1.assert)(this.pendingConnection === undefined, 0x344 /* this.pendingConnection should be undefined */);
         }
         // If there is no specified ConnectionMode, try the previous mode, if there is no previous mode use default
-        let requestedMode = (_a = connectionMode !== null && connectionMode !== void 0 ? connectionMode : pendingConnectionMode) !== null && _a !== void 0 ? _a : this.defaultReconnectionMode;
+        let requestedMode = connectionMode ?? pendingConnectionMode ?? this.defaultReconnectionMode;
         // if we have any non-acked ops from last connection, reconnect as "write".
         // without that we would connect in view-only mode, which will result in immediate
         // firing of "connected" event from Container and switch of current clientId (as tracked
@@ -399,19 +392,19 @@ class ConnectionManager {
             requestedMode = "write";
         }
         const docService = this.serviceProvider();
-        (0, common_utils_1.assert)(docService !== undefined, 0x2a7 /* "Container is not attached" */);
+        (0, core_utils_1.assert)(docService !== undefined, 0x2a7 /* "Container is not attached" */);
         let connection;
-        if (((_b = docService.policies) === null || _b === void 0 ? void 0 : _b.storageOnly) === true) {
+        if (docService.policies?.storageOnly === true) {
             connection = new NoDeltaStream();
             this.setupNewSuccessfulConnection(connection, "read", reason);
-            (0, common_utils_1.assert)(this.pendingConnection === undefined, 0x2b3 /* "logic error" */);
+            (0, core_utils_1.assert)(this.pendingConnection === undefined, 0x2b3 /* "logic error" */);
             return;
         }
         let delayMs = InitialReconnectDelayInMs;
         let connectRepeatCount = 0;
-        const connectStartTime = common_utils_1.performance.now();
+        const connectStartTime = client_utils_1.performance.now();
         let lastError;
-        const abortController = new abort_controller_1.default();
+        const abortController = new AbortController();
         const abortSignal = abortController.signal;
         this.pendingConnection = {
             abort: () => {
@@ -429,7 +422,7 @@ class ConnectionManager {
                 this.logger.sendTelemetryEvent({
                     eventName: "ConnectionAttemptCancelled",
                     attempts: connectRepeatCount,
-                    duration: telemetry_utils_1.TelemetryLogger.formatTick(common_utils_1.performance.now() - connectStartTime),
+                    duration: (0, telemetry_utils_1.formatTick)(client_utils_1.performance.now() - connectStartTime),
                     connectionEstablished: false,
                 });
                 return;
@@ -437,7 +430,10 @@ class ConnectionManager {
             connectRepeatCount++;
             try {
                 this.client.mode = requestedMode;
-                connection = await docService.connectToDeltaStream(Object.assign(Object.assign({}, this.client), { mode: requestedMode }));
+                connection = await docService.connectToDeltaStream({
+                    ...this.client,
+                    mode: requestedMode,
+                });
                 if (connection.disposed) {
                     // Nobody observed this connection, so drop it on the floor and retry.
                     this.logger.sendTelemetryEvent({ eventName: "ReceivedClosedConnection" });
@@ -461,10 +457,10 @@ class ConnectionManager {
                     attempts: connectRepeatCount,
                     delay: delayMs,
                     eventName: "DeltaConnectionFailureToConnect",
-                    duration: telemetry_utils_1.TelemetryLogger.formatTick(common_utils_1.performance.now() - connectStartTime),
+                    duration: (0, telemetry_utils_1.formatTick)(client_utils_1.performance.now() - connectStartTime),
                 }, origError);
                 lastError = origError;
-                const waitStartTime = common_utils_1.performance.now();
+                const waitStartTime = client_utils_1.performance.now();
                 const retryDelayFromError = (0, driver_utils_1.getRetryDelayFromError)(origError);
                 if (retryDelayFromError !== undefined) {
                     // If the error told us to wait, then we wait.
@@ -473,12 +469,12 @@ class ConnectionManager {
                         setTimeout(resolve, retryDelayFromError);
                     });
                 }
-                else if (((_c = globalThis.navigator) === null || _c === void 0 ? void 0 : _c.onLine) !== false) {
+                else if (globalThis.navigator?.onLine !== false) {
                     // If the error didn't tell us to wait, let's still wait a little bit before retrying.
                     // We skip this delay if we're confident we're offline, because we probably just need to wait to come back online.
                     await new Promise((resolve) => {
                         setTimeout(resolve, delayMs);
-                        delayMs = Math.min(delayMs * 2, MaxReconnectDelayInMs);
+                        delayMs = Math.min(delayMs * 2, (0, driver_utils_1.calculateMaxWaitTime)(origError));
                     });
                 }
                 // If we believe we're offline, we assume there's no point in trying until we at least think we're online.
@@ -487,7 +483,7 @@ class ConnectionManager {
                 await waitForOnline();
                 this.logger.sendPerformanceEvent({
                     eventName: "WaitBetweenConnectionAttempts",
-                    duration: common_utils_1.performance.now() - waitStartTime,
+                    duration: client_utils_1.performance.now() - waitStartTime,
                     details: JSON.stringify({
                         retryDelayFromError,
                         delayMs,
@@ -500,7 +496,7 @@ class ConnectionManager {
             (0, driver_utils_1.logNetworkFailure)(this.logger, {
                 eventName: "MultipleDeltaConnectionFailures",
                 attempts: connectRepeatCount,
-                duration: telemetry_utils_1.TelemetryLogger.formatTick(common_utils_1.performance.now() - connectStartTime),
+                duration: (0, telemetry_utils_1.formatTick)(client_utils_1.performance.now() - connectStartTime),
             }, lastError);
         }
         // Check for abort signal after while loop as well
@@ -509,7 +505,7 @@ class ConnectionManager {
             this.logger.sendTelemetryEvent({
                 eventName: "ConnectionAttemptCancelled",
                 attempts: connectRepeatCount,
-                duration: telemetry_utils_1.TelemetryLogger.formatTick(common_utils_1.performance.now() - connectStartTime),
+                duration: (0, telemetry_utils_1.formatTick)(client_utils_1.performance.now() - connectStartTime),
                 connectionEstablished: true,
             });
             return;
@@ -539,7 +535,7 @@ class ConnectionManager {
      * @param error - Error causing the disconnect if any.
      * @returns A boolean that indicates if there was an existing connection (or pending connection) to disconnect
      */
-    disconnectFromDeltaStream(reason, error) {
+    disconnectFromDeltaStream(reason) {
         this.pendingReconnect = false;
         if (this.connection === undefined) {
             if (this.pendingConnection !== undefined) {
@@ -548,7 +544,7 @@ class ConnectionManager {
             }
             return false;
         }
-        (0, common_utils_1.assert)(this.pendingConnection === undefined, 0x27b /* "reentrancy may result in incorrect behavior" */);
+        (0, core_utils_1.assert)(this.pendingConnection === undefined, 0x27b /* "reentrancy may result in incorrect behavior" */);
         const connection = this.connection;
         // Avoid any re-entrancy - clear object reference
         this.connection = undefined;
@@ -563,7 +559,7 @@ class ConnectionManager {
         this._outbound.pause();
         this._outbound.clear();
         connection.dispose();
-        this.props.disconnectHandler(reason, error);
+        this.props.disconnectHandler(reason);
         this._connectionVerboseProps = {};
         return true;
     }
@@ -571,11 +567,14 @@ class ConnectionManager {
      * Cancel in-progress connection attempt.
      */
     cancelConnection(reason) {
-        (0, common_utils_1.assert)(this.pendingConnection !== undefined, 0x345 /* this.pendingConnection is undefined when trying to cancel */);
+        (0, core_utils_1.assert)(this.pendingConnection !== undefined, 0x345 /* this.pendingConnection is undefined when trying to cancel */);
         this.pendingConnection.abort();
         this.pendingConnection = undefined;
         this.logger.sendTelemetryEvent({ eventName: "ConnectionCancelReceived" });
-        this.props.cancelConnectionHandler(`Cancel Pending Connection due to ${reason}`);
+        this.props.cancelConnectionHandler({
+            text: `Cancel Pending Connection due to ${reason.text}`,
+            error: reason.error,
+        });
     }
     /**
      * Once we've successfully gotten a connection, we need to set up state, attach event listeners, and process
@@ -583,11 +582,11 @@ class ConnectionManager {
      * @param connection - The newly established connection
      */
     setupNewSuccessfulConnection(connection, requestedMode, reason) {
-        var _a;
         // Old connection should have been cleaned up before establishing a new one
-        (0, common_utils_1.assert)(this.connection === undefined, 0x0e6 /* "old connection exists on new connection setup" */);
-        (0, common_utils_1.assert)(!connection.disposed, 0x28a /* "can't be disposed - Callers need to ensure that!" */);
+        (0, core_utils_1.assert)(this.connection === undefined, 0x0e6 /* "old connection exists on new connection setup" */);
+        (0, core_utils_1.assert)(!connection.disposed, 0x28a /* "can't be disposed - Callers need to ensure that!" */);
         this.pendingConnection = undefined;
+        const oldReadonlyValue = this.readonly;
         this.connection = connection;
         // Does information in scopes & mode matches?
         // If we asked for "write" and got "read", then file is read-only
@@ -602,12 +601,12 @@ class ConnectionManager {
         }
         // This connection mode validation logic is moving to the driver layer in 0.44.  These two asserts can be
         // removed after those packages have released and become ubiquitous.
-        (0, common_utils_1.assert)(requestedMode === "read" || readonly === (this.connectionMode === "read"), 0x0e7 /* "claims/connectionMode mismatch" */);
-        (0, common_utils_1.assert)(!readonly || this.connectionMode === "read", 0x0e8 /* "readonly perf with write connection" */);
-        this.set_readonlyPermissions(readonly);
+        (0, core_utils_1.assert)(requestedMode === "read" || readonly === (this.connectionMode === "read"), 0x0e7 /* "claims/connectionMode mismatch" */);
+        (0, core_utils_1.assert)(!readonly || this.connectionMode === "read", 0x0e8 /* "readonly perf with write connection" */);
+        this.set_readonlyPermissions(readonly, oldReadonlyValue);
         if (this._disposed) {
             // Raise proper events, Log telemetry event and close connection.
-            this.disconnectFromDeltaStream("ConnectionManager already closed");
+            this.disconnectFromDeltaStream({ text: "ConnectionManager already closed" });
             return;
         }
         this._outbound.resume();
@@ -664,7 +663,7 @@ class ConnectionManager {
             }),
         };
         this.props.signalHandler(clearSignal);
-        for (const priorClient of (_a = connection.initialClients) !== null && _a !== void 0 ? _a : []) {
+        for (const priorClient of connection.initialClients ?? []) {
             const joinSignal = {
                 clientId: null,
                 content: JSON.stringify({
@@ -692,7 +691,7 @@ class ConnectionManager {
      * @returns A promise that resolves when the connection is reestablished or we stop trying
      */
     reconnectOnError(requestedMode, error) {
-        this.reconnect(requestedMode, error.message, error).catch(this.props.closeHandler);
+        this.reconnect(requestedMode, { text: error.message, error }).catch(this.props.closeHandler);
     }
     /**
      * Disconnect the current connection and reconnect.
@@ -701,20 +700,20 @@ class ConnectionManager {
      * @param error - Error reconnect information including whether or not to reconnect
      * @returns A promise that resolves when the connection is reestablished or we stop trying
      */
-    async reconnect(requestedMode, disconnectMessage, error) {
+    async reconnect(requestedMode, reason) {
         // We quite often get protocol errors before / after observing nack/disconnect
         // we do not want to run through same sequence twice.
         // If we're already disconnected/disconnecting it's not appropriate to call this again.
-        (0, common_utils_1.assert)(this.connection !== undefined, 0x0eb /* "Missing connection for reconnect" */);
-        this.disconnectFromDeltaStream(disconnectMessage, error);
+        (0, core_utils_1.assert)(this.connection !== undefined, 0x0eb /* "Missing connection for reconnect" */);
+        this.disconnectFromDeltaStream(reason);
         // We will always trigger reconnect, even if canRetry is false.
         // Any truly fatal error state will result in container close upon attempted reconnect,
         // which is a preferable to closing abruptly when a live connection fails.
-        if (error !== undefined && !error.canRetry) {
+        if (reason.error?.canRetry === false) {
             this.logger.sendTelemetryEvent({
                 eventName: "reconnectingDespiteFatalError",
                 reconnectMode: this.reconnectMode,
-            }, error);
+            }, reason.error);
         }
         if (this.reconnectMode === contracts_1.ReconnectMode.Never) {
             // Do not raise container error if we are closing just because we lost connection.
@@ -727,9 +726,9 @@ class ConnectionManager {
             return;
         }
         // If the error tells us to wait before retrying, then do so.
-        const delayMs = (0, driver_utils_1.getRetryDelayFromError)(error);
-        if (error !== undefined && delayMs !== undefined) {
-            this.props.reconnectionDelayHandler(delayMs, error);
+        const delayMs = (0, driver_utils_1.getRetryDelayFromError)(reason.error);
+        if (reason.error !== undefined && delayMs !== undefined) {
+            this.props.reconnectionDelayHandler(delayMs, reason.error);
             await new Promise((resolve) => {
                 setTimeout(resolve, delayMs);
             });
@@ -738,15 +737,17 @@ class ConnectionManager {
         // NOTE: This isn't strictly true for drivers that don't require network (e.g. local driver).  Really this logic
         // should probably live in the driver.
         await waitForOnline();
-        this.triggerConnect(error !== undefined
-            ? "Reconnecting due to Error"
-            : `Reconnecting due to: ${disconnectMessage}`, requestedMode);
+        this.triggerConnect({
+            text: reason.error !== undefined
+                ? "Reconnecting due to Error"
+                : `Reconnecting due to: ${reason.text}`,
+            error: reason.error,
+        }, requestedMode);
     }
     prepareMessageToSend(message) {
-        var _a, _b;
         if (this.readonly === true) {
-            (0, common_utils_1.assert)(this.readOnlyInfo.readonly === true, 0x1f0 /* "Unexpected mismatch in readonly" */);
-            const error = new container_utils_1.GenericError("deltaManagerReadonlySubmit", undefined /* error */, {
+            (0, core_utils_1.assert)(this.readOnlyInfo.readonly === true, 0x1f0 /* "Unexpected mismatch in readonly" */);
+            const error = new telemetry_utils_1.GenericError("deltaManagerReadonlySubmit", undefined /* error */, {
                 readonly: this.readOnlyInfo.readonly,
                 forcedReadonly: this.readOnlyInfo.forced,
                 readonlyPermissions: this.readOnlyInfo.permissions,
@@ -759,9 +760,9 @@ class ConnectionManager {
         // reset clientSequenceNumber if we are using new clientId.
         // we keep info about old connection as long as possible to be able to account for all non-acked ops
         // that we pick up on next connection.
-        (0, common_utils_1.assert)(!!this.connection, 0x0e4 /* "Lost old connection!" */);
-        if (this.lastSubmittedClientId !== ((_a = this.connection) === null || _a === void 0 ? void 0 : _a.clientId)) {
-            this.lastSubmittedClientId = (_b = this.connection) === null || _b === void 0 ? void 0 : _b.clientId;
+        (0, core_utils_1.assert)(!!this.connection, 0x0e4 /* "Lost old connection!" */);
+        if (this.lastSubmittedClientId !== this.connection?.clientId) {
+            this.lastSubmittedClientId = this.connection?.clientId;
             this.clientSequenceNumber = 0;
             this.clientSequenceNumberObserved = 0;
         }
@@ -771,7 +772,10 @@ class ConnectionManager {
         else {
             this.localOpsToIgnore = 0;
         }
-        return Object.assign(Object.assign({}, message), { clientSequenceNumber: ++this.clientSequenceNumber });
+        return {
+            ...message,
+            clientSequenceNumber: ++this.clientSequenceNumber,
+        };
     }
     submitSignal(content) {
         if (this.connection !== undefined) {
@@ -782,7 +786,7 @@ class ConnectionManager {
         }
     }
     sendMessages(messages) {
-        (0, common_utils_1.assert)(this.connected, 0x2b4 /* "not connected on sending ops!" */);
+        (0, core_utils_1.assert)(this.connected, 0x2b4 /* "not connected on sending ops!" */);
         // If connection is "read" or implicit "read" (got leave op for "write" connection),
         // then op can't make it through - we will get a nack if op is sent.
         // We can short-circuit this process.
@@ -797,24 +801,24 @@ class ConnectionManager {
                     if (this.pendingReconnect) {
                         // still valid?
                         await this.reconnect("write", // connectionMode
-                        "Switch to write");
+                        { text: "Switch to write" });
                     }
                 })
                     .catch(() => { });
             }
             return;
         }
-        (0, common_utils_1.assert)(!this.pendingReconnect, 0x2b5 /* "logic error" */);
+        (0, core_utils_1.assert)(!this.pendingReconnect, 0x2b5 /* "logic error" */);
         this._outbound.push(messages);
     }
     beforeProcessingIncomingOp(message) {
         // if we have connection, and message is local, then we better treat is as local!
-        (0, common_utils_1.assert)(this.clientId !== message.clientId || this.lastSubmittedClientId === message.clientId, 0x0ee /* "Not accounting local messages correctly" */);
+        (0, core_utils_1.assert)(this.clientId !== message.clientId || this.lastSubmittedClientId === message.clientId, 0x0ee /* "Not accounting local messages correctly" */);
         if (this.lastSubmittedClientId !== undefined &&
             this.lastSubmittedClientId === message.clientId) {
             const clientSequenceNumber = message.clientSequenceNumber;
-            (0, common_utils_1.assert)(this.clientSequenceNumberObserved < clientSequenceNumber, 0x0ef /* "client seq# not growing" */);
-            (0, common_utils_1.assert)(clientSequenceNumber <= this.clientSequenceNumber, 0x0f0 /* "Incoming local client seq# > generated by this client" */);
+            (0, core_utils_1.assert)(this.clientSequenceNumberObserved < clientSequenceNumber, 0x0ef /* "client seq# not growing" */);
+            (0, core_utils_1.assert)(clientSequenceNumber <= this.clientSequenceNumber, 0x0f0 /* "Incoming local client seq# > generated by this client" */);
             this.clientSequenceNumberObserved = clientSequenceNumber;
         }
         if (message.type === protocol_definitions_1.MessageType.ClientLeave) {
@@ -830,7 +834,7 @@ class ConnectionManager {
                 // Clients need to be able to transition to "read" state after some time of inactivity!
                 // Note - this may close container!
                 this.reconnect("read", // connectionMode
-                "Switch to read").catch((error) => {
+                { text: "Switch to read" }).catch((error) => {
                     this.logger.sendErrorEvent({ eventName: "SwitchToReadConnection" }, error);
                 });
             }