@fluidframework/container-loader 2.0.0-internal.5.4.2 → 2.0.0-internal.6.0.1

package/lib/container.js

@@ -8,18 +8,18 @@ import { v4 as uuid } from "uuid";
 import { TypedEventEmitter, assert, performance, unreachableCase, } from "@fluidframework/common-utils";
 import { AttachState, isFluidCodeDetails, } from "@fluidframework/container-definitions";
 import { GenericError, UsageError } from "@fluidframework/container-utils";
-import { readAndParse, OnlineStatus, isOnline, combineAppAndProtocolSummary, runWithRetry, isCombinedAppAndProtocolSummary, MessageType2, } from "@fluidframework/driver-utils";
+import { readAndParse, OnlineStatus, isOnline, runWithRetry, isCombinedAppAndProtocolSummary, MessageType2, } from "@fluidframework/driver-utils";
 import { MessageType, SummaryType, } from "@fluidframework/protocol-definitions";
 import { createChildLogger, EventEmitterWithErrorHandling, PerformanceEvent, raiseConnectedEvent, connectedEventName, normalizeError, createChildMonitoringContext, wrapError, formatTick, } from "@fluidframework/telemetry-utils";
 import { Audience } from "./audience";
 import { ContainerContext } from "./containerContext";
-import { ReconnectMode, getPackageName } from "./contracts";
+import { ReconnectMode, getPackageName, } from "./contracts";
 import { DeltaManager } from "./deltaManager";
 import { RelativeLoader } from "./loader";
 import { pkgVersion } from "./packageVersion";
 import { ContainerStorageAdapter, getBlobContentsFromTree, getBlobContentsFromTreeWithBlobContents, } from "./containerStorageAdapter";
 import { createConnectionStateHandler } from "./connectionStateHandler";
-import { getProtocolSnapshotTree, getSnapshotTreeFromSerializedContainer } from "./utils";
+import { combineAppAndProtocolSummary, getProtocolSnapshotTree, getSnapshotTreeFromSerializedContainer, } from "./utils";
 import { initQuorumValuesFromCodeDetails } from "./quorum";
 import { NoopHeuristic } from "./noopHeuristic";
 import { ConnectionManager } from "./connectionManager";
@@ -104,7 +104,7 @@ export async function waitContainerToCatchUp(container) {
 }
 const getCodeProposal = 
 // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-(quorum) => { var _a; return (_a = quorum.get("code")) !== null && _a !== void 0 ? _a : quorum.get("code2"); };
+(quorum) => quorum.get("code") ?? quorum.get("code2");
 /**
  * Helper function to report to telemetry cases where operation takes longer than expected (200ms)
  * @param logger - logger to use
@@ -124,7 +124,6 @@ export class Container extends EventEmitterWithErrorHandling {
      * @internal
      */
     constructor(createProps, loadProps) {
-        var _a;
         super((name, error) => {
             this.mc.logger.sendErrorEvent({
                 eventName: "ContainerEventHandlerException",
@@ -174,8 +173,8 @@ export class Container extends EventEmitterWithErrorHandling {
         };
         const { canReconnect, clientDetailsOverride, urlResolver, documentServiceFactory, codeLoader, options, scope, subLogger, detachedBlobStorage, protocolHandlerBuilder, } = createProps;
         this.connectionTransitionTimes[ConnectionState.Disconnected] = performance.now();
-        const pendingLocalState = loadProps === null || loadProps === void 0 ? void 0 : loadProps.pendingLocalState;
-        this._canReconnect = canReconnect !== null && canReconnect !== void 0 ? canReconnect : true;
+        const pendingLocalState = loadProps?.pendingLocalState;
+        this._canReconnect = canReconnect ?? true;
         this.clientDetailsOverride = clientDetailsOverride;
         this.urlResolver = urlResolver;
         this.serviceFactory = documentServiceFactory;
@@ -183,14 +182,18 @@ export class Container extends EventEmitterWithErrorHandling {
         // Warning: this is only a shallow clone. Mutation of any individual loader option will mutate it for
         // all clients that were loaded from the same loader (including summarizer clients).
         // Tracking alternative ways to handle this in AB#4129.
-        this.options = Object.assign({}, options);
+        this.options = { ...options };
         this.scope = scope;
         this.detachedBlobStorage = detachedBlobStorage;
         this.protocolHandlerBuilder =
-            protocolHandlerBuilder !== null && protocolHandlerBuilder !== void 0 ? protocolHandlerBuilder : ((attributes, quorumSnapshot, sendProposal) => new ProtocolHandler(attributes, quorumSnapshot, sendProposal, new Audience(), (clientId) => this.clientsWhoShouldHaveLeft.has(clientId)));
+            protocolHandlerBuilder ??
+                ((attributes, quorumSnapshot, sendProposal) => new ProtocolHandler(attributes, quorumSnapshot, sendProposal, new Audience(), (clientId) => this.clientsWhoShouldHaveLeft.has(clientId)));
         // Note that we capture the createProps here so we can replicate the creation call when we want to clone.
         this.clone = async (_loadProps, createParamOverrides) => {
-            return Container.load(_loadProps, Object.assign(Object.assign({}, createProps), createParamOverrides));
+            return Container.load(_loadProps, {
+                ...createProps,
+                ...createParamOverrides,
+            });
         };
         // Create logger for data stores to use
         const type = this.client.details.type;
@@ -204,7 +207,7 @@ export class Container extends EventEmitterWithErrorHandling {
                 all: {
                     clientType,
                     containerId: uuid(),
-                    docId: () => { var _a; return (_a = this.resolvedUrl) === null || _a === void 0 ? void 0 : _a.id; },
+                    docId: () => this.resolvedUrl?.id,
                     containerAttachState: () => this._attachState,
                     containerLifecycleState: () => this._lifecycleState,
                     containerConnectionState: () => ConnectionState[this.connectionState],
@@ -215,22 +218,19 @@ export class Container extends EventEmitterWithErrorHandling {
                 // specific error or class of errors
                 error: {
                     // load information to associate errors with the specific load point
-                    dmInitialSeqNumber: () => { var _a; return (_a = this._deltaManager) === null || _a === void 0 ? void 0 : _a.initialSequenceNumber; },
-                    dmLastProcessedSeqNumber: () => { var _a; return (_a = this._deltaManager) === null || _a === void 0 ? void 0 : _a.lastSequenceNumber; },
-                    dmLastKnownSeqNumber: () => { var _a; return (_a = this._deltaManager) === null || _a === void 0 ? void 0 : _a.lastKnownSeqNumber; },
-                    containerLoadedFromVersionId: () => { var _a; return (_a = this._loadedFromVersion) === null || _a === void 0 ? void 0 : _a.id; },
-                    containerLoadedFromVersionDate: () => { var _a; return (_a = this._loadedFromVersion) === null || _a === void 0 ? void 0 : _a.date; },
+                    dmInitialSeqNumber: () => this._deltaManager?.initialSequenceNumber,
+                    dmLastProcessedSeqNumber: () => this._deltaManager?.lastSequenceNumber,
+                    dmLastKnownSeqNumber: () => this._deltaManager?.lastKnownSeqNumber,
+                    containerLoadedFromVersionId: () => this._loadedFromVersion?.id,
+                    containerLoadedFromVersionDate: () => this._loadedFromVersion?.date,
                     // message information to associate errors with the specific execution state
                     // dmLastMsqSeqNumber: if present, same as dmLastProcessedSeqNumber
-                    dmLastMsqSeqNumber: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.sequenceNumber; },
-                    dmLastMsqSeqTimestamp: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.timestamp; },
-                    dmLastMsqSeqClientId: () => {
-                        var _a, _b, _c, _d;
-                        return ((_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.clientId) === null
-                            ? "null"
-                            : (_d = (_c = this.deltaManager) === null || _c === void 0 ? void 0 : _c.lastMessage) === null || _d === void 0 ? void 0 : _d.clientId;
-                    },
-                    dmLastMsgClientSeq: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.clientSequenceNumber; },
+                    dmLastMsqSeqNumber: () => this.deltaManager?.lastMessage?.sequenceNumber,
+                    dmLastMsqSeqTimestamp: () => this.deltaManager?.lastMessage?.timestamp,
+                    dmLastMsqSeqClientId: () => this.deltaManager?.lastMessage?.clientId === null
+                        ? "null"
+                        : this.deltaManager?.lastMessage?.clientId,
+                    dmLastMsgClientSeq: () => this.deltaManager?.lastMessage?.clientSequenceNumber,
                     connectionStateDuration: () => performance.now() - this.connectionTransitionTimes[this.connectionState],
                 },
             },
@@ -260,9 +260,14 @@ export class Container extends EventEmitterWithErrorHandling {
                 // Report issues only if we already loaded container - op processing is paused while container is loading,
                 // so we always time-out processing of join op in cases where fetching snapshot takes a minute.
                 // It's not a problem with op processing itself - such issues should be tracked as part of boot perf monitoring instead.
-                this._deltaManager.logConnectionIssue(Object.assign({ eventName,
-                    mode, category: this._lifecycleState === "loading" ? "generic" : category, duration: performance.now() -
-                        this.connectionTransitionTimes[ConnectionState.CatchingUp] }, (details === undefined ? {} : { details: JSON.stringify(details) })));
+                this._deltaManager.logConnectionIssue({
+                    eventName,
+                    mode,
+                    category: this._lifecycleState === "loading" ? "generic" : category,
+                    duration: performance.now() -
+                        this.connectionTransitionTimes[ConnectionState.CatchingUp],
+                    ...(details === undefined ? {} : { details: JSON.stringify(details) }),
+                });
                 // If this is "write" connection, it took too long to receive join op. But in most cases that's due
                 // to very slow op fetches and we will eventually get there.
                 // For "read" connections, we get here due to self join signal not arriving on time. We will need to
@@ -279,7 +284,7 @@ export class Container extends EventEmitterWithErrorHandling {
             clientShouldHaveLeft: (clientId) => {
                 this.clientsWhoShouldHaveLeft.add(clientId);
             },
-        }, this.deltaManager, pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.clientId);
+        }, this.deltaManager, pendingLocalState?.clientId);
         this.on(savedContainerEvent, () => {
             this.connectionStateHandler.containerSaved();
         });
@@ -291,8 +296,9 @@ export class Container extends EventEmitterWithErrorHandling {
             : combineAppAndProtocolSummary(summaryTree, this.captureProtocolSummary());
         // Whether the combined summary tree has been forced on by either the loader option or the monitoring context.
         // Even if not forced on via this flag, combined summaries may still be enabled by service policy.
-        const forceEnableSummarizeProtocolTree = (_a = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2")) !== null && _a !== void 0 ? _a : options.summarizeProtocolTree;
-        this.storageAdapter = new ContainerStorageAdapter(detachedBlobStorage, this.mc.logger, pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.snapshotBlobs, addProtocolSummaryIfMissing, forceEnableSummarizeProtocolTree);
+        const forceEnableSummarizeProtocolTree = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2") ??
+            options.summarizeProtocolTree;
+        this.storageAdapter = new ContainerStorageAdapter(detachedBlobStorage, this.mc.logger, pendingLocalState?.snapshotBlobs, addProtocolSummaryIfMissing, forceEnableSummarizeProtocolTree);
         const isDomAvailable = typeof document === "object" &&
             document !== null &&
             typeof document.addEventListener === "function" &&
@@ -319,7 +325,7 @@ export class Container extends EventEmitterWithErrorHandling {
      * @internal
      */
     static async load(loadProps, createProps) {
-        const { version, pendingLocalState, loadMode, resolvedUrl } = loadProps;
+        const { version, pendingLocalState, loadMode, resolvedUrl, loadToSequenceNumber } = loadProps;
         const container = new Container(createProps, loadProps);
         const disableRecordHeapSize = container.mc.config.getBoolean("Fluid.Loader.DisableRecordHeapSize");
         return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "Load" }, async (event) => new Promise((resolve, reject) => {
@@ -327,19 +333,20 @@ export class Container extends EventEmitterWithErrorHandling {
             // if we have pendingLocalState, anything we cached is not useful and we shouldn't wait for connection
             // to return container, so ignore this value and use undefined for opsBeforeReturn
             const mode = pendingLocalState
-                ? Object.assign(Object.assign({}, (loadMode !== null && loadMode !== void 0 ? loadMode : defaultMode)), { opsBeforeReturn: undefined }) : loadMode !== null && loadMode !== void 0 ? loadMode : defaultMode;
+                ? { ...(loadMode ?? defaultMode), opsBeforeReturn: undefined }
+                : loadMode ?? defaultMode;
             const onClosed = (err) => {
                 // pre-0.58 error message: containerClosedWithoutErrorDuringLoad
-                reject(err !== null && err !== void 0 ? err : new GenericError("Container closed without error during load"));
+                reject(err ?? new GenericError("Container closed without error during load"));
             };
             container.on("closed", onClosed);
             container
-                .load(version, mode, resolvedUrl, pendingLocalState)
+                .load(version, mode, resolvedUrl, pendingLocalState, loadToSequenceNumber)
                 .finally(() => {
                 container.removeListener("closed", onClosed);
             })
                 .then((props) => {
-                event.end(Object.assign(Object.assign({}, props), loadMode));
+                event.end({ ...props, ...loadMode });
                 resolve(container);
             }, (error) => {
                 const err = normalizeError(error);
@@ -407,7 +414,6 @@ export class Container extends EventEmitterWithErrorHandling {
         return this;
     }
     get resolvedUrl() {
-        var _a;
         /**
          * All attached containers will have a document service,
          * this is required, as attached containers are attached to
@@ -419,7 +425,7 @@ export class Container extends EventEmitterWithErrorHandling {
          * is always the same as the containers, as we had to
          * obtain the resolved url, and then create the service from it.
          */
-        return (_a = this.service) === null || _a === void 0 ? void 0 : _a.resolvedUrl;
+        return this.service?.resolvedUrl;
     }
     get readOnlyInfo() {
         return this._deltaManager.readOnlyInfo;
@@ -447,8 +453,8 @@ export class Container extends EventEmitterWithErrorHandling {
         return this._clientId;
     }
     get offlineLoadEnabled() {
-        var _a, _b;
-        const enabled = (_a = this.mc.config.getBoolean("Fluid.Container.enableOfflineLoad")) !== null && _a !== void 0 ? _a : ((_b = this.options) === null || _b === void 0 ? void 0 : _b.enableOfflineLoad) === true;
+        const enabled = this.mc.config.getBoolean("Fluid.Container.enableOfflineLoad") ??
+            this.options?.enableOfflineLoad === true;
         // summarizer will not have any pending state we want to save
         return enabled && this.deltaManager.clientDetails.capabilities.interactive;
     }
@@ -485,18 +491,16 @@ export class Container extends EventEmitterWithErrorHandling {
      * {@inheritDoc @fluidframework/container-definitions#IContainer.entryPoint}
      */
     async getEntryPoint() {
-        var _a, _b;
         if (this._disposed) {
             throw new UsageError("The context is already disposed");
         }
         if (this._runtime !== undefined) {
-            return (_b = (_a = this._runtime).getEntryPoint) === null || _b === void 0 ? void 0 : _b.call(_a);
+            return this._runtime.getEntryPoint?.();
         }
         return new Promise((resolve, reject) => {
             const runtimeInstantiatedHandler = () => {
-                var _a, _b;
                 assert(this._runtime !== undefined, 0x5a3 /* runtimeInstantiated fired but runtime is still undefined */);
-                resolve((_b = (_a = this._runtime).getEntryPoint) === null || _b === void 0 ? void 0 : _b.call(_a));
+                resolve(this._runtime.getEntryPoint?.());
                 this._lifecycleEvents.off("disposed", disposedHandler);
             };
             const disposedHandler = () => {
@@ -530,7 +534,6 @@ export class Container extends EventEmitterWithErrorHandling {
         assert(this._lifecycleState === "closed" || this._lifecycleState === "disposed", 0x314 /* Container properly closed */);
     }
     closeCore(error) {
-        var _a;
         assert(!this.closed, 0x315 /* re-entrancy */);
         try {
             // Ensure that we raise all key events even if one of these throws
@@ -546,7 +549,7 @@ export class Container extends EventEmitterWithErrorHandling {
                         : "generic",
                 }, error);
                 this._lifecycleState = "closing";
-                (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.close();
+                this._protocolHandler?.close();
                 this.connectionStateHandler.dispose();
             }
             catch (exception) {
@@ -566,7 +569,6 @@ export class Container extends EventEmitterWithErrorHandling {
         }
     }
     disposeCore(error) {
-        var _a, _b, _c;
         assert(!this._disposed, 0x54c /* Container already disposed */);
         this._disposed = true;
         try {
@@ -583,15 +585,15 @@ export class Container extends EventEmitterWithErrorHandling {
                 if (this._lifecycleState !== "closed") {
                     this._lifecycleState = "disposing";
                 }
-                (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.close();
+                this._protocolHandler?.close();
                 this.connectionStateHandler.dispose();
                 const maybeError = error !== undefined ? new Error(error.message) : undefined;
-                (_b = this._runtime) === null || _b === void 0 ? void 0 : _b.dispose(maybeError);
+                this._runtime?.dispose(maybeError);
                 this.storageAdapter.dispose();
                 // Notify storage about critical errors. They may be due to disconnect between client & server knowledge
                 // about file, like file being overwritten in storage, but client having stale local cache.
                 // Driver need to ensure all caches are cleared on critical errors
-                (_c = this.service) === null || _c === void 0 ? void 0 : _c.dispose(error);
+                this.service?.dispose(error);
             }
             catch (exception) {
                 this.mc.logger.sendErrorEvent({ eventName: "ContainerDisposeException" }, exception);
@@ -607,15 +609,19 @@ export class Container extends EventEmitterWithErrorHandling {
             this._lifecycleEvents.emit("disposed");
         }
     }
-    closeAndGetPendingLocalState() {
+    async closeAndGetPendingLocalState() {
         // runtime matches pending ops to successful ones by clientId and client seq num, so we need to close the
         // container at the same time we get pending state, otherwise this container could reconnect and resubmit with
         // a new clientId and a future container using stale pending state without the new clientId would resubmit them
-        const pendingState = this.getPendingLocalState();
+        this.disconnect(); // TODO https://dev.azure.com/fluidframework/internal/_workitems/edit/5127
+        const pendingState = await this.getPendingLocalStateCore({ notifyImminentClosure: true });
         this.close();
         return pendingState;
     }
-    getPendingLocalState() {
+    async getPendingLocalState() {
+        return this.getPendingLocalStateCore({ notifyImminentClosure: false });
+    }
+    async getPendingLocalStateCore(props) {
         if (!this.offlineLoadEnabled) {
             throw new UsageError("Can't get pending local state unless offline load is enabled");
         }
@@ -626,8 +632,9 @@ export class Container extends EventEmitterWithErrorHandling {
         assert(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
         assert(!!this.baseSnapshot, 0x5d4 /* no base snapshot */);
         assert(!!this.baseSnapshotBlobs, 0x5d5 /* no snapshot blobs */);
+        const pendingRuntimeState = await this.runtime.getPendingLocalState(props);
         const pendingState = {
-            pendingRuntimeState: this.runtime.getPendingLocalState(),
+            pendingRuntimeState,
             baseSnapshot: this.baseSnapshot,
             snapshotBlobs: this.baseSnapshotBlobs,
             savedOps: this.savedOps,
@@ -656,7 +663,6 @@ export class Container extends EventEmitterWithErrorHandling {
     }
     async attach(request) {
         await PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Attach" }, async () => {
-            var _a;
             if (this._lifecycleState !== "loaded") {
                 // pre-0.58 error message: containerNotValidForAttach
                 throw new UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}]`);
@@ -748,7 +754,7 @@ export class Container extends EventEmitterWithErrorHandling {
             catch (error) {
                 // add resolved URL on error object so that host has the ability to find this document and delete it
                 const newError = normalizeError(error);
-                newError.addTelemetryProperties({ resolvedUrl: (_a = this.resolvedUrl) === null || _a === void 0 ? void 0 : _a.url });
+                newError.addTelemetryProperties({ resolvedUrl: this.resolvedUrl?.url });
                 this.close(newError);
                 throw newError;
             }
@@ -855,7 +861,6 @@ export class Container extends EventEmitterWithErrorHandling {
      * Determines if the currently loaded module satisfies the incoming constraint code details
      */
     async satisfies(constraintCodeDetails) {
-        var _a, _b;
         // If we have no module, it can't satisfy anything.
         if (this._loadedModule === undefined) {
             return false;
@@ -865,8 +870,8 @@ export class Container extends EventEmitterWithErrorHandling {
         if (maybeCompareCodeLoader.IFluidCodeDetailsComparer !== undefined) {
             comparers.push(maybeCompareCodeLoader.IFluidCodeDetailsComparer);
         }
-        const maybeCompareExport = (_a = this._loadedModule) === null || _a === void 0 ? void 0 : _a.module.fluidExport;
-        if ((maybeCompareExport === null || maybeCompareExport === void 0 ? void 0 : maybeCompareExport.IFluidCodeDetailsComparer) !== undefined) {
+        const maybeCompareExport = this._loadedModule?.module.fluidExport;
+        if (maybeCompareExport?.IFluidCodeDetailsComparer !== undefined) {
             comparers.push(maybeCompareExport.IFluidCodeDetailsComparer);
         }
         // If there are no comparers, then it's impossible to know if the currently loaded package satisfies
@@ -876,7 +881,7 @@ export class Container extends EventEmitterWithErrorHandling {
             return false;
         }
         for (const comparer of comparers) {
-            const satisfies = await comparer.satisfies((_b = this._loadedModule) === null || _b === void 0 ? void 0 : _b.details, constraintCodeDetails);
+            const satisfies = await comparer.satisfies(this._loadedModule?.details, constraintCodeDetails);
             if (satisfies === false) {
                 return false;
             }
@@ -899,8 +904,7 @@ export class Container extends EventEmitterWithErrorHandling {
      *
      * @param specifiedVersion - Version SHA to load snapshot. If not specified, will fetch the latest snapshot.
      */
-    async load(specifiedVersion, loadMode, resolvedUrl, pendingLocalState) {
-        var _a, _b, _c;
+    async load(specifiedVersion, loadMode, resolvedUrl, pendingLocalState, loadToSequenceNumber) {
         this.service = await this.serviceFactory.createDocumentService(resolvedUrl, this.subLogger, this.client.details.type === summarizerClientType);
         // Ideally we always connect as "read" by default.
         // Currently that works with SPO & r11s, because we get "write" connection when connecting to non-existing file.
@@ -949,9 +953,51 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         const attributes = await this.getDocumentAttributes(this.storageAdapter, snapshot);
         // If we saved ops, we will replay them and don't need DeltaManager to fetch them
-        const sequenceNumber = (_a = pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.savedOps[pendingLocalState.savedOps.length - 1]) === null || _a === void 0 ? void 0 : _a.sequenceNumber;
-        const dmAttributes = sequenceNumber !== undefined ? Object.assign(Object.assign({}, attributes), { sequenceNumber }) : attributes;
+        const sequenceNumber = pendingLocalState?.savedOps[pendingLocalState.savedOps.length - 1]?.sequenceNumber;
+        const dmAttributes = sequenceNumber !== undefined ? { ...attributes, sequenceNumber } : attributes;
         let opsBeforeReturnP;
+        if (loadMode.pauseAfterLoad === true) {
+            // If we are trying to pause at a specific sequence number, ensure the latest snapshot is not newer than the desired sequence number.
+            if (loadMode.opsBeforeReturn === "sequenceNumber") {
+                assert(loadToSequenceNumber !== undefined, 0x727 /* sequenceNumber should be defined */);
+                // Note: It is possible that we think the latest snapshot is newer than the specified sequence number
+                // due to saved ops that may be replayed after the snapshot.
+                // https://dev.azure.com/fluidframework/internal/_workitems/edit/5055
+                if (dmAttributes.sequenceNumber > loadToSequenceNumber) {
+                    throw new Error("Cannot satisfy request to pause the container at the specified sequence number. Most recent snapshot is newer than the specified sequence number.");
+                }
+            }
+            // Force readonly mode - this will ensure we don't receive an error for the lack of join op
+            this.forceReadonly(true);
+            // We need to setup a listener to stop op processing once we reach the desired sequence number (if specified).
+            const opHandler = () => {
+                if (loadToSequenceNumber === undefined) {
+                    // If there is no specified sequence number, pause after the inbound queue is empty.
+                    if (this.deltaManager.inbound.length !== 0) {
+                        return;
+                    }
+                }
+                else {
+                    // If there is a specified sequence number, keep processing until we reach it.
+                    if (this.deltaManager.lastSequenceNumber < loadToSequenceNumber) {
+                        return;
+                    }
+                }
+                // Pause op processing once we have processed the desired number of ops.
+                void this.deltaManager.inbound.pause();
+                void this.deltaManager.outbound.pause();
+                this.off("op", opHandler);
+            };
+            if ((loadToSequenceNumber === undefined && this.deltaManager.inbound.length === 0) ||
+                this.deltaManager.lastSequenceNumber === loadToSequenceNumber) {
+                // If we have already reached the desired sequence number, call opHandler() to pause immediately.
+                opHandler();
+            }
+            else {
+                // If we have not yet reached the desired sequence number, setup a listener to pause once we reach it.
+                this.on("op", opHandler);
+            }
+        }
         // Attach op handlers to finish initialization and be able to start processing ops
         // Kick off any ops fetching if required.
         switch (loadMode.opsBeforeReturn) {
@@ -960,6 +1006,9 @@ export class Container extends EventEmitterWithErrorHandling {
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 this.attachDeltaManagerOpHandler(dmAttributes, loadMode.deltaConnection !== "none" ? "all" : "none");
                 break;
+            case "sequenceNumber":
+                opsBeforeReturnP = this.attachDeltaManagerOpHandler(dmAttributes, "sequenceNumber");
+                break;
             case "cached":
                 opsBeforeReturnP = this.attachDeltaManagerOpHandler(dmAttributes, "cached");
                 break;
@@ -973,18 +1022,18 @@ export class Container extends EventEmitterWithErrorHandling {
         // Initialize the protocol handler
         await this.initializeProtocolStateFromSnapshot(attributes, this.storageAdapter, snapshot);
         const codeDetails = this.getCodeDetailsFromQuorum();
-        await this.instantiateRuntime(codeDetails, snapshot, pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.pendingRuntimeState);
+        await this.instantiateRuntime(codeDetails, snapshot, pendingLocalState?.pendingRuntimeState);
         // replay saved ops
         if (pendingLocalState) {
             for (const message of pendingLocalState.savedOps) {
                 this.processRemoteMessage(message);
                 // allow runtime to apply stashed ops at this op's sequence number
-                await ((_c = (_b = this.runtime).notifyOpReplay) === null || _c === void 0 ? void 0 : _c.call(_b, message));
+                await this.runtime.notifyOpReplay?.(message);
             }
             pendingLocalState.savedOps = [];
             // now set clientId to stashed clientId so live ops are correctly processed as local
             assert(this.clientId === undefined, 0x5d6 /* Unexpected clientId when setting stashed clientId */);
-            this._clientId = pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.clientId;
+            this._clientId = pendingLocalState?.clientId;
         }
         // We might have hit some failure that did not manifest itself in exception in this flow,
         // do not start op processing in such case - static version of Container.load() will handle it correctly.
@@ -1015,6 +1064,19 @@ export class Container extends EventEmitterWithErrorHandling {
                     unreachableCase(loadMode.deltaConnection);
             }
         }
+        // If we have not yet reached `loadToSequenceNumber`, we will wait for ops to arrive until we reach it
+        if (loadToSequenceNumber !== undefined &&
+            this.deltaManager.lastSequenceNumber < loadToSequenceNumber) {
+            await new Promise((resolve, reject) => {
+                const opHandler = (message) => {
+                    if (message.sequenceNumber >= loadToSequenceNumber) {
+                        resolve();
+                        this.off("op", opHandler);
+                    }
+                };
+                this.on("op", opHandler);
+            });
+        }
         // Safety net: static version of Container.load() should have learned about it through "closed" handler.
         // But if that did not happen for some reason, fail load for sure.
         // Otherwise we can get into situations where container is closed and does not try to connect to ordering
@@ -1169,8 +1231,7 @@ export class Container extends EventEmitterWithErrorHandling {
         return pkg;
     }
     get client() {
-        var _a;
-        const client = ((_a = this.options) === null || _a === void 0 ? void 0 : _a.client) !== undefined
+        const client = this.options?.client !== undefined
             ? this.options.client
             : {
                 details: {
@@ -1218,8 +1279,7 @@ export class Container extends EventEmitterWithErrorHandling {
             this.connectionStateHandler.cancelEstablishingConnection(reason);
         });
         deltaManager.on("disconnect", (reason, error) => {
-            var _a;
-            (_a = this.noopHeuristic) === null || _a === void 0 ? void 0 : _a.notifyDisconnect();
+            this.noopHeuristic?.notifyDisconnect();
             if (!this.closed) {
                 this.connectionStateHandler.receivedDisconnectEvent(reason, error);
             }
@@ -1254,7 +1314,6 @@ export class Container extends EventEmitterWithErrorHandling {
         }, prefetchType);
     }
     logConnectionStateChangeTelemetry(value, oldState, reason, error) {
-        var _a;
         // Log actual event
         const time = performance.now();
         this.connectionTransitionTimes[value] = time;
@@ -1284,19 +1343,31 @@ export class Container extends EventEmitterWithErrorHandling {
             }
             connectionInitiationReason = this.firstConnection ? "InitialConnect" : "AutoReconnect";
         }
-        this.mc.logger.sendPerformanceEvent(Object.assign({ eventName: `ConnectionStateChange_${ConnectionState[value]}`, from: ConnectionState[oldState], duration,
+        this.mc.logger.sendPerformanceEvent({
+            eventName: `ConnectionStateChange_${ConnectionState[value]}`,
+            from: ConnectionState[oldState],
+            duration,
             durationFromDisconnected,
             reason,
-            connectionInitiationReason, pendingClientId: this.connectionStateHandler.pendingClientId, clientId: this.clientId, autoReconnect,
-            opsBehind, online: OnlineStatus[isOnline()], lastVisible: this.lastVisible !== undefined
+            connectionInitiationReason,
+            pendingClientId: this.connectionStateHandler.pendingClientId,
+            clientId: this.clientId,
+            autoReconnect,
+            opsBehind,
+            online: OnlineStatus[isOnline()],
+            lastVisible: this.lastVisible !== undefined
                 ? performance.now() - this.lastVisible
-                : undefined, checkpointSequenceNumber, quorumSize: (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.quorum.getMembers().size, isDirty: this.isDirty }, this._deltaManager.connectionProps), error);
+                : undefined,
+            checkpointSequenceNumber,
+            quorumSize: this._protocolHandler?.quorum.getMembers().size,
+            isDirty: this.isDirty,
+            ...this._deltaManager.connectionProps,
+        }, error);
         if (value === ConnectionState.Connected) {
             this.firstConnection = false;
         }
     }
     propagateConnectionState(initialTransition, disconnectedReason) {
-        var _a;
         // When container loaded, we want to propagate initial connection state.
         // After that, we communicate only transitions to Connected & Disconnected states, skipping all other states.
         // This can be changed in the future, for example we likely should add "CatchingUp" event on Container.
@@ -1307,7 +1378,7 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         const state = this.connectionState === ConnectionState.Connected;
         // Both protocol and context should not be undefined if we got so far.
-        this.setContextConnectedState(state, (_a = this.readOnlyInfo.readonly) !== null && _a !== void 0 ? _a : false);
+        this.setContextConnectedState(state, this.readOnlyInfo.readonly ?? false);
         this.protocolHandler.setConnectionState(state, this.clientId);
         raiseConnectedEvent(this.mc.logger, this, state, this.clientId, disconnectedReason);
     }
@@ -1347,12 +1418,11 @@ export class Container extends EventEmitterWithErrorHandling {
         return this.submitMessage(MessageType.Summarize, JSON.stringify(summary), false /* batch */, undefined /* metadata */, undefined /* compression */, referenceSequenceNumber);
     }
     submitMessage(type, contents, batch, metadata, compression, referenceSequenceNumber) {
-        var _a;
         if (this.connectionState !== ConnectionState.Connected) {
             this.mc.logger.sendErrorEvent({ eventName: "SubmitMessageWithNoConnection", type });
             return -1;
         }
-        (_a = this.noopHeuristic) === null || _a === void 0 ? void 0 : _a.notifyMessageSent();
+        this.noopHeuristic?.notifyMessageSent();
         return this._deltaManager.submit(type, contents, batch, metadata, compression, referenceSequenceNumber);
     }
     processRemoteMessage(message) {
@@ -1410,8 +1480,7 @@ export class Container extends EventEmitterWithErrorHandling {
      * @returns The snapshot requested, or the latest snapshot if no version was specified, plus version ID
      */
     async fetchSnapshotTree(specifiedVersion) {
-        var _a;
-        const version = await this.getVersion(specifiedVersion !== null && specifiedVersion !== void 0 ? specifiedVersion : null);
+        const version = await this.getVersion(specifiedVersion ?? null);
         if (version === undefined && specifiedVersion !== undefined) {
             // We should have a defined version to load from if specified version requested
             this.mc.logger.sendErrorEvent({
@@ -1420,15 +1489,14 @@ export class Container extends EventEmitterWithErrorHandling {
             });
         }
         this._loadedFromVersion = version;
-        const snapshot = (_a = (await this.storageAdapter.getSnapshotTree(version))) !== null && _a !== void 0 ? _a : undefined;
+        const snapshot = (await this.storageAdapter.getSnapshotTree(version)) ?? undefined;
         if (snapshot === undefined && version !== undefined) {
             this.mc.logger.sendErrorEvent({ eventName: "getSnapshotTreeFailed", id: version.id });
         }
-        return { snapshot, versionId: version === null || version === void 0 ? void 0 : version.id };
+        return { snapshot, versionId: version?.id };
     }
     async instantiateRuntime(codeDetails, snapshot, pendingLocalState) {
-        var _a, _b;
-        assert(((_a = this._runtime) === null || _a === void 0 ? void 0 : _a.disposed) !== false, 0x0dd /* "Existing runtime not disposed" */);
+        assert(this._runtime?.disposed !== false, 0x0dd /* "Existing runtime not disposed" */);
         // The relative loader will proxy requests to '/' to the loader itself assuming no non-cache flags
         // are set. Global requests will still go directly to the loader
         const maybeLoader = this.scope;
@@ -1439,22 +1507,17 @@ export class Container extends EventEmitterWithErrorHandling {
             // An older interface ICodeLoader could return an IFluidModule which didn't have details.
             // If we're using one of those older ICodeLoaders, then we fix up the module with the specified details here.
             // TODO: Determine if this is still a realistic scenario or if this fixup could be removed.
-            details: (_b = loadCodeResult.details) !== null && _b !== void 0 ? _b : codeDetails,
+            details: loadCodeResult.details ?? codeDetails,
         };
         const fluidExport = this._loadedModule.module.fluidExport;
-        const runtimeFactory = fluidExport === null || fluidExport === void 0 ? void 0 : fluidExport.IRuntimeFactory;
+        const runtimeFactory = fluidExport?.IRuntimeFactory;
         if (runtimeFactory === undefined) {
             throw new Error(packageNotFactoryError);
         }
-        const getSpecifiedCodeDetails = () => {
-            var _a;
-            return ((_a = this.protocolHandler.quorum.get("code")) !== null && _a !== void 0 ? _a : this.protocolHandler.quorum.get("code2"));
-        };
+        const getSpecifiedCodeDetails = () => (this.protocolHandler.quorum.get("code") ??
+            this.protocolHandler.quorum.get("code2"));
         const existing = snapshot !== undefined;
-        const context = new ContainerContext(this.options, this.scope, snapshot, this._loadedFromVersion, this._deltaManager, this.storageAdapter, this.protocolHandler.quorum, this.protocolHandler.audience, loader, (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (summaryOp, referenceSequenceNumber) => this.submitSummaryMessage(summaryOp, referenceSequenceNumber), (batch, referenceSequenceNumber) => this.submitBatch(batch, referenceSequenceNumber), (message) => this.submitSignal(message), (error) => this.dispose(error), (error) => this.close(error), this.updateDirtyContainerState, this.getAbsoluteUrl, () => { var _a; return (_a = this.resolvedUrl) === null || _a === void 0 ? void 0 : _a.id; }, () => this.clientId, () => this._deltaManager.serviceConfiguration, () => this.attachState, () => this.connected, getSpecifiedCodeDetails, this._deltaManager.clientDetails, existing, this.subLogger, pendingLocalState);
-        this._lifecycleEvents.once("disposed", () => {
-            context.dispose();
-        });
+        const context = new ContainerContext(this.options, this.scope, snapshot, this._loadedFromVersion, this._deltaManager, this.storageAdapter, this.protocolHandler.quorum, this.protocolHandler.audience, loader, (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (summaryOp, referenceSequenceNumber) => this.submitSummaryMessage(summaryOp, referenceSequenceNumber), (batch, referenceSequenceNumber) => this.submitBatch(batch, referenceSequenceNumber), (message) => this.submitSignal(message), (error) => this.dispose(error), (error) => this.close(error), this.updateDirtyContainerState, this.getAbsoluteUrl, () => this.resolvedUrl?.id, () => this.clientId, () => this.attachState, () => this.connected, getSpecifiedCodeDetails, this._deltaManager.clientDetails, existing, this.subLogger, pendingLocalState);
         this._runtime = await PerformanceEvent.timedExecAsync(this.subLogger, { eventName: "InstantiateRuntime" }, async () => runtimeFactory.instantiateRuntime(context, existing));
         this._lifecycleEvents.emit("runtimeInstantiated");
         this._loadedCodeDetails = codeDetails;
@@ -1466,8 +1529,7 @@ export class Container extends EventEmitterWithErrorHandling {
      * @param readonly - Is the container in readonly mode?
      */
     setContextConnectedState(state, readonly) {
-        var _a;
-        if (((_a = this._runtime) === null || _a === void 0 ? void 0 : _a.disposed) === false) {
+        if (this._runtime?.disposed === false) {
             /**
              * We want to lie to the ContainerRuntime when we are in readonly mode to prevent issues with pending
              * ops getting through to the DeltaManager.