@fluidframework/container-loader 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/lib/container.js

@@ -1,1276 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-// eslint-disable-next-line import/no-internal-modules
-import merge from "lodash/merge";
-import { v4 as uuid } from "uuid";
-import { assert, performance, unreachableCase } from "@fluidframework/common-utils";
-import { AttachState, isFluidCodeDetails, } from "@fluidframework/container-definitions";
-import { DataCorruptionError, extractSafePropertiesFromMessage, GenericError, UsageError, } from "@fluidframework/container-utils";
-import { readAndParse, OnlineStatus, isOnline, ensureFluidResolvedUrl, combineAppAndProtocolSummary, runWithRetry, isFluidResolvedUrl, isRuntimeMessage, isUnpackedRuntimeMessage, } from "@fluidframework/driver-utils";
-import { ProtocolOpHandlerWithClientValidation, } from "@fluidframework/protocol-base";
-import { MessageType, SummaryType, } from "@fluidframework/protocol-definitions";
-import { ChildLogger, EventEmitterWithErrorHandling, PerformanceEvent, raiseConnectedEvent, TelemetryLogger, connectedEventName, disconnectedEventName, normalizeError, loggerToMonitoringContext, wrapError, } from "@fluidframework/telemetry-utils";
-import { Audience } from "./audience";
-import { ContainerContext } from "./containerContext";
-import { ReconnectMode, getPackageName } from "./contracts";
-import { DeltaManager } from "./deltaManager";
-import { DeltaManagerProxy } from "./deltaManagerProxy";
-import { RelativeLoader } from "./loader";
-import { pkgVersion } from "./packageVersion";
-import { ConnectionStateHandler } from "./connectionStateHandler";
-import { RetriableDocumentStorageService } from "./retriableDocumentStorageService";
-import { ProtocolTreeStorageService } from "./protocolTreeDocumentStorageService";
-import { BlobOnlyStorage, ContainerStorageAdapter } from "./containerStorageAdapter";
-import { getProtocolSnapshotTree, getSnapshotTreeFromSerializedContainer } from "./utils";
-import { initQuorumValuesFromCodeDetails, getCodeDetailsFromQuorumValues, QuorumProxy } from "./quorum";
-import { CollabWindowTracker } from "./collabWindowTracker";
-import { ConnectionManager } from "./connectionManager";
-import { ConnectionState } from "./connectionState";
-const detachedContainerRefSeqNumber = 0;
-const dirtyContainerEvent = "dirty";
-const savedContainerEvent = "saved";
-/**
- * Waits until container connects to delta storage and gets up-to-date
- * Useful when resolving URIs and hitting 404, due to container being loaded from (stale) snapshot and not being
- * up to date. Host may chose to wait in such case and retry resolving URI.
- * Warning: Will wait infinitely for connection to establish if there is no connection.
- * May result in deadlock if Container.disconnect() is called and never followed by a call to Container.connect().
- * @returns true: container is up to date, it processed all the ops that were know at the time of first connection
- *          false: storage does not provide indication of how far the client is. Container processed
- *          all the ops known to it, but it maybe still behind.
- * @throws an error beginning with `"Container closed"` if the container is closed before it catches up.
- */
-export async function waitContainerToCatchUp(container) {
-    // Make sure we stop waiting if container is closed.
-    if (container.closed) {
-        throw new UsageError("waitContainerToCatchUp: Container closed");
-    }
-    return new Promise((resolve, reject) => {
-        const deltaManager = container.deltaManager;
-        const closedCallback = (err) => {
-            container.off("closed", closedCallback);
-            const baseMessage = "Container closed while waiting to catch up";
-            reject(err !== undefined
-                ? wrapError(err, (innerMessage) => new GenericError(`${baseMessage}: ${innerMessage}`))
-                : new GenericError(baseMessage));
-        };
-        container.on("closed", closedCallback);
-        const waitForOps = () => {
-            assert(container.connectionState === ConnectionState.CatchingUp
-                || container.connectionState === ConnectionState.Connected, 0x0cd /* "Container disconnected while waiting for ops!" */);
-            const hasCheckpointSequenceNumber = deltaManager.hasCheckpointSequenceNumber;
-            const connectionOpSeqNumber = deltaManager.lastKnownSeqNumber;
-            assert(deltaManager.lastSequenceNumber <= connectionOpSeqNumber, 0x266 /* "lastKnownSeqNumber should never be below last processed sequence number" */);
-            if (deltaManager.lastSequenceNumber === connectionOpSeqNumber) {
-                container.off("closed", closedCallback);
-                resolve(hasCheckpointSequenceNumber);
-                return;
-            }
-            const callbackOps = (message) => {
-                if (connectionOpSeqNumber <= message.sequenceNumber) {
-                    container.off("closed", closedCallback);
-                    resolve(hasCheckpointSequenceNumber);
-                    deltaManager.off("op", callbackOps);
-                }
-            };
-            deltaManager.on("op", callbackOps);
-        };
-        // We can leverage DeltaManager's "connect" event here and test for ConnectionState.Disconnected
-        // 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.Connected) {
-            waitForOps();
-            return;
-        }
-        const callback = () => {
-            container.off(connectedEventName, callback);
-            waitForOps();
-        };
-        container.on(connectedEventName, callback);
-        if (container.connectionState === ConnectionState.Disconnected) {
-            container.connect();
-        }
-    });
-}
-const getCodeProposal = 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-(quorum) => { var _a; return (_a = quorum.get("code")) !== null && _a !== void 0 ? _a : quorum.get("code2"); };
-/**
- * Helper function to report to telemetry cases where operation takes longer than expected (1s)
- * @param logger - logger to use
- * @param eventName - event name
- * @param action - functor to call and measure
- */
-async function ReportIfTooLong(logger, eventName, action) {
-    const event = PerformanceEvent.start(logger, { eventName });
-    const props = await action();
-    if (event.duration > 1000) {
-        event.end(props);
-    }
-}
-const summarizerClientType = "summarizer";
-export class Container extends EventEmitterWithErrorHandling {
-    constructor(loader, config) {
-        var _a, _b;
-        super((name, error) => {
-            this.mc.logger.sendErrorEvent({
-                eventName: "ContainerEventHandlerException",
-                name: typeof name === "string" ? name : undefined,
-            }, error);
-        });
-        this.loader = loader;
-        // Tells if container can reconnect on losing fist connection
-        // If false, container gets closed on loss of connection.
-        this._canReconnect = true;
-        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.messageCountAfterDisconnection = 0;
-        this.attachStarted = false;
-        this._dirtyContainer = false;
-        this.setAutoReconnectTime = performance.now();
-        this._audience = new Audience();
-        this.clientDetailsOverride = config.clientDetailsOverride;
-        this._resolvedUrl = config.resolvedUrl;
-        if (config.canReconnect !== undefined) {
-            this._canReconnect = config.canReconnect;
-        }
-        // Create logger for data stores to use
-        const type = this.client.details.type;
-        const interactive = this.client.details.capabilities.interactive;
-        const clientType = `${interactive ? "interactive" : "noninteractive"}${type !== undefined && type !== "" ? `/${type}` : ""}`;
-        // Need to use the property getter for docId because for detached flow we don't have the docId initially.
-        // We assign the id later so property getter is used.
-        this.subLogger = ChildLogger.create(loader.services.subLogger, undefined, {
-            all: {
-                clientType,
-                containerId: uuid(),
-                docId: () => { var _a, _b; return (_b = (_a = this._resolvedUrl) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : undefined; },
-                containerAttachState: () => this._attachState,
-                containerLifecycleState: () => this._lifecycleState,
-                containerConnectionState: () => ConnectionState[this.connectionState],
-                serializedContainer: config.serializedContainerState !== undefined,
-            },
-            // we need to be judicious with our logging here to avoid generating too much data
-            // all data logged here should be broadly applicable, and not specific to a
-            // specific error or class of errors
-            error: {
-                // load information to associate errors with the specific load point
-                dmInitialSeqNumber: () => { var _a; return (_a = this._deltaManager) === null || _a === void 0 ? void 0 : _a.initialSequenceNumber; },
-                dmLastProcessedSeqNumber: () => { var _a; return (_a = this._deltaManager) === null || _a === void 0 ? void 0 : _a.lastSequenceNumber; },
-                dmLastKnownSeqNumber: () => { var _a; return (_a = this._deltaManager) === null || _a === void 0 ? void 0 : _a.lastKnownSeqNumber; },
-                containerLoadedFromVersionId: () => { var _a; return (_a = this.loadedFromVersion) === null || _a === void 0 ? void 0 : _a.id; },
-                containerLoadedFromVersionDate: () => { var _a; return (_a = this.loadedFromVersion) === null || _a === void 0 ? void 0 : _a.date; },
-                // message information to associate errors with the specific execution state
-                // dmLastMsqSeqNumber: if present, same as dmLastProcessedSeqNumber
-                dmLastMsqSeqNumber: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.sequenceNumber; },
-                dmLastMsqSeqTimestamp: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.timestamp; },
-                dmLastMsqSeqClientId: () => { var _a, _b; return (_b = (_a = this.deltaManager) === null || _a === void 0 ? void 0 : _a.lastMessage) === null || _b === void 0 ? void 0 : _b.clientId; },
-                connectionStateDuration: () => performance.now() - this.connectionTransitionTimes[this.connectionState],
-            },
-        });
-        // Prefix all events in this file with container-loader
-        this.mc = loggerToMonitoringContext(ChildLogger.create(this.subLogger, "Container"));
-        const summarizeProtocolTree = (_a = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree")) !== null && _a !== void 0 ? _a : this.loader.services.options.summarizeProtocolTree;
-        this.options = Object.assign(Object.assign({}, this.loader.services.options), { summarizeProtocolTree });
-        this.connectionStateHandler = new ConnectionStateHandler({
-            quorumClients: () => { var _a; return (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.quorum; },
-            logConnectionStateChangeTelemetry: (value, oldState, reason) => this.logConnectionStateChangeTelemetry(value, oldState, reason),
-            shouldClientJoinWrite: () => this._deltaManager.connectionManager.shouldJoinWrite(),
-            maxClientLeaveWaitTime: this.loader.services.options.maxClientLeaveWaitTime,
-            logConnectionIssue: (eventName, details) => {
-                // We get here when socket does not receive any ops on "write" connection, including
-                // its own join op. Attempt recovery option.
-                this._deltaManager.logConnectionIssue(Object.assign({ eventName, duration: performance.now() - this.connectionTransitionTimes[ConnectionState.CatchingUp] }, (details === undefined ? {} : { details: JSON.stringify(details) })));
-            },
-            connectionStateChanged: () => {
-                // Fire events only if container is fully loaded and not closed
-                if (this._lifecycleState === "loaded") {
-                    this.propagateConnectionState();
-                }
-            },
-        }, this.mc.logger, (_b = config.serializedContainerState) === null || _b === void 0 ? void 0 : _b.clientId);
-        this.on(savedContainerEvent, () => {
-            this.connectionStateHandler.containerSaved();
-        });
-        this._deltaManager = this.createDeltaManager();
-        this._storage = new ContainerStorageAdapter(() => {
-            if (this.attachState !== AttachState.Attached) {
-                if (this.loader.services.detachedBlobStorage !== undefined) {
-                    return new BlobOnlyStorage(this.loader.services.detachedBlobStorage, this.mc.logger);
-                }
-                this.mc.logger.sendErrorEvent({
-                    eventName: "NoRealStorageInDetachedContainer",
-                });
-                throw new Error("Real storage calls not allowed in Unattached container");
-            }
-            return this.storageService;
-        });
-        const isDomAvailable = typeof document === "object" &&
-            document !== null &&
-            typeof document.addEventListener === "function" &&
-            document.addEventListener !== null;
-        // keep track of last time page was visible for telemetry
-        if (isDomAvailable) {
-            this.lastVisible = document.hidden ? performance.now() : undefined;
-            this.visibilityEventHandler = () => {
-                if (document.hidden) {
-                    this.lastVisible = performance.now();
-                }
-                else {
-                    // settimeout so this will hopefully fire after disconnect event if being hidden caused it
-                    setTimeout(() => { this.lastVisible = undefined; }, 0);
-                }
-            };
-            document.addEventListener("visibilitychange", this.visibilityEventHandler);
-        }
-        // We observed that most users of platform do not check Container.connected event on load, causing bugs.
-        // As such, we are raising events when new listener pops up.
-        // Note that we can raise both "disconnected" & "connect" events at the same time,
-        // if we are in connecting stage.
-        this.on("newListener", (event, listener) => {
-            // Fire events on the end of JS turn, giving a chance for caller to be in consistent state.
-            Promise.resolve().then(() => {
-                switch (event) {
-                    case dirtyContainerEvent:
-                        if (this._dirtyContainer) {
-                            listener();
-                        }
-                        break;
-                    case savedContainerEvent:
-                        if (!this._dirtyContainer) {
-                            listener();
-                        }
-                        break;
-                    case connectedEventName:
-                        if (this.connected) {
-                            listener(this.clientId);
-                        }
-                        break;
-                    case disconnectedEventName:
-                        if (!this.connected) {
-                            listener();
-                        }
-                        break;
-                    default:
-                }
-            }).catch((error) => {
-                this.mc.logger.sendErrorEvent({ eventName: "RaiseConnectedEventError" }, error);
-            });
-        });
-    }
-    /**
-     * Load an existing container.
-     */
-    static async load(loader, loadOptions, pendingLocalState) {
-        const container = new Container(loader, {
-            clientDetailsOverride: loadOptions.clientDetailsOverride,
-            resolvedUrl: loadOptions.resolvedUrl,
-            canReconnect: loadOptions.canReconnect,
-            serializedContainerState: pendingLocalState,
-        });
-        return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "Load" }, async (event) => new Promise((resolve, reject) => {
-            var _a, _b;
-            const version = loadOptions.version;
-            const defaultMode = { opsBeforeReturn: "cached" };
-            // if we have pendingLocalState, anything we cached is not useful and we shouldn't wait for connection
-            // to return container, so ignore this value and use undefined for opsBeforeReturn
-            const mode = pendingLocalState
-                ? Object.assign(Object.assign({}, ((_a = loadOptions.loadMode) !== null && _a !== void 0 ? _a : defaultMode)), { opsBeforeReturn: undefined }) : (_b = loadOptions.loadMode) !== null && _b !== void 0 ? _b : defaultMode;
-            const onClosed = (err) => {
-                // pre-0.58 error message: containerClosedWithoutErrorDuringLoad
-                reject(err !== null && err !== void 0 ? err : new GenericError("Container closed without error during load"));
-            };
-            container.on("closed", onClosed);
-            container.load(version, mode, pendingLocalState)
-                .finally(() => {
-                container.removeListener("closed", onClosed);
-            })
-                .then((props) => {
-                event.end(Object.assign(Object.assign({}, props), loadOptions.loadMode));
-                resolve(container);
-            }, (error) => {
-                const err = normalizeError(error);
-                // Depending where error happens, we can be attempting to connect to web socket
-                // and continuously retrying (consider offline mode)
-                // Host has no container to close, so it's prudent to do it here
-                container.close(err);
-                onClosed(err);
-            });
-        }), { start: true, end: true, cancel: "generic" });
-    }
-    /**
-     * Create a new container in a detached state.
-     */
-    static async createDetached(loader, codeDetails) {
-        const container = new Container(loader, {});
-        return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "CreateDetached" }, async (_event) => {
-            await container.createDetached(codeDetails);
-            return container;
-        }, { start: true, end: true, cancel: "generic" });
-    }
-    /**
-     * Create a new container in a detached state that is initialized with a
-     * snapshot from a previous detached container.
-     */
-    static async rehydrateDetachedFromSnapshot(loader, snapshot) {
-        const container = new Container(loader, {});
-        return PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "RehydrateDetachedFromSnapshot" }, async (_event) => {
-            const deserializedSummary = JSON.parse(snapshot);
-            await container.rehydrateDetachedFromSnapshot(deserializedSummary);
-            return container;
-        }, { start: true, end: true, cancel: "generic" });
-    }
-    setLoaded() {
-        // It's conceivable the container could be closed when this is called
-        // Only transition states if currently loading
-        if (this._lifecycleState === "loading") {
-            // Propagate current connection state through the system.
-            this.propagateConnectionState();
-            this._lifecycleState = "loaded";
-        }
-    }
-    get closed() {
-        return (this._lifecycleState === "closing" || this._lifecycleState === "closed");
-    }
-    get storage() {
-        return this._storage;
-    }
-    get storageService() {
-        if (this._storageService === undefined) {
-            throw new Error("Attempted to access storageService before it was defined");
-        }
-        return this._storageService;
-    }
-    get context() {
-        if (this._context === undefined) {
-            throw new GenericError("Attempted to access context before it was defined");
-        }
-        return this._context;
-    }
-    get protocolHandler() {
-        if (this._protocolHandler === undefined) {
-            throw new Error("Attempted to access protocolHandler before it was defined");
-        }
-        return this._protocolHandler;
-    }
-    get connectionMode() { return this._deltaManager.connectionManager.connectionMode; }
-    get IFluidRouter() { return this; }
-    get resolvedUrl() {
-        return this._resolvedUrl;
-    }
-    get loadedFromVersion() {
-        return this._loadedFromVersion;
-    }
-    get readOnlyInfo() {
-        return this._deltaManager.readOnlyInfo;
-    }
-    get closeSignal() {
-        return this._deltaManager.closeAbortController.signal;
-    }
-    /**
-     * Tracks host requiring read-only mode.
-     */
-    forceReadonly(readonly) {
-        this._deltaManager.connectionManager.forceReadonly(readonly);
-    }
-    get deltaManager() {
-        return this._deltaManager;
-    }
-    get connectionState() {
-        return this.connectionStateHandler.connectionState;
-    }
-    get connected() {
-        return this.connectionStateHandler.connected;
-    }
-    /**
-     * Service configuration details. If running in offline mode will be undefined otherwise will contain service
-     * configuration details returned as part of the initial connection.
-     */
-    get serviceConfiguration() {
-        return this._deltaManager.serviceConfiguration;
-    }
-    /**
-     * The server provided id of the client.
-     * Set once this.connected is true, otherwise undefined
-     */
-    get clientId() {
-        return this.connectionStateHandler.clientId;
-    }
-    /**
-     * The server provided claims of the client.
-     * Set once this.connected is true, otherwise undefined
-     */
-    get scopes() {
-        return this._deltaManager.connectionManager.scopes;
-    }
-    get clientDetails() {
-        return this._deltaManager.clientDetails;
-    }
-    /**
-     * Get the code details that are currently specified for the container.
-     * @returns The current code details if any are specified, undefined if none are specified.
-     */
-    getSpecifiedCodeDetails() {
-        return this.getCodeDetailsFromQuorum();
-    }
-    /**
-     * Get the code details that were used to load the container.
-     * @returns The code details that were used to load the container if it is loaded, undefined if it is not yet
-     * loaded.
-     */
-    getLoadedCodeDetails() {
-        var _a;
-        return (_a = this._context) === null || _a === void 0 ? void 0 : _a.codeDetails;
-    }
-    /**
-     * Retrieves the audience associated with the document
-     */
-    get audience() {
-        return this._audience;
-    }
-    /**
-     * Returns true if container is dirty.
-     * Which means data loss if container is closed at that same moment
-     * Most likely that happens when there is no network connection to ordering service
-     */
-    get isDirty() {
-        return this._dirtyContainer;
-    }
-    get serviceFactory() { return this.loader.services.documentServiceFactory; }
-    get urlResolver() { return this.loader.services.urlResolver; }
-    get scope() { return this.loader.services.scope; }
-    get codeLoader() { return this.loader.services.codeLoader; }
-    /**
-     * Retrieves the quorum associated with the document
-     */
-    getQuorum() {
-        return this.protocolHandler.quorum;
-    }
-    close(error) {
-        // 1. Ensure that close sequence is exactly the same no matter if it's initiated by host or by DeltaManager
-        // 2. We need to ensure that we deliver disconnect event to runtime properly. See connectionStateChanged
-        //    handler. We only deliver events if container fully loaded. Transitioning from "loading" ->
-        //    "closing" will lose that info (can also solve by tracking extra state).
-        this._deltaManager.close(error);
-        assert(this.connectionState === ConnectionState.Disconnected, 0x0cf /* "disconnect event was not raised!" */);
-        assert(this._lifecycleState === "closed", 0x314 /* Container properly closed */);
-    }
-    closeCore(error) {
-        var _a, _b, _c, _d;
-        assert(!this.closed, 0x315 /* re-entrancy */);
-        try {
-            // Ensure that we raise all key events even if one of these throws
-            try {
-                // Raise event first, to ensure we capture _lifecycleState before transition.
-                // This gives us a chance to know what errors happened on open vs. on fully loaded container.
-                this.mc.logger.sendTelemetryEvent({
-                    eventName: "ContainerClose",
-                    category: error === undefined ? "generic" : "error",
-                }, error);
-                this._lifecycleState = "closing";
-                (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.close();
-                this.connectionStateHandler.dispose();
-                (_b = this._context) === null || _b === void 0 ? void 0 : _b.dispose(error !== undefined ? new Error(error.message) : undefined);
-                (_c = this._storageService) === null || _c === void 0 ? void 0 : _c.dispose();
-                // Notify storage about critical errors. They may be due to disconnect between client & server knowledge
-                // about file, like file being overwritten in storage, but client having stale local cache.
-                // Driver need to ensure all caches are cleared on critical errors
-                (_d = this.service) === null || _d === void 0 ? void 0 : _d.dispose(error);
-            }
-            catch (exception) {
-                this.mc.logger.sendErrorEvent({ eventName: "ContainerCloseException" }, exception);
-            }
-            this.emit("closed", error);
-            this.removeAllListeners();
-            if (this.visibilityEventHandler !== undefined) {
-                document.removeEventListener("visibilitychange", this.visibilityEventHandler);
-            }
-        }
-        finally {
-            this._lifecycleState = "closed";
-        }
-    }
-    closeAndGetPendingLocalState() {
-        // runtime matches pending ops to successful ones by clientId and client seq num, so we need to close the
-        // container at the same time we get pending state, otherwise this container could reconnect and resubmit with
-        // a new clientId and a future container using stale pending state without the new clientId would resubmit them
-        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._protocolHandler, 0x2e3 /* "Must have a valid protocol handler instance" */);
-        assert(this._protocolHandler.attributes.term !== undefined, 0x30b /* Must have a valid protocol handler instance */);
-        const pendingState = {
-            pendingRuntimeState: this.context.getPendingLocalState(),
-            url: this.resolvedUrl.url,
-            protocol: this.protocolHandler.getProtocolState(),
-            term: this._protocolHandler.attributes.term,
-            clientId: this.clientId,
-        };
-        this.close();
-        return JSON.stringify(pendingState);
-    }
-    get attachState() {
-        return this._attachState;
-    }
-    serialize() {
-        assert(this.attachState === AttachState.Detached, 0x0d3 /* "Should only be called in detached container" */);
-        const appSummary = this.context.createSummary();
-        const protocolSummary = this.captureProtocolSummary();
-        const combinedSummary = combineAppAndProtocolSummary(appSummary, protocolSummary);
-        if (this.loader.services.detachedBlobStorage && this.loader.services.detachedBlobStorage.size > 0) {
-            combinedSummary.tree[".hasAttachmentBlobs"] = { type: SummaryType.Blob, content: "true" };
-        }
-        return JSON.stringify(combinedSummary);
-    }
-    async attach(request) {
-        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.loader.services.detachedBlobStorage !== undefined
-                && this.loader.services.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.context.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.context.notifyAttaching(getSnapshotTreeFromSerializedContainer(summary));
-                }
-                // Actually go and create the resolved document
-                const createNewResolvedUrl = await this.urlResolver.resolve(request);
-                ensureFluidResolvedUrl(createNewResolvedUrl);
-                if (this.service === undefined) {
-                    assert(this.client.details.type !== summarizerClientType, 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.closeSignal,
-                    });
-                }
-                const resolvedUrl = this.service.resolvedUrl;
-                ensureFluidResolvedUrl(resolvedUrl);
-                this._resolvedUrl = resolvedUrl;
-                await this.connectStorageService();
-                if (hasAttachmentBlobs) {
-                    // upload blobs to storage
-                    assert(!!this.loader.services.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.loader.services.detachedBlobStorage.size) {
-                        const newIds = this.loader.services.detachedBlobStorage.getBlobIds().filter((id) => !redirectTable.has(id));
-                        for (const id of newIds) {
-                            const blob = await this.loader.services.detachedBlobStorage.readBlob(id);
-                            const response = await this.storageService.createBlob(blob);
-                            redirectTable.set(id, response.id);
-                        }
-                    }
-                    // take summary and upload
-                    const appSummary = this.context.createSummary(redirectTable);
-                    const protocolSummary = this.captureProtocolSummary();
-                    summary = combineAppAndProtocolSummary(appSummary, protocolSummary);
-                    this._attachState = AttachState.Attaching;
-                    this.context.notifyAttaching(getSnapshotTreeFromSerializedContainer(summary));
-                    await this.storageService.uploadSummaryWithContext(summary, {
-                        referenceSequenceNumber: 0,
-                        ackHandle: undefined,
-                        proposalHandle: undefined,
-                    });
-                }
-                this._attachState = AttachState.Attached;
-                this.emit("attached");
-                // Propagate current connection state through the system.
-                this.propagateConnectionState();
-                if (!this.closed) {
-                    this.resumeInternal({ fetchOpsFromStorage: false, reason: "createDetached" });
-                }
-            }
-            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);
-                const resolvedUrl = this.resolvedUrl;
-                if (isFluidResolvedUrl(resolvedUrl)) {
-                    newError.addTelemetryProperties({ resolvedUrl: resolvedUrl.url });
-                }
-                this.close(newError);
-                throw newError;
-            }
-        }, { start: true, end: true, cancel: "generic" });
-    }
-    async request(path) {
-        return PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Request" }, async () => this.context.request(path), { end: true, cancel: "error" });
-    }
-    setAutoReconnectInternal(mode) {
-        const currentMode = this._deltaManager.connectionManager.reconnectMode;
-        if (currentMode === mode) {
-            return;
-        }
-        const now = performance.now();
-        const duration = now - this.setAutoReconnectTime;
-        this.setAutoReconnectTime = now;
-        this.mc.logger.sendTelemetryEvent({
-            eventName: mode === ReconnectMode.Enabled ? "AutoReconnectEnabled" : "AutoReconnectDisabled",
-            connectionMode: this.connectionMode,
-            connectionState: ConnectionState[this.connectionState],
-            duration,
-        });
-        this._deltaManager.connectionManager.setAutoReconnect(mode);
-    }
-    connect() {
-        if (this.closed) {
-            throw new UsageError(`The Container is closed and cannot be connected`);
-        }
-        else if (this._attachState !== AttachState.Attached) {
-            throw new UsageError(`The Container is not attached and cannot be connected`);
-        }
-        else if (!this.connected) {
-            // Note: no need to fetch ops as we do it preemptively as part of DeltaManager.attachOpHandler().
-            // If there is gap, we will learn about it once connected, but the gap should be small (if any),
-            // assuming that connect() is called quickly after initial container boot.
-            this.connectInternal({ reason: "DocumentConnect", fetchOpsFromStorage: false });
-        }
-    }
-    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" */);
-        // Resume processing ops and connect to delta stream
-        this.resumeInternal(args);
-        // Set Auto Reconnect Mode
-        const mode = ReconnectMode.Enabled;
-        this.setAutoReconnectInternal(mode);
-    }
-    disconnect() {
-        if (this.closed) {
-            throw new UsageError(`The Container is closed and cannot be disconnected`);
-        }
-        else {
-            this.disconnectInternal();
-        }
-    }
-    disconnectInternal() {
-        assert(!this.closed, 0x2c7 /* "Attempting to disconnect() a closed Container" */);
-        // Set Auto Reconnect Mode
-        const mode = ReconnectMode.Disabled;
-        this.setAutoReconnectInternal(mode);
-    }
-    resumeInternal(args) {
-        assert(!this.closed, 0x0d9 /* "Attempting to connect() a closed DeltaManager" */);
-        // Resume processing ops
-        if (this.inboundQueuePausedFromInit) {
-            this.inboundQueuePausedFromInit = false;
-            this._deltaManager.inbound.resume();
-            this._deltaManager.inboundSignal.resume();
-        }
-        // Ensure connection to web socket
-        this.connectToDeltaStream(args);
-    }
-    async getAbsoluteUrl(relativeUrl) {
-        var _a;
-        if (this.resolvedUrl === undefined) {
-            return undefined;
-        }
-        return this.urlResolver.getAbsoluteUrl(this.resolvedUrl, relativeUrl, getPackageName((_a = this._context) === null || _a === void 0 ? void 0 : _a.codeDetails));
-    }
-    async proposeCodeDetails(codeDetails) {
-        if (!isFluidCodeDetails(codeDetails)) {
-            throw new Error("Provided codeDetails are not IFluidCodeDetails");
-        }
-        if (this.codeLoader.IFluidCodeDetailsComparer) {
-            const comparison = await this.codeLoader.IFluidCodeDetailsComparer.compare(codeDetails, this.getCodeDetailsFromQuorum());
-            if (comparison !== undefined && comparison <= 0) {
-                throw new Error("Proposed code details should be greater than the current");
-            }
-        }
-        return this.protocolHandler.quorum.propose("code", codeDetails)
-            .then(() => true)
-            .catch(() => false);
-    }
-    async processCodeProposal() {
-        const codeDetails = this.getCodeDetailsFromQuorum();
-        await Promise.all([
-            this.deltaManager.inbound.pause(),
-            this.deltaManager.inboundSignal.pause()
-        ]);
-        if ((await this.context.satisfies(codeDetails) === true)) {
-            this.deltaManager.inbound.resume();
-            this.deltaManager.inboundSignal.resume();
-            return;
-        }
-        // pre-0.58 error message: existingContextDoesNotSatisfyIncomingProposal
-        this.close(new GenericError("Existing context does not satisfy incoming proposal"));
-    }
-    async getVersion(version) {
-        const versions = await this.storageService.getVersions(version, 1);
-        return versions[0];
-    }
-    recordConnectStartTime() {
-        if (this.connectionTransitionTimes[ConnectionState.Disconnected] === undefined) {
-            this.connectionTransitionTimes[ConnectionState.Disconnected] = performance.now();
-        }
-    }
-    connectToDeltaStream(args) {
-        this.recordConnectStartTime();
-        // All agents need "write" access, including summarizer.
-        if (!this._canReconnect || !this.client.details.capabilities.interactive) {
-            args.mode = "write";
-        }
-        this._deltaManager.connect(args);
-    }
-    /**
-     * Load container.
-     *
-     * @param specifiedVersion - one of the following
-     *   - undefined - fetch latest snapshot
-     *   - otherwise, version sha to load snapshot
-     */
-    async load(specifiedVersion, loadMode, pendingLocalState) {
-        if (this._resolvedUrl === undefined) {
-            throw new Error("Attempting to load without a resolved url");
-        }
-        this.service = await this.serviceFactory.createDocumentService(this._resolvedUrl, this.subLogger, this.client.details.type === summarizerClientType);
-        // Ideally we always connect as "read" by default.
-        // Currently that works with SPO & r11s, because we get "write" connection when connecting to non-existing file.
-        // We should not rely on it by (one of them will address the issue, but we need to address both)
-        // 1) switching create new flow to one where we create file by posting snapshot
-        // 2) Fixing quorum workflows (have retry logic)
-        // That all said, "read" does not work with memorylicious workflows (that opens two simultaneous
-        // connections to same file) in two ways:
-        // A) creation flow breaks (as one of the clients "sees" file as existing, and hits #2 above)
-        // B) Once file is created, transition from view-only connection to write does not work - some bugs to be fixed.
-        const connectionArgs = { reason: "DocumentOpen", mode: "write", fetchOpsFromStorage: false };
-        // Start websocket connection as soon as possible. Note that there is no op handler attached yet, but the
-        // DeltaManager is resilient to this and will wait to start processing ops until after it is attached.
-        if (loadMode.deltaConnection === undefined) {
-            this.connectToDeltaStream(connectionArgs);
-        }
-        if (!pendingLocalState) {
-            await this.connectStorageService();
-        }
-        else {
-            // if we have pendingLocalState we can load without storage; don't wait for connection
-            this.connectStorageService().catch((error) => this.close(error));
-        }
-        this._attachState = AttachState.Attached;
-        // Fetch specified snapshot.
-        const { snapshot, versionId } = pendingLocalState === undefined
-            ? await this.fetchSnapshotTree(specifiedVersion)
-            : { snapshot: undefined, versionId: undefined };
-        assert(snapshot !== undefined || pendingLocalState !== undefined, 0x237 /* "Snapshot should exist" */);
-        const attributes = pendingLocalState === undefined
-            ? await this.getDocumentAttributes(this.storageService, snapshot)
-            : {
-                sequenceNumber: pendingLocalState.protocol.sequenceNumber,
-                minimumSequenceNumber: pendingLocalState.protocol.minimumSequenceNumber,
-                term: pendingLocalState.term,
-            };
-        let opsBeforeReturnP;
-        // Attach op handlers to finish initialization and be able to start processing ops
-        // Kick off any ops fetching if required.
-        switch (loadMode.opsBeforeReturn) {
-            case undefined:
-                // Start prefetch, but not set opsBeforeReturnP - boot is not blocked by it!
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                this.attachDeltaManagerOpHandler(attributes, loadMode.deltaConnection !== "none" ? "all" : "none");
-                break;
-            case "cached":
-                opsBeforeReturnP = this.attachDeltaManagerOpHandler(attributes, "cached");
-                break;
-            case "all":
-                opsBeforeReturnP = this.attachDeltaManagerOpHandler(attributes, "all");
-                break;
-            default:
-                unreachableCase(loadMode.opsBeforeReturn);
-        }
-        // ...load in the existing quorum
-        // Initialize the protocol handler
-        this._protocolHandler = pendingLocalState === undefined
-            ? await this.initializeProtocolStateFromSnapshot(attributes, this.storageService, snapshot)
-            : await this.initializeProtocolState(attributes, pendingLocalState.protocol.members, pendingLocalState.protocol.proposals, pendingLocalState.protocol.values);
-        const codeDetails = this.getCodeDetailsFromQuorum();
-        await this.instantiateContext(true, // existing
-        codeDetails, snapshot, pendingLocalState === null || pendingLocalState === void 0 ? void 0 : pendingLocalState.pendingRuntimeState);
-        // We might have hit some failure that did not manifest itself in exception in this flow,
-        // do not start op processing in such case - static version of Container.load() will handle it correctly.
-        if (!this.closed) {
-            if (opsBeforeReturnP !== undefined) {
-                this._deltaManager.inbound.resume();
-                await ReportIfTooLong(this.mc.logger, "WaitOps", async () => { await opsBeforeReturnP; return {}; });
-                await ReportIfTooLong(this.mc.logger, "WaitOpProcessing", async () => this._deltaManager.inbound.waitTillProcessingDone());
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                this._deltaManager.inbound.pause();
-            }
-            switch (loadMode.deltaConnection) {
-                case undefined:
-                case "delayed":
-                    assert(this.inboundQueuePausedFromInit, 0x346 /* inboundQueuePausedFromInit should be true */);
-                    this.inboundQueuePausedFromInit = false;
-                    this._deltaManager.inbound.resume();
-                    this._deltaManager.inboundSignal.resume();
-                    break;
-                case "none":
-                    break;
-                default:
-                    unreachableCase(loadMode.deltaConnection);
-            }
-        }
-        // Safety net: static version of Container.load() should have learned about it through "closed" handler.
-        // But if that did not happen for some reason, fail load for sure.
-        // Otherwise we can get into situations where container is closed and does not try to connect to ordering
-        // service, but caller does not know that (callers do expect container to be not closed on successful path
-        // and listen only on "closed" event)
-        if (this.closed) {
-            throw new Error("Container was closed while load()");
-        }
-        // Internal context is fully loaded at this point
-        this.setLoaded();
-        return {
-            sequenceNumber: attributes.sequenceNumber,
-            version: versionId,
-            dmLastProcessedSeqNumber: this._deltaManager.lastSequenceNumber,
-            dmLastKnownSeqNumber: this._deltaManager.lastKnownSeqNumber,
-        };
-    }
-    async createDetached(source) {
-        const attributes = {
-            sequenceNumber: detachedContainerRefSeqNumber,
-            term: 1,
-            minimumSequenceNumber: 0,
-        };
-        await this.attachDeltaManagerOpHandler(attributes);
-        // Need to just seed the source data in the code quorum. Quorum itself is empty
-        const qValues = initQuorumValuesFromCodeDetails(source);
-        this._protocolHandler = await this.initializeProtocolState(attributes, [], // members
-        [], // proposals
-        qValues);
-        // The load context - given we seeded the quorum - will be great
-        await this.instantiateContextDetached(false);
-        this.setLoaded();
-    }
-    async rehydrateDetachedFromSnapshot(detachedContainerSnapshot) {
-        if (detachedContainerSnapshot.tree[".hasAttachmentBlobs"] !== undefined) {
-            assert(!!this.loader.services.detachedBlobStorage && this.loader.services.detachedBlobStorage.size > 0, 0x250 /* "serialized container with attachment blobs must be rehydrated with detached blob storage" */);
-            delete detachedContainerSnapshot.tree[".hasAttachmentBlobs"];
-        }
-        const snapshotTree = getSnapshotTreeFromSerializedContainer(detachedContainerSnapshot);
-        this._storage.loadSnapshotForRehydratingContainer(snapshotTree);
-        const attributes = await this.getDocumentAttributes(this._storage, snapshotTree);
-        await this.attachDeltaManagerOpHandler(attributes);
-        // Initialize the protocol handler
-        const baseTree = getProtocolSnapshotTree(snapshotTree);
-        const qValues = await readAndParse(this._storage, baseTree.blobs.quorumValues);
-        const codeDetails = getCodeDetailsFromQuorumValues(qValues);
-        this._protocolHandler =
-            await this.initializeProtocolState(attributes, [], // members
-            [], // proposals
-            codeDetails !== undefined ? initQuorumValuesFromCodeDetails(codeDetails) : []);
-        await this.instantiateContextDetached(true, // existing
-        snapshotTree);
-        this.setLoaded();
-    }
-    async connectStorageService() {
-        var _a, _b;
-        if (this._storageService !== undefined) {
-            return;
-        }
-        assert(this.service !== undefined, 0x1ef /* "services must be defined" */);
-        const storageService = await this.service.connectToStorage();
-        this._storageService =
-            new RetriableDocumentStorageService(storageService, this.mc.logger);
-        if (this.options.summarizeProtocolTree === true) {
-            this.mc.logger.sendTelemetryEvent({ eventName: "summarizeProtocolTreeEnabled" });
-            this._storageService =
-                new ProtocolTreeStorageService(this._storageService, () => this.captureProtocolSummary());
-        }
-        // ensure we did not lose that policy in the process of wrapping
-        assert(((_a = storageService.policies) === null || _a === void 0 ? void 0 : _a.minBlobSize) === ((_b = this.storageService.policies) === null || _b === void 0 ? void 0 : _b.minBlobSize), 0x0e0 /* "lost minBlobSize policy" */);
-    }
-    async getDocumentAttributes(storage, tree) {
-        if (tree === undefined) {
-            return {
-                minimumSequenceNumber: 0,
-                sequenceNumber: 0,
-                term: 1,
-            };
-        }
-        // Backward compatibility: old docs would have ".attributes" instead of "attributes"
-        const attributesHash = ".protocol" in tree.trees
-            ? tree.trees[".protocol"].blobs.attributes
-            : tree.blobs[".attributes"];
-        const attributes = await readAndParse(storage, attributesHash);
-        // Backward compatibility for older summaries with no term
-        if (attributes.term === undefined) {
-            attributes.term = 1;
-        }
-        return attributes;
-    }
-    async initializeProtocolStateFromSnapshot(attributes, storage, snapshot) {
-        let members = [];
-        let proposals = [];
-        let values = [];
-        if (snapshot !== undefined) {
-            const baseTree = getProtocolSnapshotTree(snapshot);
-            [members, proposals, values] = await Promise.all([
-                readAndParse(storage, baseTree.blobs.quorumMembers),
-                readAndParse(storage, baseTree.blobs.quorumProposals),
-                readAndParse(storage, baseTree.blobs.quorumValues),
-            ]);
-        }
-        const protocolHandler = await this.initializeProtocolState(attributes, members, proposals, values);
-        return protocolHandler;
-    }
-    async initializeProtocolState(attributes, members, proposals, values) {
-        const protocol = new ProtocolOpHandlerWithClientValidation(attributes.minimumSequenceNumber, attributes.sequenceNumber, attributes.term, members, proposals, values, (key, value) => this.submitMessage(MessageType.Propose, { key, value }));
-        const protocolLogger = ChildLogger.create(this.subLogger, "ProtocolHandler");
-        protocol.quorum.on("error", (error) => {
-            protocolLogger.sendErrorEvent(error);
-        });
-        // Track membership changes and update connection state accordingly
-        this.connectionStateHandler.initProtocol(protocol);
-        protocol.quorum.on("addProposal", (proposal) => {
-            if (proposal.key === "code" || proposal.key === "code2") {
-                this.emit("codeDetailsProposed", proposal.value, proposal);
-            }
-        });
-        protocol.quorum.on("approveProposal", (sequenceNumber, key, value) => {
-            if (key === "code" || key === "code2") {
-                if (!isFluidCodeDetails(value)) {
-                    this.mc.logger.sendErrorEvent({
-                        eventName: "CodeProposalNotIFluidCodeDetails",
-                    });
-                }
-                this.processCodeProposal().catch((error) => {
-                    this.close(normalizeError(error));
-                    throw error;
-                });
-            }
-        });
-        return protocol;
-    }
-    captureProtocolSummary() {
-        const quorumSnapshot = this.protocolHandler.snapshot();
-        const summary = {
-            tree: {
-                attributes: {
-                    content: JSON.stringify(this.protocolHandler.attributes),
-                    type: SummaryType.Blob,
-                },
-                quorumMembers: {
-                    content: JSON.stringify(quorumSnapshot.members),
-                    type: SummaryType.Blob,
-                },
-                quorumProposals: {
-                    content: JSON.stringify(quorumSnapshot.proposals),
-                    type: SummaryType.Blob,
-                },
-                quorumValues: {
-                    content: JSON.stringify(quorumSnapshot.values),
-                    type: SummaryType.Blob,
-                },
-            },
-            type: SummaryType.Tree,
-        };
-        return summary;
-    }
-    getCodeDetailsFromQuorum() {
-        const quorum = this.protocolHandler.quorum;
-        const pkg = getCodeProposal(quorum);
-        return pkg;
-    }
-    get client() {
-        var _a;
-        const client = ((_a = this.options) === null || _a === void 0 ? void 0 : _a.client) !== undefined
-            ? this.options.client
-            : {
-                details: {
-                    capabilities: { interactive: true },
-                },
-                mode: "read",
-                permission: [],
-                scopes: [],
-                user: { id: "" },
-            };
-        if (this.clientDetailsOverride !== undefined) {
-            merge(client.details, this.clientDetailsOverride);
-        }
-        client.details.environment = [client.details.environment, ` loaderVersion:${pkgVersion}`].join(";");
-        return client;
-    }
-    /**
-     * Returns true if connection is active, i.e. it's "write" connection and
-     * container runtime was notified about this connection (i.e. we are up-to-date and could send ops).
-     * This happens after client received its own joinOp and thus is in the quorum.
-     * If it's not true, runtime is not in position to send ops.
-     */
-    activeConnection() {
-        return this.connectionState === ConnectionState.Connected &&
-            this.connectionMode === "write";
-    }
-    createDeltaManager() {
-        const serviceProvider = () => this.service;
-        const deltaManager = new DeltaManager(serviceProvider, ChildLogger.create(this.subLogger, "DeltaManager"), () => this.activeConnection(), (props) => new ConnectionManager(serviceProvider, this.client, this._canReconnect, ChildLogger.create(this.subLogger, "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();
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        deltaManager.inboundSignal.pause();
-        deltaManager.on("connect", (details, opsBehind) => {
-            var _a;
-            // Back-compat for new client and old server.
-            this._audience.clear();
-            for (const priorClient of (_a = details.initialClients) !== null && _a !== void 0 ? _a : []) {
-                this._audience.addMember(priorClient.clientId, priorClient.client);
-            }
-            this.connectionStateHandler.receivedConnectEvent(this.connectionMode, details);
-        });
-        deltaManager.on("disconnect", (reason) => {
-            var _a;
-            (_a = this.collabWindowTracker) === null || _a === void 0 ? void 0 : _a.stopSequenceNumberUpdate();
-            this.connectionStateHandler.receivedDisconnectEvent(reason);
-        });
-        deltaManager.on("throttled", (warning) => {
-            const warn = warning;
-            // Some "warning" events come from outside the container and are logged
-            // elsewhere (e.g. summarizing container). We shouldn't log these here.
-            if (warn.logged !== true) {
-                this.logContainerError(warn);
-            }
-            this.emit("warning", warn);
-        });
-        deltaManager.on("readonly", (readonly) => {
-            this.emit("readonly", readonly);
-        });
-        deltaManager.on("closed", (error) => {
-            this.closeCore(error);
-        });
-        return deltaManager;
-    }
-    async attachDeltaManagerOpHandler(attributes, prefetchType) {
-        var _a;
-        return this._deltaManager.attachOpHandler(attributes.minimumSequenceNumber, attributes.sequenceNumber, (_a = attributes.term) !== null && _a !== void 0 ? _a : 1, {
-            process: (message) => this.processRemoteMessage(message),
-            processSignal: (message) => {
-                this.processSignal(message);
-            },
-        }, prefetchType);
-    }
-    logConnectionStateChangeTelemetry(value, oldState, reason) {
-        var _a;
-        // Log actual event
-        const time = performance.now();
-        this.connectionTransitionTimes[value] = time;
-        const duration = time - this.connectionTransitionTimes[oldState];
-        let durationFromDisconnected;
-        let connectionInitiationReason;
-        let autoReconnect;
-        let checkpointSequenceNumber;
-        let opsBehind;
-        if (value === ConnectionState.Disconnected) {
-            autoReconnect = this._deltaManager.connectionManager.reconnectMode;
-        }
-        else {
-            if (value === ConnectionState.Connected) {
-                durationFromDisconnected = time - this.connectionTransitionTimes[ConnectionState.Disconnected];
-                durationFromDisconnected = TelemetryLogger.formatTick(durationFromDisconnected);
-            }
-            else {
-                // This info is of most interest on establishing connection only.
-                checkpointSequenceNumber = this.deltaManager.lastKnownSeqNumber;
-                if (this.deltaManager.hasCheckpointSequenceNumber) {
-                    opsBehind = checkpointSequenceNumber - this.deltaManager.lastSequenceNumber;
-                }
-            }
-            if (this.firstConnection) {
-                connectionInitiationReason = "InitialConnect";
-            }
-            else {
-                connectionInitiationReason = "AutoReconnect";
-            }
-        }
-        this.mc.logger.sendPerformanceEvent(Object.assign({ eventName: `ConnectionStateChange_${ConnectionState[value]}`, from: ConnectionState[oldState], duration,
-            durationFromDisconnected,
-            reason,
-            connectionInitiationReason, pendingClientId: this.connectionStateHandler.pendingClientId, clientId: this.clientId, autoReconnect,
-            opsBehind, online: OnlineStatus[isOnline()], lastVisible: this.lastVisible !== undefined ? performance.now() - this.lastVisible : undefined, checkpointSequenceNumber, quorumSize: (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.quorum.getMembers().size }, this._deltaManager.connectionProps));
-        if (value === ConnectionState.Connected) {
-            this.firstConnection = false;
-        }
-    }
-    propagateConnectionState() {
-        var _a;
-        const logOpsOnReconnect = this.connectionState === ConnectionState.Connected &&
-            !this.firstConnection &&
-            this.connectionMode === "write";
-        if (logOpsOnReconnect) {
-            this.messageCountAfterDisconnection = 0;
-        }
-        const state = this.connectionState === ConnectionState.Connected;
-        // Both protocol and context should not be undefined if we got so far.
-        if (((_a = this._context) === null || _a === void 0 ? void 0 : _a.disposed) === false) {
-            this.context.setConnectionState(state, this.clientId);
-        }
-        this.protocolHandler.setConnectionState(state, this.clientId);
-        raiseConnectedEvent(this.mc.logger, this, state, this.clientId);
-        if (logOpsOnReconnect) {
-            this.mc.logger.sendTelemetryEvent({ eventName: "OpsSentOnReconnect", count: this.messageCountAfterDisconnection });
-        }
-    }
-    submitContainerMessage(type, contents, batch, metadata) {
-        const outboundMessageType = type;
-        switch (outboundMessageType) {
-            case MessageType.Operation:
-            case MessageType.RemoteHelp:
-                break;
-            case MessageType.Summarize: {
-                // github #6451: this is only needed for staging so the server
-                // know when the protocol tree is included
-                // this can be removed once all clients send
-                // protocol tree by default
-                const summary = contents;
-                if (summary.details === undefined) {
-                    summary.details = {};
-                }
-                summary.details.includesProtocolTree =
-                    this.options.summarizeProtocolTree === true;
-                break;
-            }
-            default:
-                this.close(new GenericError("invalidContainerSubmitOpType", undefined /* error */, { messageType: type }));
-                return -1;
-        }
-        return this.submitMessage(type, contents, batch, metadata);
-    }
-    submitMessage(type, contents, batch, metadata) {
-        var _a;
-        if (this.connectionState !== ConnectionState.Connected) {
-            this.mc.logger.sendErrorEvent({ eventName: "SubmitMessageWithNoConnection", type });
-            return -1;
-        }
-        this.messageCountAfterDisconnection += 1;
-        (_a = this.collabWindowTracker) === null || _a === void 0 ? void 0 : _a.stopSequenceNumberUpdate();
-        return this._deltaManager.submit(type, contents, batch, metadata);
-    }
-    processRemoteMessage(message) {
-        const local = this.clientId === message.clientId;
-        // Allow the protocol handler to process the message
-        let result = { immediateNoOp: false };
-        try {
-            result = this.protocolHandler.processMessage(message, local);
-        }
-        catch (error) {
-            this.close(wrapError(error, (errorMessage) => new DataCorruptionError(errorMessage, extractSafePropertiesFromMessage(message))));
-        }
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        if (isUnpackedRuntimeMessage(message) && !isRuntimeMessage(message)) {
-            this.mc.logger.sendTelemetryEvent({ eventName: "UnpackedRuntimeMessage", type: message.type });
-        }
-        // Forward non system messages to the loaded runtime for processing
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        if (isRuntimeMessage(message) || isUnpackedRuntimeMessage(message)) {
-            this.context.process(message, local, undefined);
-        }
-        // Inactive (not in quorum or not writers) clients don't take part in the minimum sequence number calculation.
-        if (this.activeConnection()) {
-            if (this.collabWindowTracker === undefined) {
-                // Note that config from first connection will be used for this container's lifetime.
-                // That means that if relay service changes settings, such changes will impact only newly booted
-                // clients.
-                // All existing will continue to use settings they got earlier.
-                assert(this.serviceConfiguration !== undefined, 0x2e4 /* "there should be service config for active connection" */);
-                this.collabWindowTracker = new CollabWindowTracker((type, contents) => {
-                    assert(this.activeConnection(), 0x241 /* "disconnect should result in stopSequenceNumberUpdate() call" */);
-                    this.submitMessage(type, contents);
-                }, this.serviceConfiguration.noopTimeFrequency, this.serviceConfiguration.noopCountFrequency);
-            }
-            this.collabWindowTracker.scheduleSequenceNumberUpdate(message, result.immediateNoOp === true);
-        }
-        this.emit("op", message);
-        return result;
-    }
-    submitSignal(message) {
-        this._deltaManager.submitSignal(JSON.stringify(message));
-    }
-    processSignal(message) {
-        // No clientId indicates a system signal message.
-        if (message.clientId === null) {
-            const innerContent = message.content;
-            if (innerContent.type === MessageType.ClientJoin) {
-                const newClient = innerContent.content;
-                this._audience.addMember(newClient.clientId, newClient.client);
-            }
-            else if (innerContent.type === MessageType.ClientLeave) {
-                const leftClientId = innerContent.content;
-                this._audience.removeMember(leftClientId);
-            }
-        }
-        else {
-            const local = this.clientId === message.clientId;
-            this.context.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) {
-        var _a;
-        const version = await this.getVersion(specifiedVersion !== null && specifiedVersion !== void 0 ? 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 = (_a = await this.storageService.getSnapshotTree(version)) !== null && _a !== void 0 ? _a : undefined;
-        if (snapshot === undefined && version !== undefined) {
-            this.mc.logger.sendErrorEvent({ eventName: "getSnapshotTreeFailed", id: version.id });
-        }
-        return { snapshot, versionId: version === null || version === void 0 ? void 0 : version.id };
-    }
-    async instantiateContextDetached(existing, snapshot) {
-        const codeDetails = this.getCodeDetailsFromQuorum();
-        if (codeDetails === undefined) {
-            throw new Error("pkg should be provided in create flow!!");
-        }
-        await this.instantiateContext(existing, codeDetails, snapshot);
-    }
-    async instantiateContext(existing, codeDetails, snapshot, pendingLocalState) {
-        var _a;
-        assert(((_a = this._context) === null || _a === void 0 ? void 0 : _a.disposed) !== false, 0x0dd /* "Existing context 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 loader = new RelativeLoader(this, this.loader);
-        this._context = await ContainerContext.createOrLoad(this, this.scope, this.codeLoader, codeDetails, snapshot, new DeltaManagerProxy(this._deltaManager), new QuorumProxy(this.protocolHandler.quorum), loader, (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (message) => this.submitSignal(message), (error) => this.close(error), Container.version, (dirty) => this.updateDirtyContainerState(dirty), existing, pendingLocalState);
-        this.emit("contextChanged", codeDetails);
-    }
-    updateDirtyContainerState(dirty) {
-        if (this._dirtyContainer === dirty) {
-            return;
-        }
-        this._dirtyContainer = dirty;
-        this.emit(dirty ? dirtyContainerEvent : savedContainerEvent);
-    }
-    logContainerError(warning) {
-        this.mc.logger.sendErrorEvent({ eventName: "ContainerWarning" }, warning);
-    }
-}
-Container.version = "^0.1.0";
-//# sourceMappingURL=container.js.map