@fluidframework/container-loader 2.0.0-dev.5.2.0.169897 → 2.0.0-dev.6.4.0.191258

package/src/loader.ts

@@ -4,19 +4,18 @@
  */
 
 import { v4 as uuid } from "uuid";
-import { ITelemetryBaseLogger } from "@fluidframework/common-definitions";
 import {
 	ITelemetryLoggerExt,
-	ChildLogger,
-	DebugLogger,
 	IConfigProviderBase,
-	loggerToMonitoringContext,
 	mixinMonitoringContext,
 	MonitoringContext,
 	PerformanceEvent,
 	sessionStorageConfigProvider,
+	createChildMonitoringContext,
+	UsageError,
 } from "@fluidframework/telemetry-utils";
 import {
+	ITelemetryBaseLogger,
 	FluidObject,
 	IFluidRouter,
 	IRequest,
@@ -39,18 +38,15 @@ import {
 	IResolvedUrl,
 	IUrlResolver,
 } from "@fluidframework/driver-definitions";
-import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import { IClientDetails } from "@fluidframework/protocol-definitions";
 import { Container, IPendingContainerState } from "./container";
 import { IParsedUrl, parseUrl } from "./utils";
 import { pkgVersion } from "./packageVersion";
 import { ProtocolHandlerBuilder } from "./protocol";
+import { DebugLogger } from "./debugLogger";
 
 function canUseCache(request: IRequest): boolean {
-	if (request.headers === undefined) {
-		return true;
-	}
-
-	return request.headers[LoaderHeader.cache] !== false;
+	return request.headers?.[LoaderHeader.cache] === true;
 }
 
 function ensureResolvedUrlDefined(
@@ -69,6 +65,9 @@ export class RelativeLoader implements ILoader {
 		private readonly loader: ILoader | undefined,
 	) {}
 
+	/**
+	 * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
+	 */
 	public get IFluidRouter(): IFluidRouter {
 		return this;
 	}
@@ -100,6 +99,9 @@ export class RelativeLoader implements ILoader {
 		return this.loader.resolve(request);
 	}
 
+	/**
+	 * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
+	 */
 	public async request(request: IRequest): Promise<IResponse> {
 		if (request.url.startsWith("/")) {
 			const container = await this.resolve(request);
@@ -149,7 +151,7 @@ export interface ICodeDetailsLoader extends Partial<IProvideFluidCodeDetailsComp
 	 * Load the code module (package) that is capable to interact with the document.
 	 *
 	 * @param source - Code proposal that articulates the current schema the document is written in.
-	 * @returns - Code module entry point along with the code details associated with it.
+	 * @returns Code module entry point along with the code details associated with it.
 	 */
 	load(source: IFluidCodeDetails): Promise<IFluidModuleWithDetails>;
 }
@@ -343,15 +345,33 @@ export class Loader implements IHostLoader {
 			protocolHandlerBuilder,
 			subLogger: subMc.logger,
 		};
-		this.mc = loggerToMonitoringContext(ChildLogger.create(this.services.subLogger, "Loader"));
+		this.mc = createChildMonitoringContext({
+			logger: this.services.subLogger,
+			namespace: "Loader",
+		});
 	}
 
+	/**
+	 * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
+	 */
 	public get IFluidRouter(): IFluidRouter {
 		return this;
 	}
 
-	public async createDetachedContainer(codeDetails: IFluidCodeDetails): Promise<IContainer> {
-		const container = await Container.createDetached(this.services, codeDetails);
+	public async createDetachedContainer(
+		codeDetails: IFluidCodeDetails,
+		createDetachedProps?: {
+			canReconnect?: boolean;
+			clientDetailsOverride?: IClientDetails;
+		},
+	): Promise<IContainer> {
+		const container = await Container.createDetached(
+			{
+				...createDetachedProps,
+				...this.services,
+			},
+			codeDetails,
+		);
 
 		if (this.cachingEnabled) {
 			container.once("attached", () => {
@@ -366,8 +386,20 @@ export class Loader implements IHostLoader {
 		return container;
 	}
 
-	public async rehydrateDetachedContainerFromSnapshot(snapshot: string): Promise<IContainer> {
-		return Container.rehydrateDetachedFromSnapshot(this.services, snapshot);
+	public async rehydrateDetachedContainerFromSnapshot(
+		snapshot: string,
+		createDetachedProps?: {
+			canReconnect?: boolean;
+			clientDetailsOverride?: IClientDetails;
+		},
+	): Promise<IContainer> {
+		return Container.rehydrateDetachedFromSnapshot(
+			{
+				...createDetachedProps,
+				...this.services,
+			},
+			snapshot,
+		);
 	}
 
 	public async resolve(request: IRequest, pendingLocalState?: string): Promise<IContainer> {
@@ -381,6 +413,9 @@ export class Loader implements IHostLoader {
 		});
 	}
 
+	/**
+	 * @deprecated - Will be removed in future major release. Migrate all usage of IFluidRouter to the Container's IFluidRouter/request.
+	 */
 	public async request(request: IRequest): Promise<IResponse> {
 		return PerformanceEvent.timedExecAsync(
 			this.mc.logger,
@@ -407,16 +442,23 @@ export class Loader implements IHostLoader {
 		this.containers.set(key, containerP);
 		containerP
 			.then((container) => {
-				// If the container is closed or becomes closed after we resolve it, remove it from the cache.
-				if (container.closed) {
+				// If the container is closed/disposed or becomes closed/disposed after we resolve it,
+				// remove it from the cache.
+				if (container.closed || container.disposed) {
 					this.containers.delete(key);
 				} else {
 					container.once("closed", () => {
 						this.containers.delete(key);
 					});
+					container.once("disposed", () => {
+						this.containers.delete(key);
+					});
 				}
 			})
-			.catch((error) => {});
+			.catch((error) => {
+				// If an error occured while resolving the container request, then remove it from the cache.
+				this.containers.delete(key);
+			});
 	}
 
 	private async resolveCore(
@@ -447,11 +489,29 @@ export class Loader implements IHostLoader {
 		// If set in both query string and headers, use query string.  Also write the value from the query string into the header either way.
 		request.headers[LoaderHeader.version] =
 			parsed.version ?? request.headers[LoaderHeader.version];
+		const cacheHeader = request.headers[LoaderHeader.cache];
 		const canCache =
-			this.cachingEnabled &&
-			request.headers[LoaderHeader.cache] !== false &&
+			// Take header value if present, else use ILoaderOptions.cache value
+			(cacheHeader !== undefined ? cacheHeader === true : this.cachingEnabled) &&
 			pendingLocalState === undefined;
-		const fromSequenceNumber = request.headers[LoaderHeader.sequenceNumber] ?? -1;
+		const fromSequenceNumber = request.headers[LoaderHeader.sequenceNumber] as
+			| number
+			| undefined;
+		const opsBeforeReturn = request.headers[LoaderHeader.loadMode]?.opsBeforeReturn as
+			| string
+			| undefined;
+
+		if (
+			opsBeforeReturn === "sequenceNumber" &&
+			(fromSequenceNumber === undefined || fromSequenceNumber < 0)
+		) {
+			// If opsBeforeReturn is set to "sequenceNumber", then fromSequenceNumber should be set to a non-negative integer.
+			throw new UsageError("sequenceNumber must be set to a non-negative integer");
+		} else if (opsBeforeReturn !== "sequenceNumber" && fromSequenceNumber !== undefined) {
+			// If opsBeforeReturn is not set to "sequenceNumber", then fromSequenceNumber should be undefined (default value).
+			// In this case, we should throw an error since opsBeforeReturn is not explicitly set to "sequenceNumber".
+			throw new UsageError('opsBeforeReturn must be set to "sequenceNumber"');
+		}
 
 		let container: Container;
 		if (canCache) {
@@ -468,24 +528,11 @@ export class Loader implements IHostLoader {
 			container = await this.loadContainer(request, resolvedAsFluid, pendingLocalState);
 		}
 
-		if (container.deltaManager.lastSequenceNumber <= fromSequenceNumber) {
-			await new Promise<void>((resolve, reject) => {
-				function opHandler(message: ISequencedDocumentMessage) {
-					if (message.sequenceNumber > fromSequenceNumber) {
-						resolve();
-						container.removeListener("op", opHandler);
-					}
-				}
-
-				container.on("op", opHandler);
-			});
-		}
-
 		return { container, parsed };
 	}
 
 	private get cachingEnabled() {
-		return this.services.options.cache !== false;
+		return this.services.options.cache === true;
 	}
 
 	private async loadContainer(
@@ -499,6 +546,7 @@ export class Loader implements IHostLoader {
 				version: request.headers?.[LoaderHeader.version] ?? undefined,
 				loadMode: request.headers?.[LoaderHeader.loadMode],
 				pendingLocalState,
+				loadToSequenceNumber: request.headers?.[LoaderHeader.sequenceNumber],
 			},
 			{
 				canReconnect: request.headers?.[LoaderHeader.reconnect],

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

@@ -3,13 +3,19 @@
  * 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 { TypedEventEmitter } from "@fluid-internal/client-utils";
+import { assert, Timer } from "@fluidframework/core-utils";
+import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import { isRuntimeMessage } from "@fluidframework/driver-utils";
+import { IEvent } from "@fluidframework/core-interfaces";
 
 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 +35,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 +58,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 +67,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 +95,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-dev.5.2.0.169897";
+export const pkgVersion = "2.0.0-dev.6.4.0.191258";

package/src/protocol.ts

@@ -4,6 +4,7 @@
  */
 
 import { IAudienceOwner } from "@fluidframework/container-definitions";
+import { canBeCoalescedByService } from "@fluidframework/driver-utils";
 import {
 	IProtocolHandler as IBaseProtocolHandler,
 	IQuorumSnapshot,
@@ -18,7 +19,6 @@ import {
 	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 +30,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.
  */
@@ -60,12 +49,12 @@ export class ProtocolHandler extends ProtocolOpHandler implements IProtocolHandl
 		attributes: IDocumentAttributes,
 		quorumSnapshot: IQuorumSnapshot,
 		sendProposal: (key: string, value: any) => number,
-		readonly audience: IAudienceOwner,
+		public readonly audience: IAudienceOwner,
+		private readonly shouldClientHaveLeft: (clientId: string) => boolean,
 	) {
 		super(
 			attributes.minimumSequenceNumber,
 			attributes.sequenceNumber,
-			OnlyValidTermValue,
 			quorumSnapshot.members,
 			quorumSnapshot.proposals,
 			quorumSnapshot.values,
@@ -86,7 +75,7 @@ export class ProtocolHandler extends ProtocolOpHandler implements IProtocolHandl
 		message: ISequencedDocumentMessage,
 		local: boolean,
 	): IProcessMessageResult {
-		const client: ILocalSequencedClient | undefined = this.quorum.getMember(message.clientId);
+		const client: ISequencedClient | 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
@@ -96,7 +85,10 @@ export class ProtocolHandler extends ProtocolOpHandler implements IProtocolHandl
 				throw new Error("Remote message's clientId is missing from the quorum");
 			}
 
-			if (client?.shouldHaveLeft === true && !canBeCoalescedByService(message)) {
+			// Here checking canBeCoalescedByService is used as an approximation of "is benign to process despite being unexpected".
+			// It's still not good to see these messages from unexpected clientIds, but since they don't harm the integrity of the
+			// document we don't need to blow up aggressively.
+			if (this.shouldClientHaveLeft(message.clientId) && !canBeCoalescedByService(message)) {
 				// pre-0.58 error message: messageClientIdShouldHaveLeft
 				throw new Error("Remote message's clientId already should have left");
 			}
@@ -138,3 +130,21 @@ export class ProtocolHandler extends ProtocolOpHandler implements IProtocolHandl
 		}
 	}
 }
+
+/**
+ * Function to check whether the protocol handler should process the Signal.
+ * The protocol handler should strictly handle only ClientJoin, ClientLeave
+ * and Clear signal types.
+ */
+export function protocolHandlerShouldProcessSignal(message: ISignalMessage) {
+	// Signal originates from server
+	if (message.clientId === null) {
+		const innerContent = message.content as { content: unknown; type: string };
+		return (
+			innerContent.type === SignalType.Clear ||
+			innerContent.type === SignalType.ClientJoin ||
+			innerContent.type === SignalType.ClientLeave
+		);
+	}
+	return false;
+}

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/quorum.ts

@@ -2,47 +2,8 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { assert, EventForwarder, doIfNotDisposed } from "@fluidframework/common-utils";
 import { IFluidCodeDetails } from "@fluidframework/core-interfaces";
-import {
-	ICommittedProposal,
-	IQuorum,
-	IQuorumEvents,
-	ISequencedClient,
-} from "@fluidframework/protocol-definitions";
-
-/**
- * Proxies Quorum events.
- */
-export class QuorumProxy extends EventForwarder<IQuorumEvents> implements IQuorum {
-	public readonly propose: (key: string, value: any) => Promise<void>;
-	public readonly has: (key: string) => boolean;
-	public readonly get: (key: string) => any;
-	public readonly getMembers: () => Map<string, ISequencedClient>;
-	public readonly getMember: (clientId: string) => ISequencedClient | undefined;
-
-	constructor(quorum: IQuorum) {
-		super(quorum);
-
-		// This is heavily used object, increase limit at which Node prints warnings.
-		super.setMaxListeners(50);
-
-		this.propose = doIfNotDisposed(this, quorum.propose.bind(quorum));
-		this.has = doIfNotDisposed(this, quorum.has.bind(quorum));
-		this.get = doIfNotDisposed(this, quorum.get.bind(quorum));
-		this.getMembers = doIfNotDisposed(this, quorum.getMembers.bind(quorum));
-		this.getMember = doIfNotDisposed(this, quorum.getMember.bind(quorum));
-	}
-}
-
-export function getCodeDetailsFromQuorumValues(
-	quorumValues: [string, ICommittedProposal][],
-): IFluidCodeDetails {
-	const qValuesMap = new Map(quorumValues);
-	const proposal = qValuesMap.get("code");
-	assert(proposal !== undefined, 0x2dc /* "Cannot find code proposal" */);
-	return proposal?.value as IFluidCodeDetails;
-}
+import { ICommittedProposal } from "@fluidframework/protocol-definitions";
 
 export function initQuorumValuesFromCodeDetails(
 	source: IFluidCodeDetails,

package/src/retriableDocumentStorageService.ts

@@ -3,8 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/common-utils";
-import { GenericError } from "@fluidframework/container-utils";
+import { assert } from "@fluidframework/core-utils";
 import {
 	FetchSource,
 	IDocumentStorageService,
@@ -18,8 +17,8 @@ import {
 	ISummaryTree,
 	IVersion,
 } from "@fluidframework/protocol-definitions";
-import { IDisposable } from "@fluidframework/common-definitions";
-import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
+import { IDisposable } from "@fluidframework/core-interfaces";
+import { GenericError, ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import { runWithRetry } from "@fluidframework/driver-utils";
 
 export class RetriableDocumentStorageService implements IDocumentStorageService, IDisposable {

package/src/utils.ts

@@ -5,19 +5,16 @@
 
 import { parse } from "url";
 import { v4 as uuid } from "uuid";
-import {
-	assert,
-	stringToBuffer,
-	Uint8ArrayToArrayBuffer,
-	unreachableCase,
-} from "@fluidframework/common-utils";
+import { stringToBuffer, Uint8ArrayToArrayBuffer } from "@fluid-internal/client-utils";
+import { assert, unreachableCase } from "@fluidframework/core-utils";
 import { ISummaryTree, ISnapshotTree, SummaryType } from "@fluidframework/protocol-definitions";
 import { LoggingError } from "@fluidframework/telemetry-utils";
 import {
+	CombinedAppAndProtocolSummary,
 	DeltaStreamConnectionForbiddenError,
 	isCombinedAppAndProtocolSummary,
 } from "@fluidframework/driver-utils";
-import { DriverErrorType } from "@fluidframework/driver-definitions";
+import { DriverErrorTypes } from "@fluidframework/driver-definitions";
 
 // This is used when we rehydrate a container from the snapshot. Here we put the blob contents
 // in separate property: blobContents.
@@ -51,6 +48,34 @@ export function parseUrl(url: string): IParsedUrl | undefined {
 		: undefined;
 }
 
+/**
+ * Combine the app summary and protocol summary in 1 tree.
+ * @param appSummary - Summary of the app.
+ * @param protocolSummary - Summary of the protocol.
+ * @internal
+ */
+export function combineAppAndProtocolSummary(
+	appSummary: ISummaryTree,
+	protocolSummary: ISummaryTree,
+): CombinedAppAndProtocolSummary {
+	assert(
+		!isCombinedAppAndProtocolSummary(appSummary),
+		0x5a8 /* app summary is already a combined tree! */,
+	);
+	assert(
+		!isCombinedAppAndProtocolSummary(protocolSummary),
+		0x5a9 /* protocol summary is already a combined tree! */,
+	);
+	const createNewSummary: CombinedAppAndProtocolSummary = {
+		type: SummaryType.Tree,
+		tree: {
+			".protocol": protocolSummary,
+			".app": appSummary,
+		},
+	};
+	return createNewSummary;
+}
+
 /**
  * Converts summary tree (for upload) to snapshot tree (for download).
  * Summary tree blobs contain contents, but snapshot tree blobs normally
@@ -156,6 +181,6 @@ export function isDeltaStreamConnectionForbiddenError(
 	return (
 		typeof error === "object" &&
 		error !== null &&
-		error?.errorType === DriverErrorType.deltaStreamConnectionForbidden
+		error?.errorType === DriverErrorTypes.deltaStreamConnectionForbidden
 	);
 }

package/dist/collabWindowTracker.d.ts

@@ -1,19 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
-export declare class CollabWindowTracker {
-    private readonly submit;
-    private readonly NoopCountFrequency;
-    private opsCountSinceNoop;
-    private readonly timer;
-    constructor(submit: (type: MessageType) => void, NoopTimeFrequency?: number, NoopCountFrequency?: number);
-    /**
-     * Schedules as ack to the server to update the reference sequence number
-     */
-    scheduleSequenceNumberUpdate(message: ISequencedDocumentMessage, immediateNoOp: boolean): void;
-    private submitNoop;
-    stopSequenceNumberUpdate(): void;
-}
-//# sourceMappingURL=collabWindowTracker.d.ts.map

package/dist/collabWindowTracker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"collabWindowTracker.d.ts","sourceRoot":"","sources":["../src/collabWindowTracker.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,yBAAyB,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AAyB9F,qBAAa,mBAAmB;IAK9B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAEvB,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IANpC,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;gBAGxB,MAAM,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,EACpD,iBAAiB,GAAE,MAAiC,EACnC,kBAAkB,GAAE,MAAkC;IAaxE;;OAEG;IACI,4BAA4B,CAClC,OAAO,EAAE,yBAAyB,EAClC,aAAa,EAAE,OAAO,GACpB,IAAI;IAuCP,OAAO,CAAC,UAAU;IAUX,wBAAwB,IAAI,IAAI;CASvC"}