@fluidframework/container-loader 2.0.0-rc.1.0.4 → 2.0.0-rc.2.0.0

package/dist/container.js

@@ -3,6 +3,9 @@
  * 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.Container = exports.ReportIfTooLong = exports.waitContainerToCatchUp = void 0;
 const uuid_1 = require("uuid");
@@ -13,25 +16,27 @@ const container_definitions_1 = require("@fluidframework/container-definitions")
 const driver_utils_1 = require("@fluidframework/driver-utils");
 const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
-const audience_1 = require("./audience");
-const containerContext_1 = require("./containerContext");
-const contracts_1 = require("./contracts");
-const deltaManager_1 = require("./deltaManager");
-const loader_1 = require("./loader");
-const packageVersion_1 = require("./packageVersion");
-const containerStorageAdapter_1 = require("./containerStorageAdapter");
-const connectionStateHandler_1 = require("./connectionStateHandler");
-const utils_1 = require("./utils");
-const quorum_1 = require("./quorum");
-const noopHeuristic_1 = require("./noopHeuristic");
-const connectionManager_1 = require("./connectionManager");
-const connectionState_1 = require("./connectionState");
-const protocol_1 = require("./protocol");
+const structured_clone_1 = __importDefault(require("@ungap/structured-clone"));
+const audience_js_1 = require("./audience.js");
+const containerContext_js_1 = require("./containerContext.js");
+const contracts_js_1 = require("./contracts.js");
+const deltaManager_js_1 = require("./deltaManager.js");
+const loader_js_1 = require("./loader.js");
+const packageVersion_js_1 = require("./packageVersion.js");
+const containerStorageAdapter_js_1 = require("./containerStorageAdapter.js");
+const connectionStateHandler_js_1 = require("./connectionStateHandler.js");
+const utils_js_1 = require("./utils.js");
+const quorum_js_1 = require("./quorum.js");
+const noopHeuristic_js_1 = require("./noopHeuristic.js");
+const connectionManager_js_1 = require("./connectionManager.js");
+const connectionState_js_1 = require("./connectionState.js");
+const protocol_js_1 = require("./protocol.js");
+const attachment_js_1 = require("./attachment.js");
+const serializedStateManager_js_1 = require("./serializedStateManager.js");
 const detachedContainerRefSeqNumber = 0;
 const dirtyContainerEvent = "dirty";
 const savedContainerEvent = "saved";
 const packageNotFactoryError = "Code package does not implement IRuntimeFactory";
-const hasBlobsSummaryTree = ".hasAttachmentBlobs";
 /**
  * Waits until container connects to delta storage and gets up-to-date.
  *
@@ -69,8 +74,8 @@ async function waitContainerToCatchUp(container) {
         // Waiting for "connected" state in either case gets us at least to our own Join op
         // which is a reasonable approximation of "caught up"
         const waitForOps = () => {
-            (0, core_utils_1.assert)(container.connectionState === connectionState_1.ConnectionState.CatchingUp ||
-                container.connectionState === connectionState_1.ConnectionState.Connected, 0x0cd /* "Container disconnected while waiting for ops!" */);
+            (0, core_utils_1.assert)(container.connectionState === connectionState_js_1.ConnectionState.CatchingUp ||
+                container.connectionState === connectionState_js_1.ConnectionState.Connected, 0x0cd /* "Container disconnected while waiting for ops!" */);
             const hasCheckpointSequenceNumber = deltaManager.hasCheckpointSequenceNumber;
             const connectionOpSeqNumber = deltaManager.lastKnownSeqNumber;
             (0, core_utils_1.assert)(deltaManager.lastSequenceNumber <= connectionOpSeqNumber, 0x266 /* "lastKnownSeqNumber should never be below last processed sequence number" */);
@@ -92,7 +97,7 @@ async function waitContainerToCatchUp(container) {
         // But that works only if service provides us checkPointSequenceNumber
         // Our internal testing is based on R11S that does not, but almost all tests connect as "write" and
         // use this function to catch up, so leveraging our own join op as a fence/barrier
-        if (container.connectionState === connectionState_1.ConnectionState.Connected) {
+        if (container.connectionState === connectionState_js_1.ConnectionState.Connected) {
             waitForOps();
             return;
         }
@@ -101,15 +106,13 @@ async function waitContainerToCatchUp(container) {
             waitForOps();
         };
         container.on(telemetry_utils_1.connectedEventName, callback);
-        if (container.connectionState === connectionState_1.ConnectionState.Disconnected) {
+        if (container.connectionState === connectionState_js_1.ConnectionState.Disconnected) {
             container.connect();
         }
     });
 }
 exports.waitContainerToCatchUp = waitContainerToCatchUp;
-const getCodeProposal = 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-(quorum) => quorum.get("code") ?? quorum.get("code2");
+const getCodeProposal = (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
@@ -128,7 +131,6 @@ const summarizerClientType = "summarizer";
 class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     /**
      * Load an existing container.
-     * @internal
      */
     static async load(loadProps, createProps) {
         const { version, pendingLocalState, loadMode, resolvedUrl, loadToSequenceNumber } = loadProps;
@@ -185,11 +187,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     static async rehydrateDetachedFromSnapshot(createProps, snapshot) {
         const container = new Container(createProps);
         return telemetry_utils_1.PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "RehydrateDetachedFromSnapshot" }, async (_event) => {
-            const deserializedSummary = JSON.parse(snapshot);
-            if (!(0, driver_utils_1.isCombinedAppAndProtocolSummary)(deserializedSummary, hasBlobsSummaryTree)) {
-                throw new telemetry_utils_1.UsageError("Cannot rehydrate detached container. Incorrect format");
-            }
-            await container.rehydrateDetachedFromSnapshot(deserializedSummary);
+            const detachedContainerState = (0, utils_js_1.getDetachedContainerStateFromSerializedContainer)(snapshot);
+            await container.rehydrateDetachedFromSnapshot(detachedContainerState);
             return container;
         }, { start: true, end: true, cancel: "generic" });
     }
@@ -240,6 +239,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     get readOnlyInfo() {
         return this._deltaManager.readOnlyInfo;
     }
+    get containerMetadata() {
+        return this._containerMetadata;
+    }
     /**
      * Sends signal to runtime (and data stores) to be read-only.
      * Hosts may have read only views, indicating to data stores that no edits are allowed.
@@ -267,7 +269,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         return this.connectionStateHandler.connectionState;
     }
     get connected() {
-        return this.connectionStateHandler.connectionState === connectionState_1.ConnectionState.Connected;
+        return this.connectionStateHandler.connectionState === connectionState_js_1.ConnectionState.Connected;
     }
     /**
      * The server provided id of the client.
@@ -276,11 +278,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     get clientId() {
         return this._clientId;
     }
-    get offlineLoadEnabled() {
-        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;
+    get isInteractiveClient() {
+        return this.deltaManager.clientDetails.capabilities.interactive;
     }
     /**
      * Get the code details that are currently specified for the container.
@@ -335,9 +334,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             this._lifecycleEvents.once("disposed", disposedHandler);
         });
     }
-    /**
-     * @internal
-     */
     constructor(createProps, loadProps) {
         super((name, error) => {
             this.mc.logger.sendErrorEvent({
@@ -361,23 +357,101 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
          * disposed: Container has been disposed
          */
         this._lifecycleState = "loading";
-        this._attachState = container_definitions_1.AttachState.Detached;
         /** During initialization we pause the inbound queues. We track this state to ensure we only call resume once */
         this.inboundQueuePausedFromInit = true;
         this.firstConnection = true;
         this.connectionTransitionTimes = [];
-        this.attachStarted = false;
         this._dirtyContainer = false;
-        this.savedOps = [];
+        this.attachmentData = { state: container_definitions_1.AttachState.Detached };
         this.clientsWhoShouldHaveLeft = new Set();
+        this._containerMetadata = {};
         this.setAutoReconnectTime = client_utils_1.performance.now();
         this._lifecycleEvents = new client_utils_1.TypedEventEmitter();
         this._disposed = false;
+        this.attach = (0, utils_js_1.runSingle)(async (request, attachProps) => {
+            await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Attach" }, async () => {
+                if (this._lifecycleState !== "loaded" ||
+                    this.attachmentData.state === container_definitions_1.AttachState.Attached) {
+                    // pre-0.58 error message: containerNotValidForAttach
+                    throw new telemetry_utils_1.UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}] and [${this.attachState}]`);
+                }
+                const normalizeErrorAndClose = (error) => {
+                    const newError = (0, telemetry_utils_1.normalizeError)(error);
+                    this.close(newError);
+                    // add resolved URL on error object so that host has the ability to find this document and delete it
+                    newError.addTelemetryProperties({
+                        resolvedUrl: this.service?.resolvedUrl?.url,
+                    });
+                    return newError;
+                };
+                const setAttachmentData = (attachmentData) => {
+                    const previousState = this.attachmentData.state;
+                    this.attachmentData = attachmentData;
+                    const state = this.attachmentData.state;
+                    if (state !== previousState && state !== container_definitions_1.AttachState.Detached) {
+                        try {
+                            this.runtime.setAttachState(state);
+                            this.emit(state.toLocaleLowerCase());
+                        }
+                        catch (error) {
+                            throw normalizeErrorAndClose(error);
+                        }
+                    }
+                };
+                const createAttachmentSummary = (redirectTable) => {
+                    try {
+                        (0, core_utils_1.assert)(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
+                        return (0, utils_js_1.combineAppAndProtocolSummary)(this.runtime.createSummary(redirectTable), this.captureProtocolSummary());
+                    }
+                    catch (error) {
+                        throw normalizeErrorAndClose(error);
+                    }
+                };
+                const createOrGetStorageService = async (summary) => {
+                    // Actually go and create the resolved document
+                    if (this.service === undefined) {
+                        const createNewResolvedUrl = await this.urlResolver.resolve(request);
+                        (0, core_utils_1.assert)(this.client.details.type !== summarizerClientType &&
+                            createNewResolvedUrl !== undefined, 0x2c4 /* "client should not be summarizer before container is created" */);
+                        this.service = await (0, driver_utils_1.runWithRetry)(async () => this.serviceFactory.createContainer(summary, createNewResolvedUrl, this.subLogger, false), "containerAttach", this.mc.logger, {
+                            cancel: this._deltaManager.closeAbortController.signal,
+                        });
+                    }
+                    this.storageAdapter.connectToService(this.service);
+                    return this.storageAdapter;
+                };
+                let attachP = (0, attachment_js_1.runRetriableAttachProcess)({
+                    initialAttachmentData: this.attachmentData,
+                    offlineLoadEnabled: this.serializedStateManager.offlineLoadEnabled,
+                    detachedBlobStorage: this.detachedBlobStorage,
+                    setAttachmentData,
+                    createAttachmentSummary,
+                    createOrGetStorageService,
+                });
+                // only enable the new behavior if the config is set
+                if (this.mc.config.getBoolean("Fluid.Container.RetryOnAttachFailure") !== true) {
+                    attachP = attachP.catch((error) => {
+                        throw normalizeErrorAndClose(error);
+                    });
+                }
+                this.serializedStateManager.setSnapshot(await attachP);
+                if (!this.closed) {
+                    this.handleDeltaConnectionArg({
+                        fetchOpsFromStorage: false,
+                        reason: { text: "createDetached" },
+                    }, attachProps?.deltaConnection);
+                }
+            }, { start: true, end: true, cancel: "generic" });
+        });
         this.getAbsoluteUrl = async (relativeUrl) => {
             if (this.resolvedUrl === undefined) {
                 return undefined;
             }
-            return this.urlResolver.getAbsoluteUrl(this.resolvedUrl, relativeUrl, (0, contracts_1.getPackageName)(this._loadedCodeDetails));
+            return this.urlResolver.getAbsoluteUrl(this.resolvedUrl, relativeUrl, (0, contracts_js_1.getPackageName)(this._loadedCodeDetails));
+        };
+        this.metadataUpdateHandler = (metadata) => {
+            this._containerMetadata = { ...this._containerMetadata, ...metadata };
+            this.emit("metadataUpdate", metadata);
         };
         this.updateDirtyContainerState = (dirty) => {
             if (this._dirtyContainer === dirty) {
@@ -387,7 +461,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             this.emit(dirty ? dirtyContainerEvent : savedContainerEvent);
         };
         const { canReconnect, clientDetailsOverride, urlResolver, documentServiceFactory, codeLoader, options, scope, subLogger, detachedBlobStorage, protocolHandlerBuilder, } = createProps;
-        this.connectionTransitionTimes[connectionState_1.ConnectionState.Disconnected] = client_utils_1.performance.now();
+        this.connectionTransitionTimes[connectionState_js_1.ConnectionState.Disconnected] = client_utils_1.performance.now();
         const pendingLocalState = loadProps?.pendingLocalState;
         this._clientId = pendingLocalState?.clientId;
         this._canReconnect = canReconnect ?? true;
@@ -403,7 +477,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.detachedBlobStorage = detachedBlobStorage;
         this.protocolHandlerBuilder =
             protocolHandlerBuilder ??
-                ((attributes, quorumSnapshot, sendProposal) => new protocol_1.ProtocolHandler(attributes, quorumSnapshot, sendProposal, new audience_1.Audience(), (clientId) => this.clientsWhoShouldHaveLeft.has(clientId)));
+                ((attributes, quorumSnapshot, sendProposal) => new protocol_js_1.ProtocolHandler(attributes, quorumSnapshot, sendProposal, new audience_js_1.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, {
@@ -412,7 +486,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             });
         };
         this._containerId = (0, uuid_1.v4)();
-        this.client = Container.setupClient(this._containerId, this.options, this.clientDetailsOverride);
+        this.client = Container.setupClient(this._containerId, options.client, this.clientDetailsOverride);
         // Create logger for data stores to use
         const type = this.client.details.type;
         const interactive = this.client.details.capabilities.interactive;
@@ -426,9 +500,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     clientType,
                     containerId: this._containerId,
                     docId: () => this.resolvedUrl?.id,
-                    containerAttachState: () => this._attachState,
+                    containerAttachState: () => this.attachState,
                     containerLifecycleState: () => this._lifecycleState,
-                    containerConnectionState: () => connectionState_1.ConnectionState[this.connectionState],
+                    containerConnectionState: () => connectionState_js_1.ConnectionState[this.connectionState],
                     serializedContainer: pendingLocalState !== undefined,
                 },
                 // we need to be judicious with our logging here to avoid generating too much data
@@ -456,15 +530,15 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // Prefix all events in this file with container-loader
         this.mc = (0, telemetry_utils_1.createChildMonitoringContext)({ logger: this.subLogger, namespace: "Container" });
         this._deltaManager = this.createDeltaManager();
-        this.connectionStateHandler = (0, connectionStateHandler_1.createConnectionStateHandler)({
+        this.connectionStateHandler = (0, connectionStateHandler_js_1.createConnectionStateHandler)({
             logger: this.mc.logger,
             connectionStateChanged: (value, oldState, reason) => {
-                if (value === connectionState_1.ConnectionState.Connected) {
+                if (value === connectionState_js_1.ConnectionState.Connected) {
                     this._clientId = this.connectionStateHandler.pendingClientId;
                 }
                 this.logConnectionStateChangeTelemetry(value, oldState, reason);
                 if (this._lifecycleState === "loaded") {
-                    this.propagateConnectionState(false /* initial transition */, value === connectionState_1.ConnectionState.Disconnected
+                    this.propagateConnectionState(false /* initial transition */, value === connectionState_js_1.ConnectionState.Disconnected
                         ? reason
                         : undefined /* disconnectedReason */);
                 }
@@ -483,7 +557,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     mode,
                     category: this._lifecycleState === "loading" ? "generic" : category,
                     duration: client_utils_1.performance.now() -
-                        this.connectionTransitionTimes[connectionState_1.ConnectionState.CatchingUp],
+                        this.connectionTransitionTimes[connectionState_js_1.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
@@ -512,12 +586,16 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // using this callback and fix them up.
         const addProtocolSummaryIfMissing = (summaryTree) => (0, driver_utils_1.isCombinedAppAndProtocolSummary)(summaryTree) === true
             ? summaryTree
-            : (0, utils_1.combineAppAndProtocolSummary)(summaryTree, this.captureProtocolSummary());
+            : (0, utils_js_1.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 = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2") ??
             options.summarizeProtocolTree;
-        this.storageAdapter = new containerStorageAdapter_1.ContainerStorageAdapter(detachedBlobStorage, this.mc.logger, pendingLocalState?.snapshotBlobs, addProtocolSummaryIfMissing, forceEnableSummarizeProtocolTree);
+        this.storageAdapter = new containerStorageAdapter_js_1.ContainerStorageAdapter(detachedBlobStorage, this.mc.logger, pendingLocalState?.snapshotBlobs, addProtocolSummaryIfMissing, forceEnableSummarizeProtocolTree);
+        const offlineLoadEnabled = (this.isInteractiveClient &&
+            this.mc.config.getBoolean("Fluid.Container.enableOfflineLoad")) ??
+            options.enableOfflineLoad === true;
+        this.serializedStateManager = new serializedStateManager_js_1.SerializedStateManager(pendingLocalState, this.subLogger, this.storageAdapter, offlineLoadEnabled);
         const isDomAvailable = typeof document === "object" &&
             document !== null &&
             typeof document.addEventListener === "function" &&
@@ -558,7 +636,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.verifyClosed();
     }
     verifyClosed() {
-        (0, core_utils_1.assert)(this.connectionState === connectionState_1.ConnectionState.Disconnected, 0x0cf /* "disconnect event was not raised!" */);
+        (0, core_utils_1.assert)(this.connectionState === connectionState_js_1.ConnectionState.Disconnected, 0x0cf /* "disconnect event was not raised!" */);
         (0, core_utils_1.assert)(this._lifecycleState === "closed" || this._lifecycleState === "disposed", 0x314 /* Container properly closed */);
     }
     closeCore(error) {
@@ -577,6 +655,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                         : "generic",
                 }, error);
                 this._lifecycleState = "closing";
+                // Back-compat for Old driver
+                if (this.service?.off !== undefined) {
+                    this.service?.off("metadataUpdate", this.metadataUpdateHandler);
+                }
                 this._protocolHandler?.close();
                 this.connectionStateHandler.dispose();
             }
@@ -652,149 +734,35 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         return this.getPendingLocalStateCore({ notifyImminentClosure: false });
     }
     async getPendingLocalStateCore(props) {
-        return telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, {
-            eventName: "getPendingLocalState",
-            notifyImminentClosure: props.notifyImminentClosure,
-            savedOpsSize: this.savedOps.length,
-            clientId: this.clientId,
-        }, async () => {
-            if (!this.offlineLoadEnabled) {
-                throw new telemetry_utils_1.UsageError("Can't get pending local state unless offline load is enabled");
-            }
-            if (this.closed || this._disposed) {
-                throw new telemetry_utils_1.UsageError("Pending state cannot be retried if the container is closed or disposed");
-            }
-            (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
-            (0, core_utils_1.assert)(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
-            (0, core_utils_1.assert)(!!this.baseSnapshot, 0x5d4 /* no base snapshot */);
-            (0, core_utils_1.assert)(!!this.baseSnapshotBlobs, 0x5d5 /* no snapshot blobs */);
-            const pendingRuntimeState = await this.runtime.getPendingLocalState(props);
-            const pendingState = {
-                pendingRuntimeState,
-                baseSnapshot: this.baseSnapshot,
-                snapshotBlobs: this.baseSnapshotBlobs,
-                savedOps: this.savedOps,
-                url: this.resolvedUrl.url,
-                // no need to save this if there is no pending runtime state
-                clientId: pendingRuntimeState !== undefined ? this.clientId : undefined,
-            };
-            return JSON.stringify(pendingState);
-        });
+        if (this.closed || this._disposed) {
+            throw new telemetry_utils_1.UsageError("Pending state cannot be retried if the container is closed or disposed");
+        }
+        (0, core_utils_1.assert)(this.attachmentData.state === container_definitions_1.AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
+        (0, core_utils_1.assert)(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
+        const pendingState = await this.serializedStateManager.getPendingLocalStateCore(props, this.clientId, this.runtime, this.resolvedUrl);
+        return pendingState;
     }
     get attachState() {
-        return this._attachState;
+        return this.attachmentData.state;
     }
     serialize() {
-        (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Detached, 0x0d3 /* "Should only be called in detached container" */);
-        const appSummary = this.runtime.createSummary();
-        const protocolSummary = this.captureProtocolSummary();
-        const combinedSummary = (0, utils_1.combineAppAndProtocolSummary)(appSummary, protocolSummary);
-        if (this.detachedBlobStorage && this.detachedBlobStorage.size > 0) {
-            combinedSummary.tree[hasBlobsSummaryTree] = {
-                type: protocol_definitions_1.SummaryType.Blob,
-                content: "true",
-            };
+        if (this.attachmentData.state === container_definitions_1.AttachState.Attached || this.closed) {
+            throw new telemetry_utils_1.UsageError("Container must not be attached or closed.");
         }
-        return JSON.stringify(combinedSummary);
-    }
-    async attach(request, attachProps) {
-        await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Attach" }, async () => {
-            if (this._lifecycleState !== "loaded") {
-                // pre-0.58 error message: containerNotValidForAttach
-                throw new telemetry_utils_1.UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}]`);
-            }
-            // If container is already attached or attach is in progress, throw an error.
-            (0, core_utils_1.assert)(this._attachState === container_definitions_1.AttachState.Detached && !this.attachStarted, 0x205 /* "attach() called more than once" */);
-            this.attachStarted = true;
-            // If attachment blobs were uploaded in detached state we will go through a different attach flow
-            const hasAttachmentBlobs = this.detachedBlobStorage !== undefined && this.detachedBlobStorage.size > 0;
-            try {
-                (0, core_utils_1.assert)(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
-                let summary;
-                if (!hasAttachmentBlobs) {
-                    // Get the document state post attach - possibly can just call attach but we need to change the
-                    // semantics around what the attach means as far as async code goes.
-                    const appSummary = this.runtime.createSummary();
-                    const protocolSummary = this.captureProtocolSummary();
-                    summary = (0, utils_1.combineAppAndProtocolSummary)(appSummary, protocolSummary);
-                    // Set the state as attaching as we are starting the process of attaching container.
-                    // This should be fired after taking the summary because it is the place where we are
-                    // starting to attach the container to storage.
-                    // Also, this should only be fired in detached container.
-                    this._attachState = container_definitions_1.AttachState.Attaching;
-                    this.runtime.setAttachState(container_definitions_1.AttachState.Attaching);
-                    this.emit("attaching");
-                    if (this.offlineLoadEnabled) {
-                        const snapshot = (0, utils_1.getSnapshotTreeFromSerializedContainer)(summary);
-                        this.baseSnapshot = snapshot;
-                        this.baseSnapshotBlobs =
-                            (0, containerStorageAdapter_1.getBlobContentsFromTreeWithBlobContents)(snapshot);
-                    }
-                }
-                // Actually go and create the resolved document
-                if (this.service === undefined) {
-                    const createNewResolvedUrl = await this.urlResolver.resolve(request);
-                    (0, core_utils_1.assert)(this.client.details.type !== summarizerClientType &&
-                        createNewResolvedUrl !== undefined, 0x2c4 /* "client should not be summarizer before container is created" */);
-                    this.service = await (0, driver_utils_1.runWithRetry)(async () => this.serviceFactory.createContainer(summary, createNewResolvedUrl, this.subLogger, false), "containerAttach", this.mc.logger, {
-                        cancel: this._deltaManager.closeAbortController.signal,
-                    });
-                }
-                this.storageAdapter.connectToService(this.service);
-                if (hasAttachmentBlobs) {
-                    // upload blobs to storage
-                    (0, core_utils_1.assert)(!!this.detachedBlobStorage, 0x24e /* "assertion for type narrowing" */);
-                    // build a table mapping IDs assigned locally to IDs assigned by storage and pass it to runtime to
-                    // support blob handles that only know about the local IDs
-                    const redirectTable = new Map();
-                    // if new blobs are added while uploading, upload them too
-                    while (redirectTable.size < this.detachedBlobStorage.size) {
-                        const newIds = this.detachedBlobStorage
-                            .getBlobIds()
-                            .filter((id) => !redirectTable.has(id));
-                        for (const id of newIds) {
-                            const blob = await this.detachedBlobStorage.readBlob(id);
-                            const response = await this.storageAdapter.createBlob(blob);
-                            redirectTable.set(id, response.id);
-                        }
-                    }
-                    // take summary and upload
-                    const appSummary = this.runtime.createSummary(redirectTable);
-                    const protocolSummary = this.captureProtocolSummary();
-                    summary = (0, utils_1.combineAppAndProtocolSummary)(appSummary, protocolSummary);
-                    this._attachState = container_definitions_1.AttachState.Attaching;
-                    this.runtime.setAttachState(container_definitions_1.AttachState.Attaching);
-                    this.emit("attaching");
-                    if (this.offlineLoadEnabled) {
-                        const snapshot = (0, utils_1.getSnapshotTreeFromSerializedContainer)(summary);
-                        this.baseSnapshot = snapshot;
-                        this.baseSnapshotBlobs =
-                            (0, containerStorageAdapter_1.getBlobContentsFromTreeWithBlobContents)(snapshot);
-                    }
-                    await this.storageAdapter.uploadSummaryWithContext(summary, {
-                        referenceSequenceNumber: 0,
-                        ackHandle: undefined,
-                        proposalHandle: undefined,
-                    });
-                }
-                this._attachState = container_definitions_1.AttachState.Attached;
-                this.runtime.setAttachState(container_definitions_1.AttachState.Attached);
-                this.emit("attached");
-                if (!this.closed) {
-                    this.handleDeltaConnectionArg({
-                        fetchOpsFromStorage: false,
-                        reason: { text: "createDetached" },
-                    }, attachProps?.deltaConnection);
-                }
-            }
-            catch (error) {
-                // add resolved URL on error object so that host has the ability to find this document and delete it
-                const newError = (0, telemetry_utils_1.normalizeError)(error);
-                newError.addTelemetryProperties({ resolvedUrl: this.resolvedUrl?.url });
-                this.close(newError);
-                throw newError;
-            }
-        }, { start: true, end: true, cancel: "generic" });
+        const attachingData = this.attachmentData.state === container_definitions_1.AttachState.Attaching ? this.attachmentData : undefined;
+        const combinedSummary = attachingData?.summary ??
+            (0, utils_js_1.combineAppAndProtocolSummary)(this.runtime.createSummary(), this.captureProtocolSummary());
+        const { tree: snapshot, blobs } = (0, utils_js_1.getSnapshotTreeAndBlobsFromSerializedContainer)(combinedSummary);
+        const pendingRuntimeState = attachingData !== undefined ? this.runtime.getPendingLocalState() : undefined;
+        (0, core_utils_1.assert)(!(0, core_utils_1.isPromiseLike)(pendingRuntimeState), 0x8e3 /* should not be a promise */);
+        const detachedContainerState = {
+            attached: false,
+            baseSnapshot: snapshot,
+            snapshotBlobs: blobs,
+            pendingRuntimeState,
+            hasAttachmentBlobs: !!this.detachedBlobStorage && this.detachedBlobStorage.size > 0,
+        };
+        return JSON.stringify(detachedContainerState);
     }
     setAutoReconnectInternal(mode, reason) {
         const currentMode = this._deltaManager.connectionManager.reconnectMode;
@@ -805,9 +773,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         const duration = now - this.setAutoReconnectTime;
         this.setAutoReconnectTime = now;
         this.mc.logger.sendTelemetryEvent({
-            eventName: mode === contracts_1.ReconnectMode.Enabled ? "AutoReconnectEnabled" : "AutoReconnectDisabled",
+            eventName: mode === contracts_js_1.ReconnectMode.Enabled ? "AutoReconnectEnabled" : "AutoReconnectDisabled",
             connectionMode: this.connectionMode,
-            connectionState: connectionState_1.ConnectionState[this.connectionState],
+            connectionState: connectionState_js_1.ConnectionState[this.connectionState],
             duration,
         });
         this._deltaManager.connectionManager.setAutoReconnect(mode, reason);
@@ -816,7 +784,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         if (this.closed) {
             throw new telemetry_utils_1.UsageError(`The Container is closed and cannot be connected`);
         }
-        else if (this._attachState !== container_definitions_1.AttachState.Attached) {
+        else if (this.attachState !== container_definitions_1.AttachState.Attached) {
             throw new telemetry_utils_1.UsageError(`The Container is not attached and cannot be connected`);
         }
         else if (!this.connected) {
@@ -831,11 +799,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     connectInternal(args) {
         (0, core_utils_1.assert)(!this.closed, 0x2c5 /* "Attempting to connect() a closed Container" */);
-        (0, core_utils_1.assert)(this._attachState === container_definitions_1.AttachState.Attached, 0x2c6 /* "Attempting to connect() a container that is not attached" */);
+        (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Attached, 0x2c6 /* "Attempting to connect() a container that is not attached" */);
         // Resume processing ops and connect to delta stream
         this.resumeInternal(args);
         // Set Auto Reconnect Mode
-        const mode = contracts_1.ReconnectMode.Enabled;
+        const mode = contracts_js_1.ReconnectMode.Enabled;
         this.setAutoReconnectInternal(mode, args.reason);
     }
     disconnect() {
@@ -849,7 +817,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     disconnectInternal(reason) {
         (0, core_utils_1.assert)(!this.closed, 0x2c7 /* "Attempting to disconnect() a closed Container" */);
         // Set Auto Reconnect Mode
-        const mode = contracts_1.ReconnectMode.Disabled;
+        const mode = contracts_js_1.ReconnectMode.Disabled;
         this.setAutoReconnectInternal(mode, reason);
     }
     resumeInternal(args) {
@@ -924,10 +892,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         return true;
     }
-    async getVersion(version) {
-        const versions = await this.storageAdapter.getVersions(version, 1);
-        return versions[0];
-    }
     connectToDeltaStream(args) {
         // All agents need "write" access, including summarizer.
         if (!this._canReconnect || !this.client.details.capabilities.interactive) {
@@ -935,6 +899,14 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         this._deltaManager.connect(args);
     }
+    async createDocumentService(serviceProvider) {
+        const service = await serviceProvider();
+        // Back-compat for Old driver
+        if (service.on !== undefined) {
+            service.on("metadataUpdate", this.metadataUpdateHandler);
+        }
+        return service;
+    }
     /**
      * Load container.
      *
@@ -942,7 +914,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      */
     async load(specifiedVersion, loadMode, resolvedUrl, pendingLocalState, loadToSequenceNumber) {
         const timings = { phase1: client_utils_1.performance.now() };
-        this.service = await this.serviceFactory.createDocumentService(resolvedUrl, this.subLogger, this.client.details.type === summarizerClientType);
+        this.service = await this.createDocumentService(async () => this.serviceFactory.createDocumentService(resolvedUrl, this.subLogger, this.client.details.type === summarizerClientType));
         // Except in cases where it has stashed ops or requested by feature gate, the container will connect in "read" mode
         const mode = this.mc.config.getBoolean("Fluid.Container.ForceWriteConnection") === true ||
             (pendingLocalState?.savedOps.length ?? 0) > 0
@@ -959,25 +931,14 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             this.connectToDeltaStream(connectionArgs);
         }
         this.storageAdapter.connectToService(this.service);
-        this._attachState = container_definitions_1.AttachState.Attached;
+        this.attachmentData = {
+            state: container_definitions_1.AttachState.Attached,
+        };
         timings.phase2 = client_utils_1.performance.now();
         // Fetch specified snapshot.
-        const { snapshot, versionId } = pendingLocalState === undefined
-            ? await this.fetchSnapshotTree(specifiedVersion)
-            : { snapshot: pendingLocalState.baseSnapshot, versionId: undefined };
-        if (pendingLocalState) {
-            this.baseSnapshot = pendingLocalState.baseSnapshot;
-            this.baseSnapshotBlobs = pendingLocalState.snapshotBlobs;
-        }
-        else {
-            (0, core_utils_1.assert)(snapshot !== undefined, 0x237 /* "Snapshot should exist" */);
-            if (this.offlineLoadEnabled) {
-                this.baseSnapshot = snapshot;
-                // Save contents of snapshot now, otherwise closeAndGetPendingLocalState() must be async
-                this.baseSnapshotBlobs = await (0, containerStorageAdapter_1.getBlobContentsFromTree)(snapshot, this.storageAdapter);
-            }
-        }
-        const attributes = await this.getDocumentAttributes(this.storageAdapter, snapshot);
+        const { snapshotTree, version } = await this.serializedStateManager.fetchSnapshot(specifiedVersion, this.service?.policies?.supportGetSnapshotApi);
+        this._loadedFromVersion = version;
+        const attributes = await this.getDocumentAttributes(this.storageAdapter, snapshotTree);
         // If we saved ops, we will replay them and don't need DeltaManager to fetch them
         const sequenceNumber = pendingLocalState?.savedOps[pendingLocalState.savedOps.length - 1]?.sequenceNumber;
         const dmAttributes = sequenceNumber !== undefined ? { ...attributes, sequenceNumber } : attributes;
@@ -1042,12 +1003,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         // ...load in the existing quorum
         // Initialize the protocol handler
-        await this.initializeProtocolStateFromSnapshot(attributes, this.storageAdapter, snapshot);
+        await this.initializeProtocolStateFromSnapshot(attributes, this.storageAdapter, snapshotTree);
         timings.phase3 = client_utils_1.performance.now();
         const codeDetails = this.getCodeDetailsFromQuorum();
-        await this.instantiateRuntime(codeDetails, snapshot, 
+        await this.instantiateRuntime(codeDetails, snapshotTree, 
         // give runtime a dummy value so it knows we're loading from a stash blob
-        pendingLocalState ? pendingLocalState?.pendingRuntimeState ?? {} : undefined);
+        pendingLocalState ? pendingLocalState?.pendingRuntimeState ?? {} : undefined, (0, driver_utils_1.isInstanceOfISnapshot)(snapshotTree) ? snapshotTree : undefined);
         // replay saved ops
         if (pendingLocalState) {
             for (const message of pendingLocalState.savedOps) {
@@ -1102,7 +1063,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }, undefined, core_interfaces_1.LogLevel.verbose);
         return {
             sequenceNumber: attributes.sequenceNumber,
-            version: versionId,
+            version: version?.id,
             dmLastProcessedSeqNumber: this._deltaManager.lastSequenceNumber,
             dmLastKnownSeqNumber: this._deltaManager.lastKnownSeqNumber,
         };
@@ -1114,7 +1075,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         };
         await this.attachDeltaManagerOpHandler(attributes);
         // Need to just seed the source data in the code quorum. Quorum itself is empty
-        const qValues = (0, quorum_1.initQuorumValuesFromCodeDetails)(codeDetails);
+        const qValues = (0, quorum_js_1.initQuorumValuesFromCodeDetails)(codeDetails);
         this.initializeProtocolState(attributes, {
             members: [],
             proposals: [],
@@ -1123,18 +1084,16 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         await this.instantiateRuntime(codeDetails, undefined);
         this.setLoaded();
     }
-    async rehydrateDetachedFromSnapshot(detachedContainerSnapshot) {
-        if (detachedContainerSnapshot.tree[hasBlobsSummaryTree] !== undefined) {
+    async rehydrateDetachedFromSnapshot({ baseSnapshot, snapshotBlobs, hasAttachmentBlobs, pendingRuntimeState, }) {
+        if (hasAttachmentBlobs) {
             (0, core_utils_1.assert)(!!this.detachedBlobStorage && this.detachedBlobStorage.size > 0, 0x250 /* "serialized container with attachment blobs must be rehydrated with detached blob storage" */);
-            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-            delete detachedContainerSnapshot.tree[hasBlobsSummaryTree];
         }
-        const snapshotTree = (0, utils_1.getSnapshotTreeFromSerializedContainer)(detachedContainerSnapshot);
-        this.storageAdapter.loadSnapshotForRehydratingContainer(snapshotTree);
-        const attributes = await this.getDocumentAttributes(this.storageAdapter, snapshotTree);
+        const snapshotTreeWithBlobContents = (0, utils_js_1.combineSnapshotTreeAndSnapshotBlobs)(baseSnapshot, snapshotBlobs);
+        this.storageAdapter.loadSnapshotFromSnapshotBlobs(snapshotBlobs);
+        const attributes = await this.getDocumentAttributes(this.storageAdapter, snapshotTreeWithBlobContents);
         await this.attachDeltaManagerOpHandler(attributes);
         // Initialize the protocol handler
-        const baseTree = (0, utils_1.getProtocolSnapshotTree)(snapshotTree);
+        const baseTree = (0, utils_js_1.getProtocolSnapshotTree)(snapshotTreeWithBlobContents);
         const qValues = await (0, driver_utils_1.readAndParse)(this.storageAdapter, baseTree.blobs.quorumValues);
         this.initializeProtocolState(attributes, {
             members: [],
@@ -1142,7 +1101,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             values: qValues,
         });
         const codeDetails = this.getCodeDetailsFromQuorum();
-        await this.instantiateRuntime(codeDetails, snapshotTree);
+        await this.instantiateRuntime(codeDetails, snapshotTreeWithBlobContents, pendingRuntimeState);
         this.setLoaded();
     }
     async getDocumentAttributes(storage, tree) {
@@ -1166,7 +1125,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             values: [],
         };
         if (snapshot !== undefined) {
-            const baseTree = (0, utils_1.getProtocolSnapshotTree)(snapshot);
+            const baseTree = (0, utils_js_1.getProtocolSnapshotTree)(snapshot);
             [quorumSnapshot.members, quorumSnapshot.proposals, quorumSnapshot.values] =
                 await Promise.all([
                     (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumMembers),
@@ -1242,10 +1201,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         const pkg = getCodeProposal(quorum);
         return pkg;
     }
-    static setupClient(containerId, options, clientDetailsOverride) {
-        const loaderOptionsClient = structuredClone(options?.client);
+    static setupClient(containerId, loaderOptionsClient, clientDetailsOverride) {
         const client = loaderOptionsClient !== undefined
-            ? loaderOptionsClient
+            ? (0, structured_clone_1.default)(loaderOptionsClient)
             : {
                 details: {
                     capabilities: { interactive: true },
@@ -1267,7 +1225,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         client.details.environment = [
             client.details.environment,
-            ` loaderVersion:${packageVersion_1.pkgVersion}`,
+            ` loaderVersion:${packageVersion_js_1.pkgVersion}`,
             ` containerId:${containerId}`,
         ].join(";");
         return client;
@@ -1279,11 +1237,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      * If it's not true, runtime is not in position to send ops.
      */
     activeConnection() {
-        return (this.connectionState === connectionState_1.ConnectionState.Connected && this.connectionMode === "write");
+        return (this.connectionState === connectionState_js_1.ConnectionState.Connected && this.connectionMode === "write");
     }
     createDeltaManager() {
         const serviceProvider = () => this.service;
-        const deltaManager = new deltaManager_1.DeltaManager(serviceProvider, (0, telemetry_utils_1.createChildLogger)({ logger: this.subLogger, namespace: "DeltaManager" }), () => this.activeConnection(), (props) => new connectionManager_1.ConnectionManager(serviceProvider, () => this.isDirty, this.client, this._canReconnect, (0, telemetry_utils_1.createChildLogger)({ logger: this.subLogger, namespace: "ConnectionManager" }), props));
+        const deltaManager = new deltaManager_js_1.DeltaManager(serviceProvider, (0, telemetry_utils_1.createChildLogger)({ logger: this.subLogger, namespace: "DeltaManager" }), () => this.activeConnection(), (props) => new connectionManager_js_1.ConnectionManager(serviceProvider, () => this.isDirty, this.client, this._canReconnect, (0, telemetry_utils_1.createChildLogger)({ logger: this.subLogger, namespace: "ConnectionManager" }), props));
         // Disable inbound queues as Container is not ready to accept any ops until we are fully loaded!
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         deltaManager.inbound.pause();
@@ -1299,10 +1257,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         deltaManager.on("cancelEstablishingConnection", (reason) => {
             this.connectionStateHandler.cancelEstablishingConnection(reason);
         });
-        deltaManager.on("disconnect", (reason) => {
+        deltaManager.on("disconnect", (text, error) => {
             this.noopHeuristic?.notifyDisconnect();
             if (!this.closed) {
-                this.connectionStateHandler.receivedDisconnectEvent(reason);
+                this.connectionStateHandler.receivedDisconnectEvent({ text, error });
             }
         });
         deltaManager.on("throttled", (warning) => {
@@ -1315,7 +1273,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             this.emit("warning", warn);
         });
         deltaManager.on("readonly", (readonly) => {
-            this.setContextConnectedState(this.connectionState === connectionState_1.ConnectionState.Connected, readonly);
+            this.setContextConnectedState(this.connectionState === connectionState_js_1.ConnectionState.Connected, readonly);
             this.emit("readonly", readonly);
         });
         deltaManager.on("closed", (error) => {
@@ -1344,16 +1302,16 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         let autoReconnect;
         let checkpointSequenceNumber;
         let opsBehind;
-        if (value === connectionState_1.ConnectionState.Disconnected) {
+        if (value === connectionState_js_1.ConnectionState.Disconnected) {
             autoReconnect = this._deltaManager.connectionManager.reconnectMode;
         }
         else {
-            if (value === connectionState_1.ConnectionState.Connected) {
+            if (value === connectionState_js_1.ConnectionState.Connected) {
                 durationFromDisconnected =
-                    time - this.connectionTransitionTimes[connectionState_1.ConnectionState.Disconnected];
+                    time - this.connectionTransitionTimes[connectionState_js_1.ConnectionState.Disconnected];
                 durationFromDisconnected = (0, telemetry_utils_1.formatTick)(durationFromDisconnected);
             }
-            else if (value === connectionState_1.ConnectionState.CatchingUp) {
+            else if (value === connectionState_js_1.ConnectionState.CatchingUp) {
                 // This info is of most interesting while Catching Up.
                 checkpointSequenceNumber = this.deltaManager.lastKnownSeqNumber;
                 // Need to check that we have already loaded and fetched the snapshot.
@@ -1365,8 +1323,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             connectionInitiationReason = this.firstConnection ? "InitialConnect" : "AutoReconnect";
         }
         this.mc.logger.sendPerformanceEvent({
-            eventName: `ConnectionStateChange_${connectionState_1.ConnectionState[value]}`,
-            from: connectionState_1.ConnectionState[oldState],
+            eventName: `ConnectionStateChange_${connectionState_js_1.ConnectionState[value]}`,
+            from: connectionState_js_1.ConnectionState[oldState],
             duration,
             durationFromDisconnected,
             reason: reason?.text,
@@ -1384,7 +1342,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             isDirty: this.isDirty,
             ...this._deltaManager.connectionProps,
         }, reason?.error);
-        if (value === connectionState_1.ConnectionState.Connected) {
+        if (value === connectionState_js_1.ConnectionState.Connected) {
             this.firstConnection = false;
         }
     }
@@ -1393,11 +1351,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // 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.
         if (!initialTransition &&
-            this.connectionState !== connectionState_1.ConnectionState.Connected &&
-            this.connectionState !== connectionState_1.ConnectionState.Disconnected) {
+            this.connectionState !== connectionState_js_1.ConnectionState.Connected &&
+            this.connectionState !== connectionState_js_1.ConnectionState.Disconnected) {
             return;
         }
-        const state = this.connectionState === connectionState_1.ConnectionState.Connected;
+        const state = this.connectionState === connectionState_js_1.ConnectionState.Connected;
         // Both protocol and context should not be undefined if we got so far.
         this.setContextConnectedState(state, this.readOnlyInfo.readonly ?? false);
         this.protocolHandler.setConnectionState(state, this.clientId);
@@ -1439,7 +1397,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         return this.submitMessage(protocol_definitions_1.MessageType.Summarize, JSON.stringify(summary), false /* batch */, undefined /* metadata */, undefined /* compression */, referenceSequenceNumber);
     }
     submitMessage(type, contents, batch, metadata, compression, referenceSequenceNumber) {
-        if (this.connectionState !== connectionState_1.ConnectionState.Connected) {
+        if (this.connectionState !== connectionState_js_1.ConnectionState.Connected) {
             this.mc.logger.sendErrorEvent({ eventName: "SubmitMessageWithNoConnection", type });
             return -1;
         }
@@ -1447,14 +1405,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         return this._deltaManager.submit(type, contents, batch, metadata, compression, referenceSequenceNumber);
     }
     processRemoteMessage(message) {
-        if (this.offlineLoadEnabled) {
-            this.savedOps.push(message);
-        }
         const local = this.clientId === message.clientId;
         // Allow the protocol handler to process the message
         const result = this.protocolHandler.processMessage(message, local);
         // Forward messages to the loaded runtime for processing
         this.runtime.process(message, local);
+        this.serializedStateManager.addProcessedOp(message);
         // Inactive (not in quorum or not writers) clients don't take part in the minimum sequence number calculation.
         if (this.activeConnection()) {
             if (this.noopHeuristic === undefined) {
@@ -1464,7 +1420,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 // clients.
                 // All existing will continue to use settings they got earlier.
                 (0, core_utils_1.assert)(serviceConfiguration !== undefined, 0x2e4 /* "there should be service config for active connection" */);
-                this.noopHeuristic = new noopHeuristic_1.NoopHeuristic(serviceConfiguration.noopTimeFrequency, serviceConfiguration.noopCountFrequency);
+                this.noopHeuristic = new noopHeuristic_js_1.NoopHeuristic(serviceConfiguration.noopTimeFrequency, serviceConfiguration.noopCountFrequency);
                 this.noopHeuristic.on("wantsNoop", () => {
                     // On disconnect we notify the heuristic which should prevent it from wanting a noop.
                     // Hitting this assert would imply we lost activeConnection between notifying the heuristic of a processed message and
@@ -1487,7 +1443,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     processSignal(message) {
         // No clientId indicates a system signal message.
-        if ((0, protocol_1.protocolHandlerShouldProcessSignal)(message)) {
+        if ((0, protocol_js_1.protocolHandlerShouldProcessSignal)(message)) {
             this.protocolHandler.processSignal(message);
         }
         else {
@@ -1495,33 +1451,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             this.runtime.processSignal(message, local);
         }
     }
-    /**
-     * Get the most recent snapshot, or a specific version.
-     * @param specifiedVersion - The specific version of the snapshot to retrieve
-     * @returns The snapshot requested, or the latest snapshot if no version was specified, plus version ID
-     */
-    async fetchSnapshotTree(specifiedVersion) {
-        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({
-                eventName: "NoVersionFoundWhenSpecified",
-                id: specifiedVersion,
-            });
-        }
-        this._loadedFromVersion = version;
-        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?.id };
-    }
-    async instantiateRuntime(codeDetails, snapshot, pendingLocalState) {
+    async instantiateRuntime(codeDetails, snapshotTree, pendingLocalState, snapshot) {
         (0, core_utils_1.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;
-        const loader = new loader_1.RelativeLoader(this, maybeLoader.ILoader);
+        const loader = new loader_js_1.RelativeLoader(this, maybeLoader.ILoader);
         const loadCodeResult = await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.subLogger, { eventName: "CodeLoad" }, async () => this.codeLoader.load(codeDetails));
         this._loadedModule = {
             module: loadCodeResult.module,
@@ -1537,8 +1472,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         const getSpecifiedCodeDetails = () => (this.protocolHandler.quorum.get("code") ??
             this.protocolHandler.quorum.get("code2"));
-        const existing = snapshot !== undefined;
-        const context = new containerContext_1.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), (content, targetClientId) => this.submitSignal(content, targetClientId), (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);
+        const existing = snapshotTree !== undefined;
+        const context = new containerContext_js_1.ContainerContext(this.options, this.scope, snapshotTree, 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), (content, targetClientId) => this.submitSignal(content, targetClientId), (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, snapshot);
         this._runtime = await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.subLogger, { eventName: "InstantiateRuntime" }, async () => runtimeFactory.instantiateRuntime(context, existing));
         this._lifecycleEvents.emit("runtimeInstantiated");
         this._loadedCodeDetails = codeDetails;