@fluidframework/container-loader 2.0.0-dev-rc.1.0.0.228517 → 2.0.0-dev-rc.2.0.0.245554

package/lib/{container.mjs → container.js}

@@ -3,32 +3,34 @@
  * Licensed under the MIT License.
  */
 import { v4 as uuid } from "uuid";
-import { assert, unreachableCase } from "@fluidframework/core-utils";
+import { assert, unreachableCase, isPromiseLike } from "@fluidframework/core-utils";
 import { TypedEventEmitter, performance } from "@fluid-internal/client-utils";
 import { LogLevel, } from "@fluidframework/core-interfaces";
 import { AttachState, isFluidCodeDetails, } from "@fluidframework/container-definitions";
-import { readAndParse, OnlineStatus, isOnline, runWithRetry, isCombinedAppAndProtocolSummary, MessageType2, } from "@fluidframework/driver-utils";
+import { readAndParse, OnlineStatus, isOnline, isCombinedAppAndProtocolSummary, MessageType2, isInstanceOfISnapshot, runWithRetry, } from "@fluidframework/driver-utils";
 import { MessageType, SummaryType, } from "@fluidframework/protocol-definitions";
 import { createChildLogger, EventEmitterWithErrorHandling, PerformanceEvent, raiseConnectedEvent, connectedEventName, normalizeError, createChildMonitoringContext, wrapError, formatTick, GenericError, UsageError, } from "@fluidframework/telemetry-utils";
-import { Audience } from "./audience.mjs";
-import { ContainerContext } from "./containerContext.mjs";
-import { ReconnectMode, getPackageName, } from "./contracts.mjs";
-import { DeltaManager } from "./deltaManager.mjs";
-import { RelativeLoader } from "./loader.mjs";
-import { pkgVersion } from "./packageVersion.mjs";
-import { ContainerStorageAdapter, getBlobContentsFromTree, getBlobContentsFromTreeWithBlobContents, } from "./containerStorageAdapter.mjs";
-import { createConnectionStateHandler } from "./connectionStateHandler.mjs";
-import { combineAppAndProtocolSummary, getProtocolSnapshotTree, getSnapshotTreeFromSerializedContainer, } from "./utils.mjs";
-import { initQuorumValuesFromCodeDetails } from "./quorum.mjs";
-import { NoopHeuristic } from "./noopHeuristic.mjs";
-import { ConnectionManager } from "./connectionManager.mjs";
-import { ConnectionState } from "./connectionState.mjs";
-import { ProtocolHandler, protocolHandlerShouldProcessSignal, } from "./protocol.mjs";
+import structuredClone from "@ungap/structured-clone";
+import { Audience } from "./audience.js";
+import { ContainerContext } from "./containerContext.js";
+import { ReconnectMode, getPackageName, } from "./contracts.js";
+import { DeltaManager } from "./deltaManager.js";
+import { RelativeLoader } from "./loader.js";
+import { pkgVersion } from "./packageVersion.js";
+import { ContainerStorageAdapter } from "./containerStorageAdapter.js";
+import { createConnectionStateHandler } from "./connectionStateHandler.js";
+import { combineAppAndProtocolSummary, getProtocolSnapshotTree, getSnapshotTreeAndBlobsFromSerializedContainer, combineSnapshotTreeAndSnapshotBlobs, getDetachedContainerStateFromSerializedContainer, runSingle, } from "./utils.js";
+import { initQuorumValuesFromCodeDetails } from "./quorum.js";
+import { NoopHeuristic } from "./noopHeuristic.js";
+import { ConnectionManager } from "./connectionManager.js";
+import { ConnectionState } from "./connectionState.js";
+import { ProtocolHandler, protocolHandlerShouldProcessSignal, } from "./protocol.js";
+import { runRetriableAttachProcess } from "./attachment.js";
+import { SerializedStateManager } from "./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.
  *
@@ -103,9 +105,7 @@ export async function waitContainerToCatchUp(container) {
         }
     });
 }
-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
@@ -123,7 +123,6 @@ const summarizerClientType = "summarizer";
 export class Container extends EventEmitterWithErrorHandling {
     /**
      * Load an existing container.
-     * @internal
      */
     static async load(loadProps, createProps) {
         const { version, pendingLocalState, loadMode, resolvedUrl, loadToSequenceNumber } = loadProps;
@@ -180,11 +179,8 @@ export class Container extends EventEmitterWithErrorHandling {
     static async rehydrateDetachedFromSnapshot(createProps, snapshot) {
         const container = new Container(createProps);
         return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "RehydrateDetachedFromSnapshot" }, async (_event) => {
-            const deserializedSummary = JSON.parse(snapshot);
-            if (!isCombinedAppAndProtocolSummary(deserializedSummary, hasBlobsSummaryTree)) {
-                throw new UsageError("Cannot rehydrate detached container. Incorrect format");
-            }
-            await container.rehydrateDetachedFromSnapshot(deserializedSummary);
+            const detachedContainerState = getDetachedContainerStateFromSerializedContainer(snapshot);
+            await container.rehydrateDetachedFromSnapshot(detachedContainerState);
             return container;
         }, { start: true, end: true, cancel: "generic" });
     }
@@ -235,6 +231,9 @@ export class Container extends 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.
@@ -271,11 +270,8 @@ export class Container extends 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.
@@ -330,9 +326,6 @@ export class Container extends EventEmitterWithErrorHandling {
             this._lifecycleEvents.once("disposed", disposedHandler);
         });
     }
-    /**
-     * @internal
-     */
     constructor(createProps, loadProps) {
         super((name, error) => {
             this.mc.logger.sendErrorEvent({
@@ -356,24 +349,102 @@ export class Container extends EventEmitterWithErrorHandling {
          * disposed: Container has been disposed
          */
         this._lifecycleState = "loading";
-        this._attachState = 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: AttachState.Detached };
         this.clientsWhoShouldHaveLeft = new Set();
+        this._containerMetadata = {};
         this.setAutoReconnectTime = performance.now();
         this._lifecycleEvents = new TypedEventEmitter();
         this._disposed = false;
+        this.attach = runSingle(async (request, attachProps) => {
+            await PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Attach" }, async () => {
+                if (this._lifecycleState !== "loaded" ||
+                    this.attachmentData.state === AttachState.Attached) {
+                    // pre-0.58 error message: containerNotValidForAttach
+                    throw new UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}] and [${this.attachState}]`);
+                }
+                const normalizeErrorAndClose = (error) => {
+                    const newError = 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 !== AttachState.Detached) {
+                        try {
+                            this.runtime.setAttachState(state);
+                            this.emit(state.toLocaleLowerCase());
+                        }
+                        catch (error) {
+                            throw normalizeErrorAndClose(error);
+                        }
+                    }
+                };
+                const createAttachmentSummary = (redirectTable) => {
+                    try {
+                        assert(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
+                        return 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);
+                        assert(this.client.details.type !== summarizerClientType &&
+                            createNewResolvedUrl !== undefined, 0x2c4 /* "client should not be summarizer before container is created" */);
+                        this.service = await 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 = 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, getPackageName(this._loadedCodeDetails));
         };
+        this.metadataUpdateHandler = (metadata) => {
+            this._containerMetadata = { ...this._containerMetadata, ...metadata };
+            this.emit("metadataUpdate", metadata);
+        };
         this.updateDirtyContainerState = (dirty) => {
             if (this._dirtyContainer === dirty) {
                 return;
@@ -407,7 +478,7 @@ export class Container extends EventEmitterWithErrorHandling {
             });
         };
         this._containerId = uuid();
-        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;
@@ -421,7 +492,7 @@ export class Container extends EventEmitterWithErrorHandling {
                     clientType,
                     containerId: this._containerId,
                     docId: () => this.resolvedUrl?.id,
-                    containerAttachState: () => this._attachState,
+                    containerAttachState: () => this.attachState,
                     containerLifecycleState: () => this._lifecycleState,
                     containerConnectionState: () => ConnectionState[this.connectionState],
                     serializedContainer: pendingLocalState !== undefined,
@@ -513,6 +584,10 @@ export class Container extends EventEmitterWithErrorHandling {
         const forceEnableSummarizeProtocolTree = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2") ??
             options.summarizeProtocolTree;
         this.storageAdapter = new 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(pendingLocalState, this.subLogger, this.storageAdapter, offlineLoadEnabled);
         const isDomAvailable = typeof document === "object" &&
             document !== null &&
             typeof document.addEventListener === "function" &&
@@ -572,6 +647,10 @@ export class Container extends 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();
             }
@@ -647,149 +726,35 @@ export class Container extends EventEmitterWithErrorHandling {
         return this.getPendingLocalStateCore({ notifyImminentClosure: false });
     }
     async getPendingLocalStateCore(props) {
-        return PerformanceEvent.timedExecAsync(this.mc.logger, {
-            eventName: "getPendingLocalState",
-            notifyImminentClosure: props.notifyImminentClosure,
-            savedOpsSize: this.savedOps.length,
-            clientId: this.clientId,
-        }, async () => {
-            if (!this.offlineLoadEnabled) {
-                throw new UsageError("Can't get pending local state unless offline load is enabled");
-            }
-            if (this.closed || this._disposed) {
-                throw new UsageError("Pending state cannot be retried if the container is closed or disposed");
-            }
-            assert(this.attachState === AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
-            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,
-                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 UsageError("Pending state cannot be retried if the container is closed or disposed");
+        }
+        assert(this.attachmentData.state === AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
+        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() {
-        assert(this.attachState === AttachState.Detached, 0x0d3 /* "Should only be called in detached container" */);
-        const appSummary = this.runtime.createSummary();
-        const protocolSummary = this.captureProtocolSummary();
-        const combinedSummary = combineAppAndProtocolSummary(appSummary, protocolSummary);
-        if (this.detachedBlobStorage && this.detachedBlobStorage.size > 0) {
-            combinedSummary.tree[hasBlobsSummaryTree] = {
-                type: SummaryType.Blob,
-                content: "true",
-            };
+        if (this.attachmentData.state === AttachState.Attached || this.closed) {
+            throw new UsageError("Container must not be attached or closed.");
         }
-        return JSON.stringify(combinedSummary);
-    }
-    async attach(request, attachProps) {
-        await PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Attach" }, async () => {
-            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}]`);
-            }
-            // If container is already attached or attach is in progress, throw an error.
-            assert(this._attachState === 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 {
-                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 = 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 = AttachState.Attaching;
-                    this.runtime.setAttachState(AttachState.Attaching);
-                    this.emit("attaching");
-                    if (this.offlineLoadEnabled) {
-                        const snapshot = getSnapshotTreeFromSerializedContainer(summary);
-                        this.baseSnapshot = snapshot;
-                        this.baseSnapshotBlobs =
-                            getBlobContentsFromTreeWithBlobContents(snapshot);
-                    }
-                }
-                // Actually go and create the resolved document
-                if (this.service === undefined) {
-                    const createNewResolvedUrl = await this.urlResolver.resolve(request);
-                    assert(this.client.details.type !== summarizerClientType &&
-                        createNewResolvedUrl !== undefined, 0x2c4 /* "client should not be summarizer before container is created" */);
-                    this.service = await 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
-                    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 = combineAppAndProtocolSummary(appSummary, protocolSummary);
-                    this._attachState = AttachState.Attaching;
-                    this.runtime.setAttachState(AttachState.Attaching);
-                    this.emit("attaching");
-                    if (this.offlineLoadEnabled) {
-                        const snapshot = getSnapshotTreeFromSerializedContainer(summary);
-                        this.baseSnapshot = snapshot;
-                        this.baseSnapshotBlobs =
-                            getBlobContentsFromTreeWithBlobContents(snapshot);
-                    }
-                    await this.storageAdapter.uploadSummaryWithContext(summary, {
-                        referenceSequenceNumber: 0,
-                        ackHandle: undefined,
-                        proposalHandle: undefined,
-                    });
-                }
-                this._attachState = AttachState.Attached;
-                this.runtime.setAttachState(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 = normalizeError(error);
-                newError.addTelemetryProperties({ resolvedUrl: this.resolvedUrl?.url });
-                this.close(newError);
-                throw newError;
-            }
-        }, { start: true, end: true, cancel: "generic" });
+        const attachingData = this.attachmentData.state === AttachState.Attaching ? this.attachmentData : undefined;
+        const combinedSummary = attachingData?.summary ??
+            combineAppAndProtocolSummary(this.runtime.createSummary(), this.captureProtocolSummary());
+        const { tree: snapshot, blobs } = getSnapshotTreeAndBlobsFromSerializedContainer(combinedSummary);
+        const pendingRuntimeState = attachingData !== undefined ? this.runtime.getPendingLocalState() : undefined;
+        assert(!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;
@@ -811,7 +776,7 @@ export class Container extends EventEmitterWithErrorHandling {
         if (this.closed) {
             throw new UsageError(`The Container is closed and cannot be connected`);
         }
-        else if (this._attachState !== AttachState.Attached) {
+        else if (this.attachState !== AttachState.Attached) {
             throw new UsageError(`The Container is not attached and cannot be connected`);
         }
         else if (!this.connected) {
@@ -826,7 +791,7 @@ export class Container extends EventEmitterWithErrorHandling {
     }
     connectInternal(args) {
         assert(!this.closed, 0x2c5 /* "Attempting to connect() a closed Container" */);
-        assert(this._attachState === AttachState.Attached, 0x2c6 /* "Attempting to connect() a container that is not attached" */);
+        assert(this.attachState === 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
@@ -919,10 +884,6 @@ export class Container extends 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) {
@@ -930,6 +891,14 @@ export class Container extends 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.
      *
@@ -937,7 +906,7 @@ export class Container extends EventEmitterWithErrorHandling {
      */
     async load(specifiedVersion, loadMode, resolvedUrl, pendingLocalState, loadToSequenceNumber) {
         const timings = { phase1: 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
@@ -954,25 +923,14 @@ export class Container extends EventEmitterWithErrorHandling {
             this.connectToDeltaStream(connectionArgs);
         }
         this.storageAdapter.connectToService(this.service);
-        this._attachState = AttachState.Attached;
+        this.attachmentData = {
+            state: AttachState.Attached,
+        };
         timings.phase2 = 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 {
-            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 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;
@@ -1037,12 +995,12 @@ export class Container extends 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 = 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, isInstanceOfISnapshot(snapshotTree) ? snapshotTree : undefined);
         // replay saved ops
         if (pendingLocalState) {
             for (const message of pendingLocalState.savedOps) {
@@ -1097,7 +1055,7 @@ export class Container extends EventEmitterWithErrorHandling {
         }, undefined, LogLevel.verbose);
         return {
             sequenceNumber: attributes.sequenceNumber,
-            version: versionId,
+            version: version?.id,
             dmLastProcessedSeqNumber: this._deltaManager.lastSequenceNumber,
             dmLastKnownSeqNumber: this._deltaManager.lastKnownSeqNumber,
         };
@@ -1118,18 +1076,16 @@ export class Container extends EventEmitterWithErrorHandling {
         await this.instantiateRuntime(codeDetails, undefined);
         this.setLoaded();
     }
-    async rehydrateDetachedFromSnapshot(detachedContainerSnapshot) {
-        if (detachedContainerSnapshot.tree[hasBlobsSummaryTree] !== undefined) {
+    async rehydrateDetachedFromSnapshot({ baseSnapshot, snapshotBlobs, hasAttachmentBlobs, pendingRuntimeState, }) {
+        if (hasAttachmentBlobs) {
             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 = getSnapshotTreeFromSerializedContainer(detachedContainerSnapshot);
-        this.storageAdapter.loadSnapshotForRehydratingContainer(snapshotTree);
-        const attributes = await this.getDocumentAttributes(this.storageAdapter, snapshotTree);
+        const snapshotTreeWithBlobContents = 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 = getProtocolSnapshotTree(snapshotTree);
+        const baseTree = getProtocolSnapshotTree(snapshotTreeWithBlobContents);
         const qValues = await readAndParse(this.storageAdapter, baseTree.blobs.quorumValues);
         this.initializeProtocolState(attributes, {
             members: [],
@@ -1137,7 +1093,7 @@ export class Container extends EventEmitterWithErrorHandling {
             values: qValues,
         });
         const codeDetails = this.getCodeDetailsFromQuorum();
-        await this.instantiateRuntime(codeDetails, snapshotTree);
+        await this.instantiateRuntime(codeDetails, snapshotTreeWithBlobContents, pendingRuntimeState);
         this.setLoaded();
     }
     async getDocumentAttributes(storage, tree) {
@@ -1237,10 +1193,9 @@ export class Container extends 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
+            ? structuredClone(loaderOptionsClient)
             : {
                 details: {
                     capabilities: { interactive: true },
@@ -1294,10 +1249,10 @@ export class Container extends 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) => {
@@ -1442,14 +1397,12 @@ export class Container extends 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) {
@@ -1490,28 +1443,7 @@ export class Container extends 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) {
         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
@@ -1532,8 +1464,8 @@ export class Container extends EventEmitterWithErrorHandling {
         }
         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), (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(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 PerformanceEvent.timedExecAsync(this.subLogger, { eventName: "InstantiateRuntime" }, async () => runtimeFactory.instantiateRuntime(context, existing));
         this._lifecycleEvents.emit("runtimeInstantiated");
         this._loadedCodeDetails = codeDetails;
@@ -1576,4 +1508,4 @@ export class Container extends EventEmitterWithErrorHandling {
         }
     }
 }
-//# sourceMappingURL=container.mjs.map
+//# sourceMappingURL=container.js.map