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

package/src/loader.ts

@@ -4,147 +4,107 @@
  */
 
 import { v4 as uuid } from "uuid";
-import { ITelemetryBaseLogger, ITelemetryLogger } from "@fluidframework/common-definitions";
 import {
-    FluidObject,
-    IFluidRouter,
-    IRequest,
-    IRequestHeader,
-    IResponse,
+	ITelemetryLoggerExt,
+	mixinMonitoringContext,
+	MonitoringContext,
+	PerformanceEvent,
+	sessionStorageConfigProvider,
+	createChildMonitoringContext,
+	UsageError,
+} from "@fluidframework/telemetry-utils";
+import {
+	ITelemetryBaseLogger,
+	FluidObject,
+	IRequest,
+	IConfigProviderBase,
 } from "@fluidframework/core-interfaces";
 import {
-    IContainer,
-    IFluidModule,
-    IHostLoader,
-    ILoader,
-    ILoaderOptions as ILoaderOptions1,
-    LoaderHeader,
-    IProvideFluidCodeDetailsComparer,
-    IFluidCodeDetails,
+	IContainer,
+	IFluidModule,
+	IHostLoader,
+	ILoader,
+	ILoaderOptions as ILoaderOptions1,
+	LoaderHeader,
+	IProvideFluidCodeDetailsComparer,
+	IFluidCodeDetails,
 } from "@fluidframework/container-definitions";
 import {
-    ChildLogger,
-    DebugLogger,
-    IConfigProviderBase,
-    loggerToMonitoringContext,
-    mixinMonitoringContext,
-    MonitoringContext,
-    PerformanceEvent,
-    sessionStorageConfigProvider,
-} from "@fluidframework/telemetry-utils";
-import {
-    IDocumentServiceFactory,
-    IDocumentStorageService,
-    IFluidResolvedUrl,
-    IResolvedUrl,
-    IUrlResolver,
+	IDocumentServiceFactory,
+	IDocumentStorageService,
+	IResolvedUrl,
+	IUrlResolver,
 } from "@fluidframework/driver-definitions";
-import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
-import {
-    ensureFluidResolvedUrl,
-    MultiUrlResolver,
-    MultiDocumentServiceFactory,
-} from "@fluidframework/driver-utils";
+import { IClientDetails } from "@fluidframework/protocol-definitions";
 import { Container, IPendingContainerState } from "./container";
-import { IParsedUrl, parseUrl } from "./utils";
+import { IParsedUrl, tryParseCompatibleResolvedUrl } from "./utils";
 import { pkgVersion } from "./packageVersion";
-
-function canUseCache(request: IRequest): boolean {
-    if (request.headers === undefined) {
-        return true;
-    }
-
-    return request.headers[LoaderHeader.cache] !== false;
+import { ProtocolHandlerBuilder } from "./protocol";
+import { DebugLogger } from "./debugLogger";
+
+function ensureResolvedUrlDefined(
+	resolved: IResolvedUrl | undefined,
+): asserts resolved is IResolvedUrl {
+	if (resolved === undefined) {
+		throw new Error(`Object is not a IResolveUrl.`);
+	}
 }
-
+/**
+ * @internal
+ */
 export class RelativeLoader implements ILoader {
-    constructor(
-        private readonly container: Container,
-        private readonly loader: ILoader | undefined,
-    ) {
-    }
-
-    public get IFluidRouter(): IFluidRouter { return this; }
-
-    public async resolve(request: IRequest): Promise<IContainer> {
-        if (request.url.startsWith("/")) {
-            if (canUseCache(request)) {
-                return this.container;
-            } else {
-                const resolvedUrl = this.container.resolvedUrl;
-                ensureFluidResolvedUrl(resolvedUrl);
-                const container = await Container.load(
-                    this.loader as Loader,
-                    {
-                        canReconnect: request.headers?.[LoaderHeader.reconnect],
-                        clientDetailsOverride: request.headers?.[LoaderHeader.clientDetails],
-                        resolvedUrl: { ...resolvedUrl },
-                        version: request.headers?.[LoaderHeader.version] ?? undefined,
-                        loadMode: request.headers?.[LoaderHeader.loadMode],
-                    },
-                );
-                return container;
-            }
-        }
-
-        if (this.loader === undefined) {
-            throw new Error("Cannot resolve external containers");
-        }
-        return this.loader.resolve(request);
-    }
-
-    public async request(request: IRequest): Promise<IResponse> {
-        if (request.url.startsWith("/")) {
-            const container = await this.resolve(request);
-            return container.request(request);
-        }
-
-        if (this.loader === undefined) {
-            return {
-                status: 404,
-                value: "Cannot request external containers",
-                mimeType: "plain/text",
-            };
-        }
-        return this.loader.request(request);
-    }
-}
-
-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;
+	constructor(
+		private readonly container: Container,
+		private readonly loader: ILoader | undefined,
+	) {}
+
+	public async resolve(request: IRequest): Promise<IContainer> {
+		if (request.url.startsWith("/")) {
+			ensureResolvedUrlDefined(this.container.resolvedUrl);
+			const container = await this.container.clone(
+				{
+					resolvedUrl: { ...this.container.resolvedUrl },
+					version: request.headers?.[LoaderHeader.version] ?? undefined,
+					loadMode: request.headers?.[LoaderHeader.loadMode],
+				},
+				{
+					canReconnect: request.headers?.[LoaderHeader.reconnect],
+					clientDetailsOverride: request.headers?.[LoaderHeader.clientDetails],
+				},
+			);
+			return container;
+		}
+
+		if (this.loader === undefined) {
+			throw new Error("Cannot resolve external containers");
+		}
+		return this.loader.resolve(request);
+	}
 }
 
+/**
+ * @alpha
+ */
 export interface ILoaderOptions extends ILoaderOptions1 {
-    summarizeProtocolTree?: boolean;
+	summarizeProtocolTree?: boolean;
 }
 
 /**
  * @deprecated IFluidModuleWithDetails interface is moved to
- * {@link @fluidframework/container-definition#IFluidModuleWithDetails}
+ * {@link @fluidframework/container-definitions#IFluidModuleWithDetails}
  * to have all the code loading modules in one package. #8193
  * Encapsulates a module entry point with corresponding code details.
+ * @alpha
  */
 export interface IFluidModuleWithDetails {
-    /** Fluid code module that implements the runtime factory needed to instantiate the container runtime. */
-    module: IFluidModule;
-    /**
-     * Code details associated with the module. Represents a document schema this module supports.
-     * If the code loader implements the {@link @fluidframework/core-interfaces#IFluidCodeDetailsComparer} interface,
-     * it'll be called to determine whether the module code details satisfy the new code proposal in the quorum.
-     */
-    details: IFluidCodeDetails;
+	/** Fluid code module that implements the runtime factory needed to instantiate the container runtime. */
+	module: IFluidModule;
+	/**
+	 * Code details associated with the module. Represents a document schema this module supports.
+	 * If the code loader implements the {@link @fluidframework/core-interfaces#IFluidCodeDetailsComparer} interface,
+	 * it'll be called to determine whether the module code details satisfy the new code proposal in the quorum.
+	 */
+	details: IFluidCodeDetails;
 }
 
 /**
@@ -152,336 +112,305 @@ export interface IFluidModuleWithDetails {
  * to have code loading modules in one package. #8193
  * Fluid code loader resolves a code module matching the document schema, i.e. code details, such as
  * a package name and package version range.
+ * @alpha
  */
-export interface ICodeDetailsLoader
- extends Partial<IProvideFluidCodeDetailsComparer> {
- /**
-  * 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.
-  */
- load(source: IFluidCodeDetails): Promise<IFluidModuleWithDetails>;
+export interface ICodeDetailsLoader extends Partial<IProvideFluidCodeDetailsComparer> {
+	/**
+	 * 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.
+	 */
+	load(source: IFluidCodeDetails): Promise<IFluidModuleWithDetails>;
 }
 
 /**
  * Services and properties necessary for creating a loader
+ * @alpha
  */
 export interface ILoaderProps {
-    /**
-     * The url resolver used by the loader for resolving external urls
-     * into Fluid urls such that the container specified by the
-     * external url can be loaded.
-     */
-    readonly urlResolver: IUrlResolver;
-    /**
-     * The document service factory take the Fluid url provided
-     * by the resolved url and constructs all the necessary services
-     * for communication with the container's server.
-     */
-    readonly documentServiceFactory: IDocumentServiceFactory;
-    /**
-     * The code loader handles loading the necessary code
-     * for running a container once it is loaded.
-     */
-    readonly codeLoader: ICodeDetailsLoader;
-
-    /**
-     * A property bag of options used by various layers
-     * to control features
-     */
-    readonly options?: ILoaderOptions;
-
-    /**
-     * Scope is provided to all container and is a set of shared
-     * services for container's to integrate with their host environment.
-     */
-    readonly scope?: FluidObject;
-
-    /**
-     * The logger that all telemetry should be pushed to.
-     */
-    readonly logger?: ITelemetryBaseLogger;
-
-    /**
-     * Blobs storage for detached containers.
-     */
-    readonly detachedBlobStorage?: IDetachedBlobStorage;
-
-    /**
-     * The configuration provider which may be used to control features.
-     */
-     readonly configProvider?: IConfigProviderBase;
+	/**
+	 * The url resolver used by the loader for resolving external urls
+	 * into Fluid urls such that the container specified by the
+	 * external url can be loaded.
+	 */
+	readonly urlResolver: IUrlResolver;
+	/**
+	 * The document service factory take the Fluid url provided
+	 * by the resolved url and constructs all the necessary services
+	 * for communication with the container's server.
+	 */
+	readonly documentServiceFactory: IDocumentServiceFactory;
+	/**
+	 * The code loader handles loading the necessary code
+	 * for running a container once it is loaded.
+	 */
+	readonly codeLoader: ICodeDetailsLoader;
+
+	/**
+	 * A property bag of options used by various layers
+	 * to control features
+	 */
+	readonly options?: ILoaderOptions;
+
+	/**
+	 * Scope is provided to all container and is a set of shared
+	 * services for container's to integrate with their host environment.
+	 */
+	readonly scope?: FluidObject;
+
+	/**
+	 * The logger that all telemetry should be pushed to.
+	 */
+	readonly logger?: ITelemetryBaseLogger;
+
+	/**
+	 * Blobs storage for detached containers.
+	 */
+	readonly detachedBlobStorage?: IDetachedBlobStorage;
+
+	/**
+	 * The configuration provider which may be used to control features.
+	 */
+	readonly configProvider?: IConfigProviderBase;
+
+	/**
+	 * Optional property for allowing the container to use a custom
+	 * protocol implementation for handling the quorum and/or the audience.
+	 */
+	readonly protocolHandlerBuilder?: ProtocolHandlerBuilder;
 }
 
 /**
  * Services and properties used by and exposed by the loader
+ * @alpha
  */
 export interface ILoaderServices {
-    /**
-     * The url resolver used by the loader for resolving external urls
-     * into Fluid urls such that the container specified by the
-     * external url can be loaded.
-     */
-    readonly urlResolver: IUrlResolver;
-    /**
-     * The document service factory take the Fluid url provided
-     * by the resolved url and constructs all the necessary services
-     * for communication with the container's server.
-     */
-    readonly documentServiceFactory: IDocumentServiceFactory;
-    /**
-     * The code loader handles loading the necessary code
-     * for running a container once it is loaded.
-     */
-    readonly codeLoader: ICodeDetailsLoader;
-
-    /**
-     * A property bag of options used by various layers
-     * to control features
-     */
-    readonly options: ILoaderOptions;
-
-    /**
-     * Scope is provided to all container and is a set of shared
-     * services for container's to integrate with their host environment.
-     */
-    readonly scope: FluidObject;
-
-    /**
-     * The logger downstream consumers should construct their loggers from
-     */
-    readonly subLogger: ITelemetryLogger;
-
-    /**
-     * Blobs storage for detached containers.
-     */
-    readonly detachedBlobStorage?: IDetachedBlobStorage;
+	/**
+	 * The url resolver used by the loader for resolving external urls
+	 * into Fluid urls such that the container specified by the
+	 * external url can be loaded.
+	 */
+	readonly urlResolver: IUrlResolver;
+	/**
+	 * The document service factory take the Fluid url provided
+	 * by the resolved url and constructs all the necessary services
+	 * for communication with the container's server.
+	 */
+	readonly documentServiceFactory: IDocumentServiceFactory;
+	/**
+	 * The code loader handles loading the necessary code
+	 * for running a container once it is loaded.
+	 */
+	readonly codeLoader: ICodeDetailsLoader;
+
+	/**
+	 * A property bag of options used by various layers
+	 * to control features
+	 */
+	readonly options: ILoaderOptions;
+
+	/**
+	 * Scope is provided to all container and is a set of shared
+	 * services for container's to integrate with their host environment.
+	 */
+	readonly scope: FluidObject;
+
+	/**
+	 * The logger downstream consumers should construct their loggers from
+	 */
+	readonly subLogger: ITelemetryLoggerExt;
+
+	/**
+	 * Blobs storage for detached containers.
+	 */
+	readonly detachedBlobStorage?: IDetachedBlobStorage;
+
+	/**
+	 * Optional property for allowing the container to use a custom
+	 * protocol implementation for handling the quorum and/or the audience.
+	 */
+	readonly protocolHandlerBuilder?: ProtocolHandlerBuilder;
 }
 
 /**
  * Subset of IDocumentStorageService which only supports createBlob() and readBlob(). This is used to support
  * blobs in detached containers.
+ * @alpha
  */
 export type IDetachedBlobStorage = Pick<IDocumentStorageService, "createBlob" | "readBlob"> & {
-    size: number;
-    /**
-     * Return an array of all blob IDs present in storage
-     */
-    getBlobIds(): string[];
- };
+	size: number;
+	/**
+	 * Return an array of all blob IDs present in storage
+	 */
+	getBlobIds(): string[];
+};
 
 /**
  * Manages Fluid resource loading
+ * @alpha
  */
 export class Loader implements IHostLoader {
-    private readonly containers = new Map<string, Promise<Container>>();
-    public readonly services: ILoaderServices;
-    private readonly mc: MonitoringContext;
-
-    constructor(loaderProps: ILoaderProps) {
-        const scope: FluidObject<ILoader> = { ...loaderProps.scope };
-        if (loaderProps.options?.provideScopeLoader !== false) {
-            scope.ILoader = this;
-        }
-        const telemetryProps = {
-            loaderId: uuid(),
-            loaderVersion: pkgVersion,
-        };
-
-        const subMc = mixinMonitoringContext(
-            DebugLogger.mixinDebugLogger("fluid:telemetry", loaderProps.logger, { all: telemetryProps }),
-            sessionStorageConfigProvider.value,
-            loaderProps.configProvider,
-        );
-
-        this.services = {
-            urlResolver: createCachedResolver(MultiUrlResolver.create(loaderProps.urlResolver)),
-            documentServiceFactory: MultiDocumentServiceFactory.create(loaderProps.documentServiceFactory),
-            codeLoader: loaderProps.codeLoader,
-            options: loaderProps.options ?? {},
-            scope,
-            subLogger: subMc.logger,
-            detachedBlobStorage: loaderProps.detachedBlobStorage,
-        };
-        this.mc = loggerToMonitoringContext(
-            ChildLogger.create(this.services.subLogger, "Loader"));
-    }
-
-    public get IFluidRouter(): IFluidRouter { return this; }
-
-    public async createDetachedContainer(codeDetails: IFluidCodeDetails): Promise<IContainer> {
-        const container = await Container.createDetached(
-            this,
-            codeDetails,
-        );
-
-        if (this.cachingEnabled) {
-            container.once("attached", () => {
-                ensureFluidResolvedUrl(container.resolvedUrl);
-                const parsedUrl = parseUrl(container.resolvedUrl.url);
-                if (parsedUrl !== undefined) {
-                    this.addToContainerCache(parsedUrl.id, Promise.resolve(container));
-                }
-            });
-        }
-
-        return container;
-    }
-
-    public async rehydrateDetachedContainerFromSnapshot(snapshot: string): Promise<IContainer> {
-        return Container.rehydrateDetachedFromSnapshot(this, snapshot);
-    }
-
-    public async resolve(request: IRequest, pendingLocalState?: string): Promise<IContainer> {
-        const eventName = pendingLocalState === undefined ? "Resolve" : "ResolveWithPendingState";
-        return PerformanceEvent.timedExecAsync(this.mc.logger, { eventName }, async () => {
-            const resolved = await this.resolveCore(
-                request,
-                pendingLocalState !== undefined ? JSON.parse(pendingLocalState) : undefined,
-            );
-            return resolved.container;
-        });
-    }
-
-    public async request(request: IRequest): Promise<IResponse> {
-        return PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Request" }, async () => {
-            const resolved = await this.resolveCore(request);
-            return resolved.container.request({
-                ...request,
-                url: `${resolved.parsed.path}${resolved.parsed.query}`,
-            });
-        });
-    }
-
-    private getKeyForContainerCache(request: IRequest, parsedUrl: IParsedUrl): string {
-        const key = request.headers?.[LoaderHeader.version] !== undefined
-            ? `${parsedUrl.id}@${request.headers[LoaderHeader.version]}`
-            : parsedUrl.id;
-        return key;
-    }
-
-    private addToContainerCache(key: string, containerP: Promise<Container>) {
-        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) {
-                this.containers.delete(key);
-            } else {
-                container.once("closed", () => {
-                    this.containers.delete(key);
-                });
-            }
-        }).catch((error) => {});
-    }
-
-    private async resolveCore(
-        request: IRequest,
-        pendingLocalState?: IPendingContainerState,
-    ): Promise<{ container: Container; parsed: IParsedUrl; }> {
-        const resolvedAsFluid = await this.services.urlResolver.resolve(request);
-        ensureFluidResolvedUrl(resolvedAsFluid);
-
-        // Parse URL into data stores
-        const parsed = parseUrl(resolvedAsFluid.url);
-        if (parsed === undefined) {
-            throw new Error(`Invalid URL ${resolvedAsFluid.url}`);
-        }
-
-        if (pendingLocalState !== undefined) {
-            const parsedPendingUrl = parseUrl(pendingLocalState.url);
-            if (parsedPendingUrl?.id !== parsed.id ||
-                parsedPendingUrl?.path.replace(/\/$/, "") !== parsed.path.replace(/\/$/, "")) {
-                const message = `URL ${resolvedAsFluid.url} does not match pending state URL ${pendingLocalState.url}`;
-                throw new Error(message);
-            }
-        }
-
-        const { canCache, fromSequenceNumber } = this.parseHeader(parsed, request);
-        const shouldCache = pendingLocalState !== undefined ? false : canCache;
-
-        let container: Container;
-        if (shouldCache) {
-            const key = this.getKeyForContainerCache(request, parsed);
-            const maybeContainer = await this.containers.get(key);
-            if (maybeContainer !== undefined) {
-                container = maybeContainer;
-            } else {
-                const containerP =
-                    this.loadContainer(
-                        request,
-                        resolvedAsFluid);
-                this.addToContainerCache(key, containerP);
-                container = await containerP;
-            }
-        } else {
-            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;
-    }
-
-    private canCacheForRequest(headers: IRequestHeader): boolean {
-        return this.cachingEnabled && headers[LoaderHeader.cache] !== false;
-    }
-
-    private parseHeader(parsed: IParsedUrl, request: IRequest) {
-        let fromSequenceNumber = -1;
-
-        request.headers = request.headers ?? {};
-
-        const headerSeqNum = request.headers[LoaderHeader.sequenceNumber];
-        if (headerSeqNum !== undefined) {
-            fromSequenceNumber = headerSeqNum;
-        }
-
-        // If set in both query string and headers, use query string
-        request.headers[LoaderHeader.version] = parsed.version ?? request.headers[LoaderHeader.version];
-
-        const canCache = this.canCacheForRequest(request.headers);
-
-        return {
-            canCache,
-            fromSequenceNumber,
-        };
-    }
-
-    private async loadContainer(
-        request: IRequest,
-        resolved: IFluidResolvedUrl,
-        pendingLocalState?: IPendingContainerState,
-    ): Promise<Container> {
-        return Container.load(
-            this,
-            {
-                canReconnect: request.headers?.[LoaderHeader.reconnect],
-                clientDetailsOverride: request.headers?.[LoaderHeader.clientDetails],
-                resolvedUrl: resolved,
-                version: request.headers?.[LoaderHeader.version] ?? undefined,
-                loadMode: request.headers?.[LoaderHeader.loadMode],
-            },
-            pendingLocalState,
-        );
-    }
+	public readonly services: ILoaderServices;
+	private readonly mc: MonitoringContext;
+
+	constructor(loaderProps: ILoaderProps) {
+		const {
+			urlResolver,
+			documentServiceFactory,
+			codeLoader,
+			options,
+			scope,
+			logger,
+			detachedBlobStorage,
+			configProvider,
+			protocolHandlerBuilder,
+		} = loaderProps;
+
+		const telemetryProps = {
+			loaderId: uuid(),
+			loaderVersion: pkgVersion,
+		};
+
+		const subMc = mixinMonitoringContext(
+			DebugLogger.mixinDebugLogger("fluid:telemetry", logger, {
+				all: telemetryProps,
+			}),
+			sessionStorageConfigProvider.value,
+			configProvider,
+		);
+
+		this.services = {
+			urlResolver,
+			documentServiceFactory,
+			codeLoader,
+			options: options ?? {},
+			scope:
+				options?.provideScopeLoader !== false ? { ...scope, ILoader: this } : { ...scope },
+			detachedBlobStorage,
+			protocolHandlerBuilder,
+			subLogger: subMc.logger,
+		};
+		this.mc = createChildMonitoringContext({
+			logger: this.services.subLogger,
+			namespace: "Loader",
+		});
+	}
+
+	public async createDetachedContainer(
+		codeDetails: IFluidCodeDetails,
+		createDetachedProps?: {
+			canReconnect?: boolean;
+			clientDetailsOverride?: IClientDetails;
+		},
+	): Promise<IContainer> {
+		return Container.createDetached(
+			{
+				...createDetachedProps,
+				...this.services,
+			},
+			codeDetails,
+		);
+	}
+
+	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> {
+		const eventName = pendingLocalState === undefined ? "Resolve" : "ResolveWithPendingState";
+		return PerformanceEvent.timedExecAsync(this.mc.logger, { eventName }, async () => {
+			const resolved = await this.resolveCore(
+				request,
+				pendingLocalState !== undefined ? JSON.parse(pendingLocalState) : undefined,
+			);
+			return resolved.container;
+		});
+	}
+
+	private async resolveCore(
+		request: IRequest,
+		pendingLocalState?: IPendingContainerState,
+	): Promise<{ container: Container; parsed: IParsedUrl }> {
+		const resolvedAsFluid = await this.services.urlResolver.resolve(request);
+		ensureResolvedUrlDefined(resolvedAsFluid);
+
+		// Parse URL into data stores
+		const parsed = tryParseCompatibleResolvedUrl(resolvedAsFluid.url);
+		if (parsed === undefined) {
+			throw new Error(`Invalid URL ${resolvedAsFluid.url}`);
+		}
+
+		if (pendingLocalState !== undefined) {
+			const parsedPendingUrl = tryParseCompatibleResolvedUrl(pendingLocalState.url);
+			if (
+				parsedPendingUrl?.id !== parsed.id ||
+				parsedPendingUrl?.path.replace(/\/$/, "") !== parsed.path.replace(/\/$/, "")
+			) {
+				const message = `URL ${resolvedAsFluid.url} does not match pending state URL ${pendingLocalState.url}`;
+				throw new Error(message);
+			}
+		}
+
+		request.headers ??= {};
+		// 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 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"');
+		}
+
+		return {
+			container: await this.loadContainer(request, resolvedAsFluid, pendingLocalState),
+			parsed,
+		};
+	}
+
+	private async loadContainer(
+		request: IRequest,
+		resolvedUrl: IResolvedUrl,
+		pendingLocalState?: IPendingContainerState,
+	): Promise<Container> {
+		return Container.load(
+			{
+				resolvedUrl,
+				version: request.headers?.[LoaderHeader.version] ?? undefined,
+				loadMode: request.headers?.[LoaderHeader.loadMode],
+				pendingLocalState,
+				loadToSequenceNumber: request.headers?.[LoaderHeader.sequenceNumber],
+			},
+			{
+				canReconnect: request.headers?.[LoaderHeader.reconnect],
+				clientDetailsOverride: request.headers?.[LoaderHeader.clientDetails],
+				...this.services,
+			},
+		);
+	}
 }