@fluidframework/container-loader 2.0.0-dev.3.1.0.125672 → 2.0.0-dev.4.1.0.148229

package/src/containerContext.ts

@@ -4,7 +4,7 @@
  */
 
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { LazyPromise } from "@fluidframework/common-utils";
+import { assert, LazyPromise, TypedEventEmitter } from "@fluidframework/common-utils";
 import {
 	IAudience,
 	IContainerContext,
@@ -21,7 +21,6 @@ import {
 	IProvideFluidCodeDetailsComparer,
 	ICodeDetailsLoader,
 	IFluidModuleWithDetails,
-	ISnapshotTreeWithBlobContents,
 	IBatchMessage,
 } from "@fluidframework/container-definitions";
 import { IRequest, IResponse, FluidObject } from "@fluidframework/core-interfaces";
@@ -42,10 +41,21 @@ import {
 	ISummaryContent,
 } from "@fluidframework/protocol-definitions";
 import { PerformanceEvent } from "@fluidframework/telemetry-utils";
+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.
+ */
+type ContextLifecycleEvents = "runtimeInstantiated" | "disposed";
+
 export class ContainerContext implements IContainerContext {
 	public static async createOrLoad(
 		container: Container,
@@ -57,8 +67,8 @@ export class ContainerContext implements IContainerContext {
 		quorum: IQuorum,
 		loader: ILoader,
 		submitFn: (type: MessageType, contents: any, batch: boolean, appData: any) => number,
-		submitSummaryFn: (summaryOp: ISummaryContent) => number,
-		submitBatchFn: (batch: IBatchMessage[]) => 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,
@@ -92,6 +102,7 @@ export class ContainerContext implements IContainerContext {
 	}
 
 	public readonly taggedLogger: ITelemetryLogger;
+	public readonly supportedFeatures: ReadonlyMap<string, unknown>;
 
 	public get clientId(): string | undefined {
 		return this.container.clientId;
@@ -170,12 +181,46 @@ export class ContainerContext implements IContainerContext {
 
 	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 scope: FluidObject,
 		private readonly codeLoader: ICodeDetailsLoader,
 		private readonly _codeDetails: IFluidCodeDetails,
-		private _baseSnapshot: ISnapshotTree | undefined,
+		private readonly _baseSnapshot: ISnapshotTree | undefined,
 		public readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
 		quorum: IQuorum,
 		public readonly loader: ILoader,
@@ -185,9 +230,15 @@ export class ContainerContext implements IContainerContext {
 			batch: boolean,
 			appData: any,
 		) => number,
-		public readonly submitSummaryFn: (summaryOp: ISummaryContent) => number,
+		public readonly submitSummaryFn: (
+			summaryOp: ISummaryContent,
+			referenceSequenceNumber?: number,
+		) => number,
 		/** @returns clientSequenceNumber of last message in a batch */
-		public readonly submitBatchFn: (batch: IBatchMessage[]) => number,
+		public readonly submitBatchFn: (
+			batch: IBatchMessage[],
+			referenceSequenceNumber?: number,
+		) => number,
 		public readonly submitSignalFn: (contents: any) => void,
 		public readonly disposeFn: (error?: ICriticalContainerError) => void,
 		public readonly closeFn: (error?: ICriticalContainerError) => void,
@@ -202,6 +253,15 @@ export class ContainerContext implements IContainerContext {
 		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();
 	}
 
@@ -223,6 +283,7 @@ export class ContainerContext implements IContainerContext {
 		}
 		this._disposed = true;
 
+		this.lifecycleEvents.emit("disposed");
 		this.runtime.dispose(error);
 		this._quorum.dispose();
 		this.deltaManager.dispose();
@@ -313,10 +374,8 @@ export class ContainerContext implements IContainerContext {
 		return true;
 	}
 
-	public notifyAttaching(snapshot: ISnapshotTreeWithBlobContents) {
-		this._baseSnapshot = snapshot;
-		this.runtime.notifyAttaching?.(snapshot);
-		this.runtime.setAttachState(AttachState.Attaching);
+	public async notifyOpReplay(message: ISequencedDocumentMessage): Promise<void> {
+		return this.runtime.notifyOpReplay?.(message);
 	}
 
 	// #region private
@@ -340,9 +399,13 @@ export class ContainerContext implements IContainerContext {
 			{ 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);
 		});

package/src/containerStorageAdapter.ts

@@ -4,7 +4,7 @@
  */
 
 import { IDisposable, ITelemetryLogger } from "@fluidframework/common-definitions";
-import { assert } from "@fluidframework/common-utils";
+import { assert, bufferToString, stringToBuffer } from "@fluidframework/common-utils";
 import { ISnapshotTreeWithBlobContents } from "@fluidframework/container-definitions";
 import {
 	FetchSource,
@@ -25,20 +25,51 @@ import { IDetachedBlobStorage } from "./loader";
 import { ProtocolTreeStorageService } from "./protocolTreeDocumentStorageService";
 import { RetriableDocumentStorageService } from "./retriableDocumentStorageService";
 
+/**
+ * Stringified blobs from a summary/snapshot tree.
+ * @deprecated this is an internal interface and will not longer be exported in future versions
+ * @internal
+ */
+export interface ISerializableBlobContents {
+	[id: string]: string;
+}
+
 /**
  * This class wraps the actual storage and make sure no wrong apis are called according to
  * container attach state.
  */
 export class ContainerStorageAdapter implements IDocumentStorageService, IDisposable {
-	private readonly blobContents: { [id: string]: ArrayBufferLike } = {};
 	private _storageService: IDocumentStorageService & Partial<IDisposable>;
 
-	constructor(
+	private _summarizeProtocolTree: boolean | undefined;
+	/**
+	 * Whether the adapter will enforce sending combined summary trees.
+	 */
+	public get summarizeProtocolTree() {
+		return this._summarizeProtocolTree === true;
+	}
+
+	/**
+	 * An adapter that ensures we're using detachedBlobStorage up until we connect to a real service, and then
+	 * after connecting to a real service augments it with retry and combined summary tree enforcement.
+	 * @param detachedBlobStorage - The detached blob storage to use up until we connect to a real service
+	 * @param logger - Telemetry logger
+	 * @param addProtocolSummaryIfMissing - a callback to permit the container to inspect the summary we're about to
+	 * upload, and fix it up with a protocol tree if needed
+	 * @param forceEnableSummarizeProtocolTree - Enforce uploading a protocol summary regardless of the service's policy
+	 */
+	public constructor(
 		detachedBlobStorage: IDetachedBlobStorage | undefined,
 		private readonly logger: ITelemetryLogger,
-		private readonly captureProtocolSummary?: () => ISummaryTree,
+		/**
+		 * ArrayBufferLikes or utf8 encoded strings, containing blobs from a snapshot
+		 */
+		private readonly blobContents: { [id: string]: ArrayBufferLike | string } = {},
+		private readonly addProtocolSummaryIfMissing: (summaryTree: ISummaryTree) => ISummaryTree,
+		forceEnableSummarizeProtocolTree: boolean | undefined,
 	) {
 		this._storageService = new BlobOnlyStorage(detachedBlobStorage, logger);
+		this._summarizeProtocolTree = forceEnableSummarizeProtocolTree;
 	}
 
 	disposed: boolean = false;
@@ -58,11 +89,13 @@ export class ContainerStorageAdapter implements IDocumentStorageService, IDispos
 			this.logger,
 		));
 
-		if (this.captureProtocolSummary !== undefined) {
+		this._summarizeProtocolTree =
+			this._summarizeProtocolTree ?? service.policies?.summarizeProtocolTree;
+		if (this.summarizeProtocolTree) {
 			this.logger.sendTelemetryEvent({ eventName: "summarizeProtocolTreeEnabled" });
 			this._storageService = new ProtocolTreeStorageService(
 				retriableStorage,
-				this.captureProtocolSummary,
+				this.addProtocolSummaryIfMissing,
 			);
 		}
 
@@ -107,9 +140,13 @@ export class ContainerStorageAdapter implements IDocumentStorageService, IDispos
 	}
 
 	public async readBlob(id: string): Promise<ArrayBufferLike> {
-		const blob = this.blobContents[id];
-		if (blob !== undefined) {
-			return blob;
+		const maybeBlob = this.blobContents[id];
+		if (maybeBlob !== undefined) {
+			if (typeof maybeBlob === "string") {
+				const blob = stringToBuffer(maybeBlob, "utf8");
+				return blob;
+			}
+			return maybeBlob;
 		}
 		return this._storageService.readBlob(id);
 	}
@@ -191,3 +228,70 @@ class BlobOnlyStorage implements IDocumentStorageService {
 		}
 	}
 }
+
+// runtime will write a tree to the summary containing only "attachment" type entries
+// which reference attachment blobs by ID. However, some drivers do not support this type
+// and will convert them to "blob" type entries. We want to avoid saving these to reduce
+// the size of stashed change blobs.
+const blobsTreeName = ".blobs";
+
+/**
+ * Get blob contents of a snapshot tree from storage (or, ideally, cache)
+ */
+export async function getBlobContentsFromTree(
+	snapshot: ISnapshotTree,
+	storage: IDocumentStorageService,
+): Promise<ISerializableBlobContents> {
+	const blobs = {};
+	await getBlobContentsFromTreeCore(snapshot, blobs, storage);
+	return blobs;
+}
+
+async function getBlobContentsFromTreeCore(
+	tree: ISnapshotTree,
+	blobs: ISerializableBlobContents,
+	storage: IDocumentStorageService,
+	root = true,
+) {
+	const treePs: Promise<any>[] = [];
+	for (const [key, subTree] of Object.entries(tree.trees)) {
+		if (!root || key !== blobsTreeName) {
+			treePs.push(getBlobContentsFromTreeCore(subTree, blobs, storage, false));
+		}
+	}
+	for (const id of Object.values(tree.blobs)) {
+		const blob = await storage.readBlob(id);
+		// ArrayBufferLike will not survive JSON.stringify()
+		blobs[id] = bufferToString(blob, "utf8");
+	}
+	return Promise.all(treePs);
+}
+
+/**
+ * Extract blob contents from a snapshot tree with blob contents
+ */
+export function getBlobContentsFromTreeWithBlobContents(
+	snapshot: ISnapshotTreeWithBlobContents,
+): ISerializableBlobContents {
+	const blobs = {};
+	getBlobContentsFromTreeWithBlobContentsCore(snapshot, blobs);
+	return blobs;
+}
+
+function getBlobContentsFromTreeWithBlobContentsCore(
+	tree: ISnapshotTreeWithBlobContents,
+	blobs: ISerializableBlobContents,
+	root = true,
+) {
+	for (const [key, subTree] of Object.entries(tree.trees)) {
+		if (!root || key !== blobsTreeName) {
+			getBlobContentsFromTreeWithBlobContentsCore(subTree, blobs, false);
+		}
+	}
+	for (const id of Object.values(tree.blobs)) {
+		const blob = tree.blobsContents[id];
+		assert(blob !== undefined, 0x2ec /* "Blob must be present in blobsContents" */);
+		// ArrayBufferLike will not survive JSON.stringify()
+		blobs[id] = bufferToString(blob, "utf8");
+	}
+}

package/src/contracts.ts

@@ -7,7 +7,7 @@ import { ITelemetryProperties } from "@fluidframework/common-definitions";
 import {
 	IDeltaQueue,
 	ReadOnlyInfo,
-	IConnectionDetails,
+	IConnectionDetailsInternal,
 	ICriticalContainerError,
 	IFluidCodeDetails,
 	isFluidPackage,
@@ -144,7 +144,7 @@ export interface IConnectionManagerFactoryArgs {
 	/**
 	 * Called whenever new connection to rely service is established
 	 */
-	readonly connectHandler: (connection: IConnectionDetails) => void;
+	readonly connectHandler: (connection: IConnectionDetailsInternal) => void;
 
 	/**
 	 * Called whenever ping/pong messages are roundtripped on connection.

package/src/deltaManager.ts

@@ -18,7 +18,7 @@ import {
 	IDeltaQueue,
 	ICriticalContainerError,
 	IThrottlingWarning,
-	IConnectionDetails,
+	IConnectionDetailsInternal,
 } from "@fluidframework/container-definitions";
 import { assert, TypedEventEmitter } from "@fluidframework/common-utils";
 import { normalizeError, logIfFalse, safeRaiseEvent } from "@fluidframework/telemetry-utils";
@@ -57,6 +57,7 @@ export interface IConnectionArgs {
 export interface IDeltaManagerInternalEvents extends IDeltaManagerEvents {
 	(event: "throttled", listener: (error: IThrottlingWarning) => void);
 	(event: "closed" | "disposed", listener: (error?: ICriticalContainerError) => void);
+	(event: "connect", listener: (details: IConnectionDetailsInternal, opsBehind?: number) => void);
 }
 
 /**
@@ -230,11 +231,14 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		batch = false,
 		metadata?: any,
 		compression?: string,
+		referenceSequenceNumber?: number,
 	) {
+		// Back-compat ADO:3455
+		const backCompatRefSeqNum = referenceSequenceNumber ?? this.lastProcessedSequenceNumber;
 		const messagePartial: Omit<IDocumentMessage, "clientSequenceNumber"> = {
 			contents,
 			metadata,
-			referenceSequenceNumber: this.lastProcessedSequenceNumber,
+			referenceSequenceNumber: backCompatRefSeqNum,
 			type,
 			compression,
 		};
@@ -358,7 +362,8 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 				this.emitDelayInfo(this.deltaStreamDelayId, delayMs, error),
 			closeHandler: (error: any) => this.close(error),
 			disconnectHandler: (reason: string) => this.disconnectHandler(reason),
-			connectHandler: (connection: IConnectionDetails) => this.connectHandler(connection),
+			connectHandler: (connection: IConnectionDetailsInternal) =>
+				this.connectHandler(connection),
 			pongHandler: (latency: number) => this.emit("pong", latency),
 			readonlyChangeHandler: (readonly?: boolean) =>
 				safeRaiseEvent(this, this.logger, "readonly", readonly),
@@ -401,7 +406,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		// - inbound & inboundSignal are resumed in attachOpHandler() when we have handler setup
 	}
 
-	private connectHandler(connection: IConnectionDetails) {
+	private connectHandler(connection: IConnectionDetailsInternal) {
 		this.refreshDelayInfo(this.deltaStreamDelayId);
 
 		const props = this.connectionManager.connectionVerboseProps;

package/src/deltaManagerProxy.ts

@@ -5,20 +5,16 @@
 
 import {
 	IDeltaManager,
-	IDeltaManagerEvents,
 	IDeltaQueue,
-	IDeltaSender,
 	IDeltaQueueEvents,
-	ReadOnlyInfo,
 } from "@fluidframework/container-definitions";
 import { EventForwarder } from "@fluidframework/common-utils";
 import {
-	IClientConfiguration,
-	IClientDetails,
 	IDocumentMessage,
 	ISequencedDocumentMessage,
 	ISignalMessage,
 } from "@fluidframework/protocol-definitions";
+import { DeltaManagerProxyBase } from "@fluidframework/container-utils";
 
 /**
  * Proxy to the real IDeltaQueue - used to restrict access
@@ -78,87 +74,36 @@ export class DeltaQueueProxy<T>
  * Proxy to the real IDeltaManager - used to restrict access
  */
 export class DeltaManagerProxy
-	extends EventForwarder<IDeltaManagerEvents>
+	extends DeltaManagerProxyBase
 	implements IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>
 {
-	public readonly inbound: IDeltaQueue<ISequencedDocumentMessage>;
-	public readonly outbound: IDeltaQueue<IDocumentMessage[]>;
-	public readonly inboundSignal: IDeltaQueue<ISignalMessage>;
-
-	public get IDeltaSender(): IDeltaSender {
-		return this;
-	}
-
-	public get minimumSequenceNumber(): number {
-		return this.deltaManager.minimumSequenceNumber;
-	}
-
-	public get lastSequenceNumber(): number {
-		return this.deltaManager.lastSequenceNumber;
-	}
-
-	public get lastMessage() {
-		return this.deltaManager.lastMessage;
-	}
-
-	public get lastKnownSeqNumber() {
-		return this.deltaManager.lastKnownSeqNumber;
-	}
-
-	public get initialSequenceNumber(): number {
-		return this.deltaManager.initialSequenceNumber;
-	}
-
-	public get hasCheckpointSequenceNumber() {
-		return this.deltaManager.hasCheckpointSequenceNumber;
+	public get inbound(): IDeltaQueue<ISequencedDocumentMessage> {
+		return this._inbound;
 	}
+	private readonly _inbound: IDeltaQueue<ISequencedDocumentMessage>;
 
-	public get clientDetails(): IClientDetails {
-		return this.deltaManager.clientDetails;
+	public get outbound(): IDeltaQueue<IDocumentMessage[]> {
+		return this._outbound;
 	}
+	private readonly _outbound: IDeltaQueue<IDocumentMessage[]>;
 
-	public get version(): string {
-		return this.deltaManager.version;
+	public get inboundSignal(): IDeltaQueue<ISignalMessage> {
+		return this._inboundSignal;
 	}
+	private readonly _inboundSignal: IDeltaQueue<ISignalMessage>;
 
-	public get maxMessageSize(): number {
-		return this.deltaManager.maxMessageSize;
-	}
-
-	public get serviceConfiguration(): IClientConfiguration | undefined {
-		return this.deltaManager.serviceConfiguration;
-	}
-
-	public get active(): boolean {
-		return this.deltaManager.active;
-	}
-
-	public get readOnlyInfo(): ReadOnlyInfo {
-		return this.deltaManager.readOnlyInfo;
-	}
-
-	constructor(
-		private readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
-	) {
+	constructor(deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>) {
 		super(deltaManager);
 
-		this.inbound = new DeltaQueueProxy(deltaManager.inbound);
-		this.outbound = new DeltaQueueProxy(deltaManager.outbound);
-		this.inboundSignal = new DeltaQueueProxy(deltaManager.inboundSignal);
+		this._inbound = new DeltaQueueProxy(deltaManager.inbound);
+		this._outbound = new DeltaQueueProxy(deltaManager.outbound);
+		this._inboundSignal = new DeltaQueueProxy(deltaManager.inboundSignal);
 	}
 
 	public dispose(): void {
-		this.inbound.dispose();
-		this.outbound.dispose();
-		this.inboundSignal.dispose();
+		this._inbound.dispose();
+		this._outbound.dispose();
+		this._inboundSignal.dispose();
 		super.dispose();
 	}
-
-	public submitSignal(content: any): void {
-		return this.deltaManager.submitSignal(content);
-	}
-
-	public flush(): void {
-		return this.deltaManager.flush();
-	}
 }

package/src/index.ts

@@ -5,12 +5,12 @@
 
 export { ConnectionState } from "./connectionState";
 export {
-	Container,
-	IContainerLoadOptions,
 	IContainerConfig,
+	IContainerLoadOptions,
 	IPendingContainerState,
 	waitContainerToCatchUp,
 } from "./container";
+export { ISerializableBlobContents } from "./containerStorageAdapter";
 export {
 	ICodeDetailsLoader,
 	IDetachedBlobStorage,
@@ -19,6 +19,5 @@ export {
 	ILoaderProps,
 	ILoaderServices,
 	Loader,
-	RelativeLoader,
 } from "./loader";
 export { IProtocolHandler, ProtocolHandlerBuilder } from "./protocol";

package/src/loader.ts

@@ -36,15 +36,10 @@ import {
 	IDocumentServiceFactory,
 	IDocumentStorageService,
 	IFluidResolvedUrl,
-	IResolvedUrl,
 	IUrlResolver,
 } from "@fluidframework/driver-definitions";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
-import {
-	ensureFluidResolvedUrl,
-	MultiUrlResolver,
-	MultiDocumentServiceFactory,
-} from "@fluidframework/driver-utils";
+import { ensureFluidResolvedUrl } from "@fluidframework/driver-utils";
 import { Container, IPendingContainerState } from "./container";
 import { IParsedUrl, parseUrl } from "./utils";
 import { pkgVersion } from "./packageVersion";
@@ -58,6 +53,9 @@ function canUseCache(request: IRequest): boolean {
 	return request.headers[LoaderHeader.cache] !== false;
 }
 
+/**
+ * @deprecated - In the next release RelativeLoader will no longer be exported. It is an internal class that should not be used directly.
+ */
 export class RelativeLoader implements ILoader {
 	constructor(
 		private readonly container: Container,
@@ -109,22 +107,6 @@ export class RelativeLoader implements ILoader {
 	}
 }
 
-function createCachedResolver(resolver: IUrlResolver) {
-	const cacheResolver = Object.create(resolver) as IUrlResolver;
-	const resolveCache = new Map<string, Promise<IResolvedUrl | undefined>>();
-	cacheResolver.resolve = async (request: IRequest): Promise<IResolvedUrl | undefined> => {
-		if (!canUseCache(request)) {
-			return resolver.resolve(request);
-		}
-		if (!resolveCache.has(request.url)) {
-			resolveCache.set(request.url, resolver.resolve(request));
-		}
-
-		return resolveCache.get(request.url);
-	};
-	return cacheResolver;
-}
-
 export interface ILoaderOptions extends ILoaderOptions1 {
 	summarizeProtocolTree?: boolean;
 }
@@ -275,6 +257,28 @@ export type IDetachedBlobStorage = Pick<IDocumentStorageService, "createBlob" |
 	getBlobIds(): string[];
 };
 
+/**
+ * With an already-resolved container, we can request a component directly, without loading the container again
+ * @param container - a resolved container
+ * @returns component on the container
+ */
+export async function requestResolvedObjectFromContainer(
+	container: IContainer,
+	headers?: IRequestHeader,
+): Promise<IResponse> {
+	ensureFluidResolvedUrl(container.resolvedUrl);
+	const parsedUrl = parseUrl(container.resolvedUrl.url);
+
+	if (parsedUrl === undefined) {
+		throw new Error(`Invalid URL ${container.resolvedUrl.url}`);
+	}
+
+	return container.request({
+		url: `${parsedUrl.path}${parsedUrl.query}`,
+		headers,
+	});
+}
+
 /**
  * Manages Fluid resource loading
  */
@@ -303,10 +307,8 @@ export class Loader implements IHostLoader {
 		);
 
 		this.services = {
-			urlResolver: createCachedResolver(MultiUrlResolver.create(loaderProps.urlResolver)),
-			documentServiceFactory: MultiDocumentServiceFactory.create(
-				loaderProps.documentServiceFactory,
-			),
+			urlResolver: loaderProps.urlResolver,
+			documentServiceFactory: loaderProps.documentServiceFactory,
 			codeLoader: loaderProps.codeLoader,
 			options: loaderProps.options ?? {},
 			scope,

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-loader";
-export const pkgVersion = "2.0.0-dev.3.1.0.125672";
+export const pkgVersion = "2.0.0-dev.4.1.0.148229";

package/src/protocolTreeDocumentStorageService.ts

@@ -5,13 +5,16 @@
 
 import { IDisposable } from "@fluidframework/common-definitions";
 import { IDocumentStorageService, ISummaryContext } from "@fluidframework/driver-definitions";
-import { combineAppAndProtocolSummary } from "@fluidframework/driver-utils";
 import { ISummaryTree } from "@fluidframework/protocol-definitions";
 
+/**
+ * A storage service wrapper whose sole job is to intercept calls to uploadSummaryWithContext and ensure they include
+ * the protocol summary, using the provided callback to add it if necessary.
+ */
 export class ProtocolTreeStorageService implements IDocumentStorageService, IDisposable {
 	constructor(
 		private readonly internalStorageService: IDocumentStorageService & IDisposable,
-		private readonly generateProtocolTree: () => ISummaryTree,
+		private readonly addProtocolSummaryIfMissing: (summaryTree: ISummaryTree) => ISummaryTree,
 	) {}
 	public get policies() {
 		return this.internalStorageService.policies;
@@ -35,7 +38,7 @@ export class ProtocolTreeStorageService implements IDocumentStorageService, IDis
 		context: ISummaryContext,
 	): Promise<string> {
 		return this.internalStorageService.uploadSummaryWithContext(
-			combineAppAndProtocolSummary(summary, this.generateProtocolTree()),
+			this.addProtocolSummaryIfMissing(summary),
 			context,
 		);
 	}