@fluidframework/container-loader 2.0.0-internal.6.4.0 → 2.0.0-internal.7.0.1

package/lib/container.js

@@ -25,7 +25,7 @@ import { initQuorumValuesFromCodeDetails } from "./quorum";
 import { NoopHeuristic } from "./noopHeuristic";
 import { ConnectionManager } from "./connectionManager";
 import { ConnectionState } from "./connectionState";
-import { OnlyValidTermValue, ProtocolHandler, protocolHandlerShouldProcessSignal, } from "./protocol";
+import { ProtocolHandler, protocolHandlerShouldProcessSignal, } from "./protocol";
 const detachedContainerRefSeqNumber = 0;
 const dirtyContainerEvent = "dirty";
 const savedContainerEvent = "saved";
@@ -121,208 +121,6 @@ export async function ReportIfTooLong(logger, eventName, action) {
 }
 const summarizerClientType = "summarizer";
 export class Container extends EventEmitterWithErrorHandling {
-    /**
-     * @internal
-     */
-    constructor(createProps, loadProps) {
-        super((name, error) => {
-            this.mc.logger.sendErrorEvent({
-                eventName: "ContainerEventHandlerException",
-                name: typeof name === "string" ? name : undefined,
-            }, error);
-        });
-        /**
-         * Lifecycle state of the container, used mainly to prevent re-entrancy and telemetry
-         *
-         * States are allowed to progress to further states:
-         * "loading" - "loaded" - "closing" - "disposing" - "closed" - "disposed"
-         *
-         * For example, moving from "closed" to "disposing" is not allowed since it is an earlier state.
-         *
-         * loading: Container has been created, but is not yet in normal/loaded state
-         * loaded: Container is in normal/loaded state
-         * closing: Container has started closing process (for re-entrancy prevention)
-         * disposing: Container has started disposing process (for re-entrancy prevention)
-         * closed: Container has closed
-         * 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.clientsWhoShouldHaveLeft = new Set();
-        this.setAutoReconnectTime = performance.now();
-        this._lifecycleEvents = new TypedEventEmitter();
-        this._disposed = false;
-        this.getAbsoluteUrl = async (relativeUrl) => {
-            if (this.resolvedUrl === undefined) {
-                return undefined;
-            }
-            return this.urlResolver.getAbsoluteUrl(this.resolvedUrl, relativeUrl, getPackageName(this._loadedCodeDetails));
-        };
-        this.updateDirtyContainerState = (dirty) => {
-            if (this._dirtyContainer === dirty) {
-                return;
-            }
-            this._dirtyContainer = dirty;
-            this.emit(dirty ? dirtyContainerEvent : savedContainerEvent);
-        };
-        const { canReconnect, clientDetailsOverride, urlResolver, documentServiceFactory, codeLoader, options, scope, subLogger, detachedBlobStorage, protocolHandlerBuilder, } = createProps;
-        this.connectionTransitionTimes[ConnectionState.Disconnected] = performance.now();
-        const pendingLocalState = loadProps?.pendingLocalState;
-        this._clientId = pendingLocalState?.clientId;
-        this._canReconnect = canReconnect ?? true;
-        this.clientDetailsOverride = clientDetailsOverride;
-        this.urlResolver = urlResolver;
-        this.serviceFactory = documentServiceFactory;
-        this.codeLoader = codeLoader;
-        // Warning: this is only a shallow clone. Mutation of any individual loader option will mutate it for
-        // all clients that were loaded from the same loader (including summarizer clients).
-        // Tracking alternative ways to handle this in AB#4129.
-        this.options = { ...options };
-        this.scope = scope;
-        this.detachedBlobStorage = detachedBlobStorage;
-        this.protocolHandlerBuilder =
-            protocolHandlerBuilder ??
-                ((attributes, quorumSnapshot, sendProposal) => new ProtocolHandler(attributes, quorumSnapshot, sendProposal, new Audience(), (clientId) => this.clientsWhoShouldHaveLeft.has(clientId)));
-        // Note that we capture the createProps here so we can replicate the creation call when we want to clone.
-        this.clone = async (_loadProps, createParamOverrides) => {
-            return Container.load(_loadProps, {
-                ...createProps,
-                ...createParamOverrides,
-            });
-        };
-        // 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 = createChildLogger({
-            logger: subLogger,
-            properties: {
-                all: {
-                    clientType,
-                    containerId: uuid(),
-                    docId: () => this.resolvedUrl?.id,
-                    containerAttachState: () => this._attachState,
-                    containerLifecycleState: () => this._lifecycleState,
-                    containerConnectionState: () => ConnectionState[this.connectionState],
-                    serializedContainer: pendingLocalState !== 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: () => this._deltaManager?.initialSequenceNumber,
-                    dmLastProcessedSeqNumber: () => this._deltaManager?.lastSequenceNumber,
-                    dmLastKnownSeqNumber: () => this._deltaManager?.lastKnownSeqNumber,
-                    containerLoadedFromVersionId: () => this._loadedFromVersion?.id,
-                    containerLoadedFromVersionDate: () => this._loadedFromVersion?.date,
-                    // message information to associate errors with the specific execution state
-                    // dmLastMsqSeqNumber: if present, same as dmLastProcessedSeqNumber
-                    dmLastMsqSeqNumber: () => this.deltaManager?.lastMessage?.sequenceNumber,
-                    dmLastMsqSeqTimestamp: () => this.deltaManager?.lastMessage?.timestamp,
-                    dmLastMsqSeqClientId: () => this.deltaManager?.lastMessage?.clientId === null
-                        ? "null"
-                        : this.deltaManager?.lastMessage?.clientId,
-                    dmLastMsgClientSeq: () => this.deltaManager?.lastMessage?.clientSequenceNumber,
-                    connectionStateDuration: () => performance.now() - this.connectionTransitionTimes[this.connectionState],
-                },
-            },
-        });
-        // Prefix all events in this file with container-loader
-        this.mc = createChildMonitoringContext({ logger: this.subLogger, namespace: "Container" });
-        this._deltaManager = this.createDeltaManager();
-        this.connectionStateHandler = createConnectionStateHandler({
-            logger: this.mc.logger,
-            connectionStateChanged: (value, oldState, reason) => {
-                if (value === ConnectionState.Connected) {
-                    this._clientId = this.connectionStateHandler.pendingClientId;
-                }
-                this.logConnectionStateChangeTelemetry(value, oldState, reason);
-                if (this._lifecycleState === "loaded") {
-                    this.propagateConnectionState(false /* initial transition */, value === ConnectionState.Disconnected
-                        ? reason
-                        : undefined /* disconnectedReason */);
-                }
-            },
-            shouldClientJoinWrite: () => this._deltaManager.connectionManager.shouldJoinWrite(),
-            maxClientLeaveWaitTime: options.maxClientLeaveWaitTime,
-            logConnectionIssue: (eventName, category, details) => {
-                const mode = this.connectionMode;
-                // We get here when socket does not receive any ops on "write" connection, including
-                // its own join op.
-                // Report issues only if we already loaded container - op processing is paused while container is loading,
-                // so we always time-out processing of join op in cases where fetching snapshot takes a minute.
-                // It's not a problem with op processing itself - such issues should be tracked as part of boot perf monitoring instead.
-                this._deltaManager.logConnectionIssue({
-                    eventName,
-                    mode,
-                    category: this._lifecycleState === "loading" ? "generic" : category,
-                    duration: performance.now() -
-                        this.connectionTransitionTimes[ConnectionState.CatchingUp],
-                    ...(details === undefined ? {} : { details: JSON.stringify(details) }),
-                });
-                // If this is "write" connection, it took too long to receive join op. But in most cases that's due
-                // to very slow op fetches and we will eventually get there.
-                // For "read" connections, we get here due to self join signal not arriving on time. We will need to
-                // better understand when and why it may happen.
-                // For now, attempt to recover by reconnecting. In future, maybe we can query relay service for
-                // current state of audience.
-                // Other possible recovery path - move to connected state (i.e. ConnectionStateHandler.joinOpTimer
-                // to call this.applyForConnectedState("addMemberEvent") for "read" connections)
-                if (mode === "read") {
-                    const reason = { text: "NoJoinSignal" };
-                    this.disconnectInternal(reason);
-                    this.connectInternal({ reason, fetchOpsFromStorage: false });
-                }
-            },
-            clientShouldHaveLeft: (clientId) => {
-                this.clientsWhoShouldHaveLeft.add(clientId);
-            },
-        }, this.deltaManager, pendingLocalState?.clientId);
-        this.on(savedContainerEvent, () => {
-            this.connectionStateHandler.containerSaved();
-        });
-        // We expose our storage publicly, so it's possible others may call uploadSummaryWithContext() with a
-        // non-combined summary tree (in particular, ContainerRuntime.submitSummary).  We'll intercept those calls
-        // using this callback and fix them up.
-        const addProtocolSummaryIfMissing = (summaryTree) => isCombinedAppAndProtocolSummary(summaryTree) === true
-            ? summaryTree
-            : combineAppAndProtocolSummary(summaryTree, this.captureProtocolSummary());
-        // Whether the combined summary tree has been forced on by either the loader option or the monitoring context.
-        // Even if not forced on via this flag, combined summaries may still be enabled by service policy.
-        const forceEnableSummarizeProtocolTree = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2") ??
-            options.summarizeProtocolTree;
-        this.storageAdapter = new ContainerStorageAdapter(detachedBlobStorage, this.mc.logger, pendingLocalState?.snapshotBlobs, addProtocolSummaryIfMissing, forceEnableSummarizeProtocolTree);
-        const isDomAvailable = typeof document === "object" &&
-            document !== null &&
-            typeof document.addEventListener === "function" &&
-            document.addEventListener !== null;
-        // keep track of last time page was visible for telemetry (on interactive clients only)
-        if (isDomAvailable && interactive) {
-            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);
-        }
-    }
     /**
      * Load an existing container.
      * @internal
@@ -417,6 +215,10 @@ export class Container extends EventEmitterWithErrorHandling {
     get connectionMode() {
         return this._deltaManager.connectionManager.connectionMode;
     }
+    /**
+     * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+     */
+    // eslint-disable-next-line import/no-deprecated
     get IFluidRouter() {
         return this;
     }
@@ -532,6 +334,208 @@ export class Container extends EventEmitterWithErrorHandling {
             this._lifecycleEvents.once("disposed", disposedHandler);
         });
     }
+    /**
+     * @internal
+     */
+    constructor(createProps, loadProps) {
+        super((name, error) => {
+            this.mc.logger.sendErrorEvent({
+                eventName: "ContainerEventHandlerException",
+                name: typeof name === "string" ? name : undefined,
+            }, error);
+        });
+        /**
+         * Lifecycle state of the container, used mainly to prevent re-entrancy and telemetry
+         *
+         * States are allowed to progress to further states:
+         * "loading" - "loaded" - "closing" - "disposing" - "closed" - "disposed"
+         *
+         * For example, moving from "closed" to "disposing" is not allowed since it is an earlier state.
+         *
+         * loading: Container has been created, but is not yet in normal/loaded state
+         * loaded: Container is in normal/loaded state
+         * closing: Container has started closing process (for re-entrancy prevention)
+         * disposing: Container has started disposing process (for re-entrancy prevention)
+         * closed: Container has closed
+         * 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.clientsWhoShouldHaveLeft = new Set();
+        this.setAutoReconnectTime = performance.now();
+        this._lifecycleEvents = new TypedEventEmitter();
+        this._disposed = false;
+        this.getAbsoluteUrl = async (relativeUrl) => {
+            if (this.resolvedUrl === undefined) {
+                return undefined;
+            }
+            return this.urlResolver.getAbsoluteUrl(this.resolvedUrl, relativeUrl, getPackageName(this._loadedCodeDetails));
+        };
+        this.updateDirtyContainerState = (dirty) => {
+            if (this._dirtyContainer === dirty) {
+                return;
+            }
+            this._dirtyContainer = dirty;
+            this.emit(dirty ? dirtyContainerEvent : savedContainerEvent);
+        };
+        const { canReconnect, clientDetailsOverride, urlResolver, documentServiceFactory, codeLoader, options, scope, subLogger, detachedBlobStorage, protocolHandlerBuilder, } = createProps;
+        this.connectionTransitionTimes[ConnectionState.Disconnected] = performance.now();
+        const pendingLocalState = loadProps?.pendingLocalState;
+        this._clientId = pendingLocalState?.clientId;
+        this._canReconnect = canReconnect ?? true;
+        this.clientDetailsOverride = clientDetailsOverride;
+        this.urlResolver = urlResolver;
+        this.serviceFactory = documentServiceFactory;
+        this.codeLoader = codeLoader;
+        // Warning: this is only a shallow clone. Mutation of any individual loader option will mutate it for
+        // all clients that were loaded from the same loader (including summarizer clients).
+        // Tracking alternative ways to handle this in AB#4129.
+        this.options = { ...options };
+        this.scope = scope;
+        this.detachedBlobStorage = detachedBlobStorage;
+        this.protocolHandlerBuilder =
+            protocolHandlerBuilder ??
+                ((attributes, quorumSnapshot, sendProposal) => new ProtocolHandler(attributes, quorumSnapshot, sendProposal, new Audience(), (clientId) => this.clientsWhoShouldHaveLeft.has(clientId)));
+        // Note that we capture the createProps here so we can replicate the creation call when we want to clone.
+        this.clone = async (_loadProps, createParamOverrides) => {
+            return Container.load(_loadProps, {
+                ...createProps,
+                ...createParamOverrides,
+            });
+        };
+        // 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 = createChildLogger({
+            logger: subLogger,
+            properties: {
+                all: {
+                    clientType,
+                    containerId: uuid(),
+                    docId: () => this.resolvedUrl?.id,
+                    containerAttachState: () => this._attachState,
+                    containerLifecycleState: () => this._lifecycleState,
+                    containerConnectionState: () => ConnectionState[this.connectionState],
+                    serializedContainer: pendingLocalState !== 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: () => this._deltaManager?.initialSequenceNumber,
+                    dmLastProcessedSeqNumber: () => this._deltaManager?.lastSequenceNumber,
+                    dmLastKnownSeqNumber: () => this._deltaManager?.lastKnownSeqNumber,
+                    containerLoadedFromVersionId: () => this._loadedFromVersion?.id,
+                    containerLoadedFromVersionDate: () => this._loadedFromVersion?.date,
+                    // message information to associate errors with the specific execution state
+                    // dmLastMsqSeqNumber: if present, same as dmLastProcessedSeqNumber
+                    dmLastMsqSeqNumber: () => this.deltaManager?.lastMessage?.sequenceNumber,
+                    dmLastMsqSeqTimestamp: () => this.deltaManager?.lastMessage?.timestamp,
+                    dmLastMsqSeqClientId: () => this.deltaManager?.lastMessage?.clientId === null
+                        ? "null"
+                        : this.deltaManager?.lastMessage?.clientId,
+                    dmLastMsgClientSeq: () => this.deltaManager?.lastMessage?.clientSequenceNumber,
+                    connectionStateDuration: () => performance.now() - this.connectionTransitionTimes[this.connectionState],
+                },
+            },
+        });
+        // Prefix all events in this file with container-loader
+        this.mc = createChildMonitoringContext({ logger: this.subLogger, namespace: "Container" });
+        this._deltaManager = this.createDeltaManager();
+        this.connectionStateHandler = createConnectionStateHandler({
+            logger: this.mc.logger,
+            connectionStateChanged: (value, oldState, reason) => {
+                if (value === ConnectionState.Connected) {
+                    this._clientId = this.connectionStateHandler.pendingClientId;
+                }
+                this.logConnectionStateChangeTelemetry(value, oldState, reason);
+                if (this._lifecycleState === "loaded") {
+                    this.propagateConnectionState(false /* initial transition */, value === ConnectionState.Disconnected
+                        ? reason
+                        : undefined /* disconnectedReason */);
+                }
+            },
+            shouldClientJoinWrite: () => this._deltaManager.connectionManager.shouldJoinWrite(),
+            maxClientLeaveWaitTime: options.maxClientLeaveWaitTime,
+            logConnectionIssue: (eventName, category, details) => {
+                const mode = this.connectionMode;
+                // We get here when socket does not receive any ops on "write" connection, including
+                // its own join op.
+                // Report issues only if we already loaded container - op processing is paused while container is loading,
+                // so we always time-out processing of join op in cases where fetching snapshot takes a minute.
+                // It's not a problem with op processing itself - such issues should be tracked as part of boot perf monitoring instead.
+                this._deltaManager.logConnectionIssue({
+                    eventName,
+                    mode,
+                    category: this._lifecycleState === "loading" ? "generic" : category,
+                    duration: performance.now() -
+                        this.connectionTransitionTimes[ConnectionState.CatchingUp],
+                    ...(details === undefined ? {} : { details: JSON.stringify(details) }),
+                });
+                // If this is "write" connection, it took too long to receive join op. But in most cases that's due
+                // to very slow op fetches and we will eventually get there.
+                // For "read" connections, we get here due to self join signal not arriving on time. We will need to
+                // better understand when and why it may happen.
+                // For now, attempt to recover by reconnecting. In future, maybe we can query relay service for
+                // current state of audience.
+                // Other possible recovery path - move to connected state (i.e. ConnectionStateHandler.joinOpTimer
+                // to call this.applyForConnectedState("addMemberEvent") for "read" connections)
+                if (mode === "read") {
+                    const reason = { text: "NoJoinSignal" };
+                    this.disconnectInternal(reason);
+                    this.connectInternal({ reason, fetchOpsFromStorage: false });
+                }
+            },
+            clientShouldHaveLeft: (clientId) => {
+                this.clientsWhoShouldHaveLeft.add(clientId);
+            },
+        }, this.deltaManager, pendingLocalState?.clientId);
+        this.on(savedContainerEvent, () => {
+            this.connectionStateHandler.containerSaved();
+        });
+        // We expose our storage publicly, so it's possible others may call uploadSummaryWithContext() with a
+        // non-combined summary tree (in particular, ContainerRuntime.submitSummary).  We'll intercept those calls
+        // using this callback and fix them up.
+        const addProtocolSummaryIfMissing = (summaryTree) => isCombinedAppAndProtocolSummary(summaryTree) === true
+            ? summaryTree
+            : combineAppAndProtocolSummary(summaryTree, this.captureProtocolSummary());
+        // Whether the combined summary tree has been forced on by either the loader option or the monitoring context.
+        // Even if not forced on via this flag, combined summaries may still be enabled by service policy.
+        const forceEnableSummarizeProtocolTree = this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2") ??
+            options.summarizeProtocolTree;
+        this.storageAdapter = new ContainerStorageAdapter(detachedBlobStorage, this.mc.logger, pendingLocalState?.snapshotBlobs, addProtocolSummaryIfMissing, forceEnableSummarizeProtocolTree);
+        const isDomAvailable = typeof document === "object" &&
+            document !== null &&
+            typeof document.addEventListener === "function" &&
+            document.addEventListener !== null;
+        // keep track of last time page was visible for telemetry (on interactive clients only)
+        if (isDomAvailable && interactive) {
+            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);
+        }
+    }
     /**
      * Retrieves the quorum associated with the document
      */
@@ -666,7 +670,6 @@ export class Container extends EventEmitterWithErrorHandling {
                 snapshotBlobs: this.baseSnapshotBlobs,
                 savedOps: this.savedOps,
                 url: this.resolvedUrl.url,
-                term: OnlyValidTermValue,
                 // no need to save this if there is no pending runtime state
                 clientId: pendingRuntimeState !== undefined ? this.clientId : undefined,
             };
@@ -788,6 +791,9 @@ export class Container extends EventEmitterWithErrorHandling {
             }
         }, { start: true, end: true, cancel: "generic" });
     }
+    /**
+     * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+     */
     async request(path) {
         return PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Request" }, async () => this.runtime.request(path), { end: true, cancel: "error" });
     }
@@ -938,18 +944,14 @@ 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);
-        // 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.
+        // 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
+            ? "write"
+            : "read";
         const connectionArgs = {
             reason: { text: "DocumentOpen" },
-            mode: "write",
+            mode,
             fetchOpsFromStorage: false,
         };
         // Start websocket connection as soon as possible. Note that there is no op handler attached yet, but the
@@ -1114,7 +1116,6 @@ export class Container extends EventEmitterWithErrorHandling {
     async createDetached(codeDetails) {
         const attributes = {
             sequenceNumber: detachedContainerRefSeqNumber,
-            term: OnlyValidTermValue,
             minimumSequenceNumber: 0,
         };
         await this.attachDeltaManagerOpHandler(attributes);
@@ -1154,7 +1155,6 @@ export class Container extends EventEmitterWithErrorHandling {
             return {
                 minimumSequenceNumber: 0,
                 sequenceNumber: 0,
-                term: OnlyValidTermValue,
             };
         }
         // Backward compatibility: old docs would have ".attributes" instead of "attributes"