@fluidframework/container-loader 2.0.0-internal.5.1.0 → 2.0.0-internal.5.2.0

package/src/containerContext.ts

@@ -3,27 +3,19 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLoggerExt, PerformanceEvent } from "@fluidframework/telemetry-utils";
-import { assert, LazyPromise, TypedEventEmitter } from "@fluidframework/common-utils";
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import {
 	IAudience,
 	IContainerContext,
 	IDeltaManager,
 	ILoader,
-	IRuntime,
 	ICriticalContainerError,
 	AttachState,
 	ILoaderOptions,
-	IRuntimeFactory,
-	IProvideRuntimeFactory,
 	IFluidCodeDetails,
-	IFluidCodeDetailsComparer,
-	IProvideFluidCodeDetailsComparer,
-	ICodeDetailsLoader,
-	IFluidModuleWithDetails,
 	IBatchMessage,
 } from "@fluidframework/container-definitions";
-import { IRequest, IResponse, FluidObject } from "@fluidframework/core-interfaces";
+import { FluidObject } from "@fluidframework/core-interfaces";
 import { IDocumentStorageService } from "@fluidframework/driver-definitions";
 import {
 	IClientConfiguration,
@@ -32,130 +24,46 @@ import {
 	IQuorum,
 	IQuorumClients,
 	ISequencedDocumentMessage,
-	ISignalMessage,
 	ISnapshotTree,
-	ISummaryTree,
 	IVersion,
 	MessageType,
 	ISummaryContent,
 } from "@fluidframework/protocol-definitions";
-import { UsageError } from "@fluidframework/container-utils";
-import { Container } from "./container";
-
-const PackageNotFactoryError = "Code package does not implement IRuntimeFactory";
 
 /**
- * Events that {@link ContainerContext} can emit through its lifecycle.
- *
- * "runtimeInstantiated" - When an {@link @fluidframework/container-definitions#IRuntime} has been instantiated (by
- * calling instantiateRuntime() on the runtime factory), and this._runtime is set.
- *
- * "disposed" - When its dispose() method is called. The {@link ContainerContext} is no longer usable at that point.
+ * {@inheritDoc @fluidframework/container-definitions#IContainerContext}
  */
-type ContextLifecycleEvents = "runtimeInstantiated" | "disposed";
-
 export class ContainerContext implements IContainerContext {
-	public static async createOrLoad(
-		container: Container,
-		scope: FluidObject,
-		codeLoader: ICodeDetailsLoader,
-		codeDetails: IFluidCodeDetails,
-		baseSnapshot: ISnapshotTree | undefined,
-		deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
-		quorum: IQuorum,
-		loader: ILoader,
-		submitFn: (type: MessageType, contents: any, batch: boolean, appData: any) => number,
-		submitSummaryFn: (summaryOp: ISummaryContent, referenceSequenceNumber?: number) => number,
-		submitBatchFn: (batch: IBatchMessage[], referenceSequenceNumber?: number) => number,
-		submitSignalFn: (contents: any) => void,
-		disposeFn: (error?: ICriticalContainerError) => void,
-		closeFn: (error?: ICriticalContainerError) => void,
-		version: string,
-		updateDirtyContainerState: (dirty: boolean) => void,
-		existing: boolean,
-		pendingLocalState?: unknown,
-	): Promise<ContainerContext> {
-		const context = new ContainerContext(
-			container,
-			scope,
-			codeLoader,
-			codeDetails,
-			baseSnapshot,
-			deltaManager,
-			quorum,
-			loader,
-			submitFn,
-			submitSummaryFn,
-			submitBatchFn,
-			submitSignalFn,
-			disposeFn,
-			closeFn,
-			version,
-			updateDirtyContainerState,
-			existing,
-			pendingLocalState,
-		);
-		await context.instantiateRuntime(existing);
-		return context;
-	}
-
-	public readonly taggedLogger: ITelemetryLoggerExt;
-	public readonly supportedFeatures: ReadonlyMap<string, unknown>;
+	public readonly supportedFeatures: ReadonlyMap<string, unknown> = new Map([
+		/**
+		 * This version of the loader accepts `referenceSequenceNumber`, provided by the container runtime,
+		 * as a parameter to the `submitBatchFn` and `submitSummaryFn` functions.
+		 * This is then used to set the reference sequence numbers of the submitted ops in the DeltaManager.
+		 */
+		["referenceSequenceNumbers", true],
+	]);
 
 	public get clientId(): string | undefined {
-		return this.container.clientId;
+		return this._getClientId();
 	}
 
 	/**
 	 * DISCLAIMER: this id is only for telemetry purposes. Not suitable for any other usages.
 	 */
 	public get id(): string {
-		return this.container.resolvedUrl?.id ?? "";
+		return this._getContainerDiagnosticId() ?? "";
 	}
 
-	public get clientDetails(): IClientDetails {
-		return this.container.clientDetails;
-	}
-
-	private _connected: boolean;
 	/**
 	 * When true, ops are free to flow
 	 * When false, ops should be kept as pending or rejected
 	 */
 	public get connected(): boolean {
-		return this._connected;
-	}
-
-	public get canSummarize(): boolean {
-		return "summarize" in this.runtime;
+		return this._getConnected();
 	}
 
 	public get serviceConfiguration(): IClientConfiguration | undefined {
-		return this.container.serviceConfiguration;
-	}
-
-	public get audience(): IAudience {
-		return this.container.audience;
-	}
-
-	public get options(): ILoaderOptions {
-		return this.container.options;
-	}
-
-	public get baseSnapshot() {
-		return this._baseSnapshot;
-	}
-
-	public get storage(): IDocumentStorageService {
-		return this.container.storage;
-	}
-
-	private _runtime: IRuntime | undefined;
-	private get runtime() {
-		if (this._runtime === undefined) {
-			throw new Error("Attempted to access runtime before it was defined");
-		}
-		return this._runtime;
+		return this._getServiceConfiguration();
 	}
 
 	private _disposed = false;
@@ -164,59 +72,19 @@ export class ContainerContext implements IContainerContext {
 		return this._disposed;
 	}
 
-	public get codeDetails() {
-		return this._codeDetails;
-	}
-
-	private readonly _quorum: IQuorum;
 	public get quorum(): IQuorumClients {
 		return this._quorum;
 	}
 
-	private readonly _fluidModuleP: Promise<IFluidModuleWithDetails>;
-
-	/**
-	 * {@inheritDoc @fluidframework/container-definitions#IContainerContext.getEntryPoint}
-	 */
-	public async getEntryPoint?(): Promise<FluidObject | undefined> {
-		if (this._disposed) {
-			throw new UsageError("The context is already disposed");
-		}
-		if (this._runtime !== undefined) {
-			return this._runtime?.getEntryPoint?.();
-		}
-		return new Promise<FluidObject | undefined>((resolve, reject) => {
-			const runtimeInstantiatedHandler = () => {
-				assert(
-					this._runtime !== undefined,
-					0x5a3 /* runtimeInstantiated fired but runtime is still undefined */,
-				);
-				resolve(this._runtime.getEntryPoint?.());
-				this.lifecycleEvents.off("disposed", disposedHandler);
-			};
-			const disposedHandler = () => {
-				reject(new Error("ContainerContext was disposed"));
-				this.lifecycleEvents.off("runtimeInstantiated", runtimeInstantiatedHandler);
-			};
-			this.lifecycleEvents.once("runtimeInstantiated", runtimeInstantiatedHandler);
-			this.lifecycleEvents.once("disposed", disposedHandler);
-		});
-	}
-
-	/**
-	 * Emits events about the container context's lifecycle.
-	 * Use it to coordinate things inside the ContainerContext class.
-	 */
-	private readonly lifecycleEvents = new TypedEventEmitter<ContextLifecycleEvents>();
-
 	constructor(
-		private readonly container: Container,
+		public readonly options: ILoaderOptions,
 		public readonly scope: FluidObject,
-		private readonly codeLoader: ICodeDetailsLoader,
-		private readonly _codeDetails: IFluidCodeDetails,
-		private readonly _baseSnapshot: ISnapshotTree | undefined,
+		public readonly baseSnapshot: ISnapshotTree | undefined,
+		private readonly _version: IVersion | undefined,
 		public readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
-		quorum: IQuorum,
+		public readonly storage: IDocumentStorageService,
+		private readonly _quorum: IQuorum,
+		public readonly audience: IAudience,
 		public readonly loader: ILoader,
 		public readonly submitFn: (
 			type: MessageType,
@@ -236,28 +104,18 @@ export class ContainerContext implements IContainerContext {
 		public readonly submitSignalFn: (contents: any) => void,
 		public readonly disposeFn: (error?: ICriticalContainerError) => void,
 		public readonly closeFn: (error?: ICriticalContainerError) => void,
-		public readonly version: string,
 		public readonly updateDirtyContainerState: (dirty: boolean) => void,
+		public readonly getAbsoluteUrl: (relativeUrl: string) => Promise<string | undefined>,
+		private readonly _getContainerDiagnosticId: () => string | undefined,
+		private readonly _getClientId: () => string | undefined,
+		private readonly _getServiceConfiguration: () => IClientConfiguration | undefined,
+		private readonly _getAttachState: () => AttachState,
+		private readonly _getConnected: () => boolean,
+		public readonly clientDetails: IClientDetails,
 		public readonly existing: boolean,
+		public readonly taggedLogger: ITelemetryLoggerExt,
 		public readonly pendingLocalState?: unknown,
-	) {
-		this._connected = this.container.connected;
-		this._quorum = quorum;
-		this.taggedLogger = container.subLogger;
-		this._fluidModuleP = new LazyPromise<IFluidModuleWithDetails>(async () =>
-			this.loadCodeModule(_codeDetails),
-		);
-
-		this.supportedFeatures = new Map([
-			/**
-			 * This version of the loader accepts `referenceSequenceNumber`, provided by the container runtime,
-			 * as a parameter to the `submitBatchFn` and `submitSummaryFn` functions.
-			 * This is then used to set the reference sequence numbers of the submitted ops in the DeltaManager.
-			 */
-			["referenceSequenceNumbers", true],
-		]);
-		this.attachListener();
-	}
+	) {}
 
 	/**
 	 * @deprecated Temporary migratory API, to be removed when customers no longer need it.
@@ -272,158 +130,14 @@ export class ContainerContext implements IContainerContext {
 	}
 
 	public dispose(error?: Error): void {
-		if (this._disposed) {
-			return;
-		}
 		this._disposed = true;
-
-		this.lifecycleEvents.emit("disposed");
-		this.runtime.dispose(error);
-		this._quorum.dispose();
-		this.deltaManager.dispose();
 	}
 
 	public getLoadedFromVersion(): IVersion | undefined {
-		return this.container.loadedFromVersion;
+		return this._version;
 	}
 
 	public get attachState(): AttachState {
-		return this.container.attachState;
-	}
-
-	/**
-	 * Create a summary. Used when attaching or serializing a detached container.
-	 *
-	 * @param blobRedirectTable - A table passed during the attach process. While detached, blob upload is supported
-	 * using IDs generated locally. After attach, these IDs cannot be used, so this table maps the old local IDs to the
-	 * new storage IDs so requests can be redirected.
-	 */
-	public createSummary(blobRedirectTable?: Map<string, string>): ISummaryTree {
-		return this.runtime.createSummary(blobRedirectTable);
-	}
-
-	public setConnectionState(connected: boolean, clientId?: string) {
-		const runtime = this.runtime;
-		this._connected = connected;
-		runtime.setConnectionState(connected, clientId);
-	}
-
-	public process(message: ISequencedDocumentMessage, local: boolean) {
-		this.runtime.process(message, local);
-	}
-
-	public processSignal(message: ISignalMessage, local: boolean) {
-		this.runtime.processSignal(message, local);
-	}
-
-	public async request(path: IRequest): Promise<IResponse> {
-		return this.runtime.request(path);
-	}
-
-	public async getAbsoluteUrl(relativeUrl: string): Promise<string | undefined> {
-		return this.container.getAbsoluteUrl(relativeUrl);
-	}
-
-	public getPendingLocalState(): unknown {
-		return this.runtime.getPendingLocalState();
-	}
-
-	/**
-	 * Determines if the current code details of the context
-	 * satisfy the incoming constraint code details
-	 */
-	public async satisfies(constraintCodeDetails: IFluidCodeDetails) {
-		const comparers: IFluidCodeDetailsComparer[] = [];
-
-		const maybeCompareCodeLoader = this.codeLoader;
-		if (maybeCompareCodeLoader.IFluidCodeDetailsComparer !== undefined) {
-			comparers.push(maybeCompareCodeLoader.IFluidCodeDetailsComparer);
-		}
-
-		const moduleWithDetails = await this._fluidModuleP;
-		const maybeCompareExport: Partial<IProvideFluidCodeDetailsComparer> | undefined =
-			moduleWithDetails.module?.fluidExport;
-		if (maybeCompareExport?.IFluidCodeDetailsComparer !== undefined) {
-			comparers.push(maybeCompareExport.IFluidCodeDetailsComparer);
-		}
-
-		// if there are not comparers it is not possible to know
-		// if the current satisfy the incoming, so return false,
-		// as assuming they do not satisfy is safer .e.g we will
-		// reload, rather than potentially running with
-		// incompatible code
-		if (comparers.length === 0) {
-			return false;
-		}
-
-		for (const comparer of comparers) {
-			const satisfies = await comparer.satisfies(
-				moduleWithDetails.details,
-				constraintCodeDetails,
-			);
-			if (satisfies === false) {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	public async notifyOpReplay(message: ISequencedDocumentMessage): Promise<void> {
-		return this.runtime.notifyOpReplay?.(message);
-	}
-
-	// #region private
-
-	private async getRuntimeFactory(): Promise<IRuntimeFactory> {
-		const fluidExport: FluidObject<IProvideRuntimeFactory> | undefined = (
-			await this._fluidModuleP
-		).module?.fluidExport;
-		const runtimeFactory = fluidExport?.IRuntimeFactory;
-		if (runtimeFactory === undefined) {
-			throw new Error(PackageNotFactoryError);
-		}
-
-		return runtimeFactory;
-	}
-
-	private async instantiateRuntime(existing: boolean) {
-		const runtimeFactory = await this.getRuntimeFactory();
-		this._runtime = await PerformanceEvent.timedExecAsync(
-			this.taggedLogger,
-			{ eventName: "InstantiateRuntime" },
-			async () => runtimeFactory.instantiateRuntime(this, existing),
-		);
-		this.lifecycleEvents.emit("runtimeInstantiated");
-	}
-
-	private attachListener() {
-		this.container.once("attaching", () => {
-			this.runtime.setAttachState(AttachState.Attaching);
-		});
-		this.container.once("attached", () => {
-			this.runtime.setAttachState(AttachState.Attached);
-		});
-	}
-
-	private async loadCodeModule(codeDetails: IFluidCodeDetails): Promise<IFluidModuleWithDetails> {
-		const loadCodeResult = await PerformanceEvent.timedExecAsync(
-			this.taggedLogger,
-			{ eventName: "CodeLoad" },
-			async () => this.codeLoader.load(codeDetails),
-		);
-
-		if ("module" in loadCodeResult) {
-			const { module, details } = loadCodeResult;
-			return {
-				module,
-				details: details ?? codeDetails,
-			};
-		} else {
-			// If "module" is not in the result, we are using a legacy ICodeLoader.  Fix the result up with details.
-			// Once usage drops to 0 we can remove this compat path.
-			this.taggedLogger.sendTelemetryEvent({ eventName: "LegacyCodeLoader" });
-			return loadCodeResult;
-		}
+		return this._getAttachState();
 	}
-	// #endregion
 }

package/src/containerStorageAdapter.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { IDisposable } from "@fluidframework/common-definitions";
+import { IDisposable } from "@fluidframework/core-interfaces";
 import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import { assert, bufferToString, stringToBuffer } from "@fluidframework/common-utils";
 import { ISnapshotTreeWithBlobContents } from "@fluidframework/container-definitions";

package/src/{collabWindowTracker.ts → noopHeuristic.ts}

@@ -3,13 +3,18 @@
  * Licensed under the MIT License.
  */
 
-import { assert, Timer } from "@fluidframework/common-utils";
-import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
-import { isRuntimeMessage, MessageType2 } from "@fluidframework/driver-utils";
+import { assert, Timer, TypedEventEmitter } from "@fluidframework/common-utils";
+import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import { isRuntimeMessage } from "@fluidframework/driver-utils";
+import { IEvent } from "@fluidframework/common-definitions";
 
 const defaultNoopTimeFrequency = 2000;
 const defaultNoopCountFrequency = 50;
 
+export interface INoopSenderEvents extends IEvent {
+	(event: "wantsNoop", listener: () => void);
+}
+
 // Here are key considerations when deciding conditions for when to send non-immediate noops:
 // 1. Sending them too often results in increase in file size and bandwidth, as well as catch up performance
 // 2. Sending too infrequently ensures that collab window is large, and as result Sequence DDS would have
@@ -29,21 +34,21 @@ const defaultNoopCountFrequency = 50;
 //    server timeout of 2000ms should be reconsidered to be increased.
 // 2. If there are more than 50 ops received without sending any ops, send noop to keep collab window small.
 //    Note that system ops (including noops themselves) are excluded, so it's 1 noop per 50 real ops.
-export class CollabWindowTracker {
-	private opsCountSinceNoop = 0;
+export class NoopHeuristic extends TypedEventEmitter<INoopSenderEvents> {
+	private opsProcessedSinceOpSent = 0;
 	private readonly timer: Timer | undefined;
 
 	constructor(
-		private readonly submit: (type: MessageType) => void,
 		NoopTimeFrequency: number = defaultNoopTimeFrequency,
 		private readonly NoopCountFrequency: number = defaultNoopCountFrequency,
 	) {
+		super();
 		if (NoopTimeFrequency !== Infinity) {
 			this.timer = new Timer(NoopTimeFrequency, () => {
-				// Can get here due to this.stopSequenceNumberUpdate() not resetting timer.
-				// Also timer callback can fire even after timer cancellation if it was queued before cancellation.
-				if (this.opsCountSinceNoop !== 0) {
-					this.submitNoop(false /* immediate */);
+				// We allow the timer to expire even if an op is sent or we disconnect.
+				// This condition is to guard against trying to send a noop anyway in that case.
+				if (this.opsProcessedSinceOpSent !== 0) {
+					this.emit("wantsNoop");
 				}
 			});
 		}
@@ -52,17 +57,7 @@ export class CollabWindowTracker {
 	/**
 	 * Schedules as ack to the server to update the reference sequence number
 	 */
-	public scheduleSequenceNumberUpdate(
-		message: ISequencedDocumentMessage,
-		immediateNoOp: boolean,
-	): void {
-		// While processing a message, an immediate no-op can be requested.
-		// i.e. to expedite approve or commit phase of quorum.
-		if (immediateNoOp) {
-			this.submitNoop(true /* immediate */);
-			return;
-		}
-
+	public notifyMessageProcessed(message: ISequencedDocumentMessage): void {
 		// We don't acknowledge no-ops to avoid acknowledgement cycles (i.e. ack the MSN
 		// update, which updates the MSN, then ack the update, etc...).
 		// Intent here is for runtime (and DDSes) not to keep too much tracking state / memory
@@ -71,22 +66,27 @@ export class CollabWindowTracker {
 			return;
 		}
 
-		this.opsCountSinceNoop++;
-		if (this.opsCountSinceNoop === this.NoopCountFrequency) {
-			// Ensure we only send noop after a batch of many ops is processed
-			// eslint-disable-next-line @typescript-eslint/no-floating-promises
-			Promise.resolve().then(() => {
-				if (this.opsCountSinceNoop >= this.NoopCountFrequency) {
-					this.submitNoop(false /* immediate */);
-					// reset count now that all ops are processed
-					this.opsCountSinceNoop = 0;
+		this.opsProcessedSinceOpSent++;
+		if (this.opsProcessedSinceOpSent === this.NoopCountFrequency) {
+			// Wait to send a noop if we are still synchronously processing ops.  This guards against two things:
+			// 1. If we're processing many ops, we may pass the frequency threshold many times.  We only need to send one noop at the very end in this case.
+			// 2. We may send another (non-noop) op in response to processing those ops, e.g. an Accept op.
+			queueMicrotask(() => {
+				if (this.opsProcessedSinceOpSent >= this.NoopCountFrequency) {
+					this.emit("wantsNoop");
+					assert(
+						this.opsProcessedSinceOpSent === 0,
+						0x243 /* "Expected a noop to be synchronously sent" */,
+					);
 				}
 				return;
 			});
 		}
 
 		if (this.timer !== undefined) {
-			if (this.opsCountSinceNoop === 1) {
+			// Start the timer if we newly have ops that want a noop.
+			// If the timer was already running (e.g. we surpassed the op count and sent a noop) this will reset it to its full duration.
+			if (this.opsProcessedSinceOpSent === 1) {
 				this.timer.restart();
 			}
 
@@ -94,23 +94,13 @@ export class CollabWindowTracker {
 		}
 	}
 
-	private submitNoop(immediate: boolean) {
-		// Anything other than null is immediate noop
-		// ADO:1385: Remove cast and use MessageType once definition changes propagate
-		this.submit(immediate ? (MessageType2.Accept as unknown as MessageType) : MessageType.NoOp);
-		assert(
-			this.opsCountSinceNoop === 0,
-			0x243 /* "stopSequenceNumberUpdate should be called as result of sending any op!" */,
-		);
+	public notifyDisconnect(): void {
+		// No need to noop for any ops processed prior to disconnect - we are already removed from MSN calculation.
+		this.opsProcessedSinceOpSent = 0;
 	}
 
-	public stopSequenceNumberUpdate(): void {
-		this.opsCountSinceNoop = 0;
-		// Ideally, we cancel timer here. But that will result in too often set/reset cycle if this client
-		// keeps sending ops. In most cases it's actually better to let it expire (at most - 4 times per second)
-		// for nothing, then have a ton of set/reset cycles.
-		// Note that Timer.restart() is smart and will not change timer expiration if we keep extending timer
-		// expiration - it will restart the timer instead when it fires with adjusted expiration.
-		// this.timer.clear();
+	public notifyMessageSent(): void {
+		// Sending any message is as good as a noop for updating MSN.
+		this.opsProcessedSinceOpSent = 0;
 	}
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-loader";
-export const pkgVersion = "2.0.0-internal.5.1.0";
+export const pkgVersion = "2.0.0-internal.5.2.0";

package/src/protocol.ts

@@ -11,14 +11,9 @@ import {
 } from "@fluidframework/protocol-base";
 import {
 	IDocumentAttributes,
-	IProcessMessageResult,
-	ISequencedClient,
-	ISequencedDocumentMessage,
 	ISignalClient,
 	ISignalMessage,
-	MessageType,
 } from "@fluidframework/protocol-definitions";
-import { canBeCoalescedByService } from "@fluidframework/driver-utils";
 
 // "term" was an experimental feature that is being removed.  The only safe value to use is 1.
 export const OnlyValidTermValue = 1 as const;
@@ -30,17 +25,6 @@ export enum SignalType {
 	Clear = "clear", // used only by client for synthetic signals
 }
 
-/**
- * ADO: #4277: ConnectionStateHandler can mutate Quorum members, but shouldn't
- * This interface might go away after the above ADO item is done
- */
-export interface ILocalSequencedClient extends ISequencedClient {
-	/**
-	 * True if the client should have left the quorum, false otherwise
-	 */
-	shouldHaveLeft?: boolean;
-}
-
 /**
  * Function to be used for creating a protocol handler.
  */
@@ -82,29 +66,6 @@ export class ProtocolHandler extends ProtocolOpHandler implements IProtocolHandl
 		}
 	}
 
-	public processMessage(
-		message: ISequencedDocumentMessage,
-		local: boolean,
-	): IProcessMessageResult {
-		const client: ILocalSequencedClient | undefined = this.quorum.getMember(message.clientId);
-
-		// Check and report if we're getting messages from a clientId that we previously
-		// flagged as shouldHaveLeft, or from a client that's not in the quorum but should be
-		if (message.clientId != null) {
-			if (client === undefined && message.type !== MessageType.ClientJoin) {
-				// pre-0.58 error message: messageClientIdMissingFromQuorum
-				throw new Error("Remote message's clientId is missing from the quorum");
-			}
-
-			if (client?.shouldHaveLeft === true && !canBeCoalescedByService(message)) {
-				// pre-0.58 error message: messageClientIdShouldHaveLeft
-				throw new Error("Remote message's clientId already should have left");
-			}
-		}
-
-		return super.processMessage(message, local);
-	}
-
 	public processSignal(message: ISignalMessage) {
 		const innerContent = message.content as { content: any; type: string };
 		switch (innerContent.type) {

package/src/protocolTreeDocumentStorageService.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { IDisposable } from "@fluidframework/common-definitions";
+import { IDisposable } from "@fluidframework/core-interfaces";
 import { IDocumentStorageService, ISummaryContext } from "@fluidframework/driver-definitions";
 import { ISummaryTree } from "@fluidframework/protocol-definitions";
 

package/src/retriableDocumentStorageService.ts

@@ -18,7 +18,8 @@ import {
 	ISummaryTree,
 	IVersion,
 } from "@fluidframework/protocol-definitions";
-import { IDisposable } from "@fluidframework/common-definitions";
+import { IDisposable } from "@fluidframework/core-interfaces";
+
 import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import { runWithRetry } from "@fluidframework/driver-utils";