@fluidframework/container-loader 2.117.0 → 3.0.0

package/src/createAndLoadContainerUtils.ts

@@ -18,7 +18,7 @@ import type {
 } from "@fluidframework/core-interfaces";
 import type { AllOrNone } from "@fluidframework/core-interfaces/internal";
 import { validateAllOrNone } from "@fluidframework/core-utils/internal";
-import type { IClientDetails } from "@fluidframework/driver-definitions";
+import type { IClient, IClientDetails } from "@fluidframework/driver-definitions";
 import type {
 	IDocumentServiceFactory,
 	IResolvedUrl,
@@ -32,6 +32,7 @@ import { getSnapshotTree } from "@fluidframework/driver-utils/internal";
 import {
 	GenericError,
 	UsageError,
+	createChildLogger,
 	normalizeError,
 	createChildMonitoringContext,
 	mixinMonitoringContext,
@@ -50,8 +51,11 @@ import {
 	snapshotHasLoadingGroups,
 	unreferencedAttachmentBlobLocalIds,
 	type IBlobAttachReference,
+	type IGcSnapshotData,
 } from "./captureReferencedContents.js";
-import { DebugLogger } from "./debugLogger.js";
+import { CatchUpMonitor } from "./catchUpMonitor.js";
+import { mixinDebugLogger } from "./debugLogger.js";
+import { createDeltaManager } from "./deltaManagerFactory.js";
 import { createFrozenDocumentServiceFactory } from "./frozenServices.js";
 import { Loader } from "./loader.js";
 import { pkgVersion } from "./packageVersion.js";
@@ -321,19 +325,19 @@ export async function loadExistingContainer(
  * resolver's external URL format is unknown without a real `IUrlResolver`.
  *
  * **Offline form precondition.** With no driver wiring there is no live
- * storage to read attachment blobs from, so any blob the runtime dereferences
- * during load must already be inlined into `pendingLocalState`. The pending
- * state must therefore be produced by {@link captureFullContainerState}
- * (which inlines all referenced attachment blobs) rather than
- * `IContainer.getPendingLocalState` / `getRequiredPendingLocalState` (which
- * do not). If the runtime needs an attachment blob that is not inlined, the
- * load fails with `UsageError` from the synthesized storage service.
+ * storage to read blobs from, so every structural and attachment blob the
+ * runtime dereferences during load must already be inlined into
+ * `pendingLocalState`. The pending state must therefore be produced by
+ * {@link captureFullContainerState} with its default `"inline"` blob capture
+ * mode rather than its `"reference"` mode or
+ * `IContainer.getPendingLocalState` / `getRequiredPendingLocalState`. Missing
+ * blob payloads fail the load with `UsageError`.
  *
  * **URL shape requirement.** In the offline form the captured
  * `pendingLocalState.url` is the only URL available; it is parsed in place of
  * a real `IUrlResolver.resolve()` call, so it must satisfy
  * {@link tryParseCompatibleResolvedUrl}'s contract — a resolved URL of shape
- * `protocol://<string>/.../..?<querystring>`. This is the format that
+ * `protocol://{host}/.../..?{queryString}`. This is the format that
  * Fluid-shipped drivers emit; drivers that emit a non-standard resolved-URL
  * shape will surface as a `UsageError` at load time. The online form has no
  * such constraint because the supplied resolver controls URL parsing.
@@ -418,6 +422,11 @@ export async function loadFrozenContainerFromPendingState(
 		// returns a resolved URL whose `url` equals `pendingLocalState.url`, so the
 		// identity guard in `Loader.resolveCore` is trivially satisfied.
 		const pending = getAttachedContainerStateFromSerializedContainer(pendingLocalState);
+		if (pending.blobContentsMode === "reference") {
+			throw new UsageError(
+				`${fnName}: pending state does not contain inlined snapshot blob contents. Reference-only state captured by ${captureFullContainerState.name} requires online driver wiring.`,
+			);
+		}
 		const parsed = tryParseCompatibleResolvedUrl(pending.url);
 		if (parsed === undefined) {
 			throw new UsageError(
@@ -505,6 +514,18 @@ export interface ICaptureFullContainerStateProps {
 	 * Optional logger for driver-side telemetry.
 	 */
 	readonly logger?: ITelemetryBaseLogger | undefined;
+	/**
+	 * Controls whether blob payloads are included in the captured state.
+	 *
+	 * `"inline"` (the default) includes blob contents, producing self-contained
+	 * state that supports fully offline loading with {@link loadFrozenContainerFromPendingState}.
+	 *
+	 * `"reference"` preserves blob IDs in the snapshot tree but omits their
+	 * payloads. This reduces the captured state size, but loading requires live
+	 * storage through {@link loadExistingContainer} or the online form of
+	 * {@link loadFrozenContainerFromPendingState}.
+	 */
+	readonly blobCaptureMode?: "inline" | "reference" | undefined;
 }
 
 /**
@@ -514,11 +535,19 @@ export interface ICaptureFullContainerStateProps {
  * format produced by a live container's pending-state serialization, and can
  * be handed to {@link loadExistingContainer} as `pendingLocalState`.
  *
- * The output is a self-contained view of the container's referenced graph:
- * the latest snapshot, inlined contents of every blob reachable through
+ * By default, the output is a self-contained view of the container's referenced
+ * graph: the latest snapshot, inlined contents of every blob reachable through
  * referenced subtrees, inlined contents of every referenced attachment blob
  * keyed by storage id, and all ops with sequence numbers after the base
- * snapshot's sequence number (as read from its attributes blob).
+ * snapshot's sequence number through the point observed when the delta stream
+ * connects. The same DeltaManager catch-up path used by container loading
+ * combines delta-storage and delta-stream ops, so recently sequenced ops do
+ * not need to have reached durable delta storage before capture.
+ *
+ * When `blobCaptureMode` is `"reference"`, the snapshot tree retains the blob
+ * IDs needed to load the container, but structural and attachment payloads are
+ * omitted. Reference-only state requires live storage during load and cannot be
+ * used with the fully offline form of {@link loadFrozenContainerFromPendingState}.
  *
  * Reachability respects GC. Snapshot subtrees flagged `unreferenced: true`
  * are skipped (their contents are not inlined). Attachment blobs that GC has
@@ -539,7 +568,8 @@ export interface ICaptureFullContainerStateProps {
  * is a known consumer and end-to-end coverage, the capture refuses rather
  * than silently producing pending state that omits group data.
  *
- * Note: if a new snapshot lands between the snapshot fetch and the ops fetch,
+ * @privateRemarks
+ * Note: if a new snapshot lands between the snapshot fetch and delta catch-up,
  * the returned state may not reflect the very latest snapshot, but remains
  * internally consistent: ops are anchored to the snapshot that was captured.
  *
@@ -556,20 +586,20 @@ export async function captureFullContainerState({
 	documentServiceFactory,
 	request,
 	logger,
+	blobCaptureMode = "inline",
 }: ICaptureFullContainerStateProps): Promise<string> {
 	const resolvedUrl = await urlResolver.resolve(request);
 	if (resolvedUrl === undefined) {
 		throw new UsageError("Failed to resolve request to a Fluid URL");
 	}
 
-	// Validate the resolver's URL shape at capture time. The captured pending
-	// state is rehydrated later (possibly in a different process) via the
-	// offline form of `loadFrozenContainerFromPendingState`, which requires
-	// `tryParseCompatibleResolvedUrl` to succeed on `pendingLocalState.url`.
-	// Failing fast here turns "your captured artifact silently isn't
-	// rehydratable" into a same-call error a partner can act on, instead of
-	// surfacing as a `UsageError` at offline-load time in a different process.
-	if (tryParseCompatibleResolvedUrl(resolvedUrl.url) === undefined) {
+	// Inline state supports the offline form of `loadFrozenContainerFromPendingState`,
+	// which requires `tryParseCompatibleResolvedUrl` to succeed on `pendingLocalState.url`.
+	// Reference-only state always uses the caller's live resolver, so it has no such constraint.
+	if (
+		blobCaptureMode === "inline" &&
+		tryParseCompatibleResolvedUrl(resolvedUrl.url) === undefined
+	) {
 		throw new UsageError(
 			`${captureFullContainerState.name}: resolved URL is not in the shape required by tryParseCompatibleResolvedUrl (protocol://<string>/<tenantId>/<docId>?<querystring>); captured state would not rehydrate offline (${resolvedUrl.url})`,
 		);
@@ -579,6 +609,43 @@ export async function captureFullContainerState({
 		resolvedUrl,
 		logger,
 	);
+	const captureLogger = createChildLogger({ logger, namespace: "captureFullContainerState" });
+	const client: IClient = {
+		details: { capabilities: { interactive: true } },
+		mode: "read",
+		permission: [],
+		scopes: [],
+		user: { id: "" },
+	};
+	const deltaManager = createDeltaManager({
+		serviceProvider: () => documentService,
+		logger: captureLogger,
+		active: () => false,
+		containerDirty: () => false,
+		client,
+		reconnectAllowed: true,
+	});
+	const connectedP = new Promise<void>((resolve) => {
+		deltaManager.once("connect", () => resolve());
+	});
+	const closedP = new Promise<never>((_resolve, reject) => {
+		deltaManager.once("closed", (error) => {
+			reject(
+				error === undefined
+					? new GenericError("DeltaManager closed while capturing container state")
+					: normalizeError(error),
+			);
+		});
+	});
+	deltaManager.connect({
+		reason: { text: "captureFullContainerState" },
+		mode: "read",
+		// Ops will be fetched from storage using the later "attachOpHandler" call. Attempting to fetch here is a no-op anyway as
+		// no op handler is yet attached.
+		// Fetching the snapshot first such that an op handler could be attached using its sequence number information may simplify
+		// the code, but doing it this way allows parallelization of snapshot fetch and establishing a connection.
+		fetchOpsFromStorage: false,
+	});
 	try {
 		const storage = await documentService.connectToStorage();
 
@@ -610,42 +677,46 @@ export async function captureFullContainerState({
 			);
 		}
 		const attributes = await getDocumentAttributes(storage, baseSnapshot);
-		const gcData = await parseGcSnapshotData(baseSnapshot, storage);
+		let gcData: IGcSnapshotData | undefined;
+		let snapshotBlobs = {};
+		let attachmentBlobContents = {};
 		// Structural snapshot blobs (JSON/text the runtime authored) are
 		// UTF-8-encoded; attachment blobs may carry arbitrary binary bytes
 		// and are base64-encoded. Keep them on separate fields of the
 		// pending state so the load side can apply the matching decoder
 		// without ambiguity. See IPendingContainerState.attachmentBlobContents.
-		const [snapshotBlobs, attachmentBlobContents] = await Promise.all([
-			readReferencedSnapshotBlobs(snapshot, storage), // utf8 encoded
-			captureReferencedAttachmentBlobs(baseSnapshot, storage, gcData), // base64 encoded
-		]);
-
-		const deltaStorage = await documentService.connectToDeltaStorage();
-		const opsStream = deltaStorage.fetchMessages(
-			attributes.sequenceNumber + 1,
-			undefined,
-			undefined,
-			false,
-			"captureFullContainerState",
-		);
+		if (blobCaptureMode === "inline") {
+			gcData = await parseGcSnapshotData(baseSnapshot, storage);
+			[snapshotBlobs, attachmentBlobContents] = await Promise.all([
+				readReferencedSnapshotBlobs(snapshot, storage), // utf8 encoded
+				captureReferencedAttachmentBlobs(baseSnapshot, storage, gcData), // base64 encoded
+			]);
+		}
+
 		const savedOps: ISequencedDocumentMessage[] = [];
+		const attachP = deltaManager.attachOpHandler(
+			attributes.minimumSequenceNumber,
+			attributes.sequenceNumber,
+			{
+				process: (message) => savedOps.push(message),
+				processSignal: () => {},
+			},
+			"all",
+		);
+		await Promise.race([Promise.all([connectedP, attachP]), closedP]);
+		await Promise.race([waitForCatchUp(deltaManager), closedP]);
+		deltaManager.dispose();
+
 		const postSnapshotBlobReferences: IBlobAttachReference[] = [];
-		let opsResult = await opsStream.read();
-		while (!opsResult.done) {
-			for (const op of opsResult.value) {
-				savedOps.push(op);
+		if (blobCaptureMode === "inline") {
+			for (const op of savedOps) {
 				// Blobs uploaded after the base snapshot are not in its
 				// `.blobs` redirect table, so `captureReferencedAttachmentBlobs`
 				// did not see them. The wire-format BlobAttach op carries
 				// `(localId, storageId)` in its metadata; collect those here so
 				// we can backfill the bytes before sealing the artifact.
-				const refs = extractBlobAttachReferences(op);
-				if (refs.length > 0) {
-					postSnapshotBlobReferences.push(...refs);
-				}
+				postSnapshotBlobReferences.push(...extractBlobAttachReferences(op));
 			}
-			opsResult = await opsStream.read();
 		}
 
 		if (postSnapshotBlobReferences.length > 0) {
@@ -662,6 +733,7 @@ export async function captureFullContainerState({
 			attached: true,
 			baseSnapshot,
 			snapshotBlobs,
+			blobContentsMode: blobCaptureMode === "reference" ? "reference" : undefined,
 			attachmentBlobContents:
 				Object.keys(attachmentBlobContents).length === 0 ? undefined : attachmentBlobContents,
 			loadedGroupIdSnapshots: undefined,
@@ -671,10 +743,23 @@ export async function captureFullContainerState({
 		};
 		return JSON.stringify(pendingState);
 	} finally {
+		deltaManager.dispose();
 		documentService.dispose();
 	}
 }
 
+async function waitForCatchUp(
+	deltaManager: ReturnType<typeof createDeltaManager>,
+): Promise<void> {
+	await new Promise<void>((resolve) => {
+		const monitor = new CatchUpMonitor(deltaManager, () => {
+			monitor.dispose();
+			resolve();
+		});
+		monitor.start();
+	});
+}
+
 /**
  * Loads a summarizer container with the required headers, triggers an on-demand summary, and then closes it.
  * Returns success/failure and an optional error for host-side handling.
@@ -708,7 +793,7 @@ async function loadSummarizerContainerAndMakeSummaryInternal(
 	};
 
 	const subMc = mixinMonitoringContext(
-		DebugLogger.mixinDebugLogger("fluid:telemetry", logger, {
+		mixinDebugLogger("fluid:telemetry", logger, {
 			all: telemetryProps,
 		}),
 		sessionStorageConfigProvider.value,

package/src/debugLogger.ts

@@ -25,46 +25,8 @@ const { debug: registerDebug } = debugPkg;
 /**
  * Implementation of debug logger
  */
-export class DebugLogger implements ITelemetryBaseLogger {
-	/**
-	 * Mix in debug logger with another logger.
-	 * Returned logger will output events to both newly created debug logger, as well as base logger
-	 * @param namespace - Telemetry event name prefix to add to all events
-	 * @param properties - Base properties to add to all events
-	 * @param propertyGetters - Getters to add additional properties to all events
-	 * @param baseLogger - Base logger to output events (in addition to debug logger being created). Can be undefined.
-	 */
-	public static mixinDebugLogger(
-		namespace: string,
-		baseLogger?: ITelemetryBaseLogger,
-		properties?: ITelemetryLoggerPropertyBags,
-	): TelemetryLoggerExt {
-		// Setup base logger upfront, such that host can disable it (if needed)
-		const debug = registerDebug(namespace);
-
-		// Create one for errors that is always enabled
-		// It can be silenced by replacing console.error if the debug namespace is not enabled.
-		const debugErr = registerDebug(namespace);
-		debugErr.log = function (...args: unknown[]): void {
-			if (debug.enabled === true) {
-				// if the namespace is enabled, just use the default logger
-				registerDebug.log(...args);
-			} else {
-				// other wise, use the console logger (which could be replaced and silenced)
-				console.error(...args);
-			}
-		};
-		debugErr.enabled = true;
-
-		return createMultiSinkLogger({
-			namespace,
-			loggers: [baseLogger, new DebugLogger(debug, debugErr)],
-			properties,
-			tryInheritProperties: true,
-		});
-	}
-
-	private constructor(
+class DebugLogger implements ITelemetryBaseLogger {
+	public constructor(
 		private readonly debug: IDebugger,
 		private readonly debugErr: IDebugger,
 	) {}
@@ -119,3 +81,40 @@ export class DebugLogger implements ITelemetryBaseLogger {
 		logger(`${name} ${payload} ${tick} ${stack}`);
 	}
 }
+
+/**
+ * Mix in debug logger with another logger.
+ * Returned logger will output events to both newly created debug logger, as well as base logger
+ * @param namespace - Telemetry event name prefix to add to all events
+ * @param baseLogger - Base logger to output events (in addition to debug logger being created). Can be undefined.
+ * @param properties - Base properties to add to all events
+ */
+export function mixinDebugLogger(
+	namespace: string,
+	baseLogger?: ITelemetryBaseLogger,
+	properties?: ITelemetryLoggerPropertyBags,
+): TelemetryLoggerExt {
+	// Setup base logger upfront, such that host can disable it (if needed)
+	const debug = registerDebug(namespace);
+
+	// Create one for errors that is always enabled
+	// It can be silenced by replacing console.error if the debug namespace is not enabled.
+	const debugErr = registerDebug(namespace);
+	debugErr.log = function (...args: unknown[]): void {
+		if (debug.enabled === true) {
+			// if the namespace is enabled, just use the default logger
+			registerDebug.log(...args);
+		} else {
+			// other wise, use the console logger (which could be replaced and silenced)
+			console.error(...args);
+		}
+	};
+	debugErr.enabled = true;
+
+	return createMultiSinkLogger({
+		namespace,
+		loggers: [baseLogger, new DebugLogger(debug, debugErr)],
+		properties,
+		tryInheritProperties: true,
+	});
+}

package/src/deltaManager.ts

@@ -16,6 +16,7 @@ import type {
 	ITelemetryBaseEvent,
 	ITelemetryBaseProperties,
 } from "@fluidframework/core-interfaces";
+import { LogLevel } from "@fluidframework/core-interfaces";
 import { JsonParse } from "@fluidframework/core-interfaces/internal";
 import type { IThrottlingWarning, JsonString } from "@fluidframework/core-interfaces/internal";
 import { assert } from "@fluidframework/core-utils/internal";
@@ -143,7 +144,7 @@ function logIfFalse(
 		typeof event === "string"
 			? { eventName: event, category: "error" }
 			: { category: "error", ...event };
-	logger.send(newEvent);
+	logger.send(newEvent, LogLevel.essential);
 	return false;
 }
 
@@ -566,10 +567,22 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 	}
 
 	/**
-	 * Sets the sequence number from which inbound messages should be returned
-	 * @param snapshotSequenceNumber - The sequence number of the snapshot at which the document loaded from.
-	 * @param lastProcessedSequenceNumber - The last processed sequence number, for offline, it should be greater than the sequence number.
-	 * Setting lastProcessedSequenceNumber allows the DeltaManager to skip downloading and processing ops that have already been processed.
+	 * Initializes sequence number tracking, attaches the handler for inbound ops and signals, and
+	 * resumes the inbound queues.
+	 *
+	 * @param minSequenceNumber - The document's current minimum sequence number. This is used for client-side
+	 * protocol validation.
+	 * @param snapshotSequenceNumber - The sequence number of the snapshot from which the document
+	 * was loaded.
+	 * @param handler - The op/signal handler to attach.
+	 * @param prefetchType - Controls how missing ops are fetched before the returned promise resolves:
+	 * `"none"` does not initiate a fetch; `"all"` waits for all available missing ops from storage;
+	 * and `"cached"` waits only for cached ops before continuing the remaining storage fetch in the
+	 * background.
+	 * @param lastProcessedSequenceNumber - The latest sequence number already reflected in the
+	 * loaded state. It defaults to `snapshotSequenceNumber`. Offline loads may provide a later
+	 * sequence number so the DeltaManager skips downloading and processing ops already included in
+	 * that state.
 	 */
 	public async attachOpHandler(
 		minSequenceNumber: number,

package/src/deltaManagerFactory.ts

@@ -0,0 +1,53 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { IClient } from "@fluidframework/driver-definitions";
+import type { IDocumentService } from "@fluidframework/driver-definitions/internal";
+import {
+	createChildLogger,
+	type TelemetryLoggerExt,
+} from "@fluidframework/telemetry-utils/internal";
+
+import { ConnectionManager } from "./connectionManager.js";
+import { DeltaManager } from "./deltaManager.js";
+
+export interface ICreateDeltaManagerProps {
+	readonly serviceProvider: () => IDocumentService | undefined;
+	readonly logger: TelemetryLoggerExt;
+	readonly active: () => boolean;
+	readonly containerDirty: () => boolean;
+	readonly client: IClient;
+	readonly reconnectAllowed: boolean;
+	readonly maxInitialConnectionAttempts?: number;
+}
+
+/**
+ * Creates the DeltaManager and ConnectionManager pair used by container loading.
+ */
+export function createDeltaManager({
+	serviceProvider,
+	logger,
+	active,
+	containerDirty,
+	client,
+	reconnectAllowed,
+	maxInitialConnectionAttempts,
+}: ICreateDeltaManagerProps): DeltaManager<ConnectionManager> {
+	return new DeltaManager<ConnectionManager>(
+		serviceProvider,
+		createChildLogger({ logger, namespace: "DeltaManager" }),
+		active,
+		(props) =>
+			new ConnectionManager(
+				serviceProvider,
+				containerDirty,
+				client,
+				reconnectAllowed,
+				createChildLogger({ logger, namespace: "ConnectionManager" }),
+				props,
+				maxInitialConnectionAttempts,
+			),
+	);
+}

package/src/frozenServices.ts

@@ -171,16 +171,15 @@ const frozenDocumentStorageServiceHandler = (): never => {
 
 /**
  * Distinct from {@link frozenDocumentStorageServiceHandler} because callers
- * that hit this path are almost always exercising a fully-offline frozen load
- * whose pending state was produced by {@link getPendingLocalState} (which omits
- * inlined attachment blobs) rather than {@link captureFullContainerState}. A
- * generic "operation not supported" is technically true but unhelpful; this
- * message names the missing precondition and the API that produces it.
+ * that hit this path are exercising a fully-offline frozen load whose pending
+ * state omits a required structural or attachment blob. A generic "operation
+ * not supported" is technically true but unhelpful; this message names the
+ * missing precondition and the API mode that satisfies it.
  */
 const frozenReadBlobOfflineHandler = async (): Promise<never> => {
 	throw new UsageError(
-		"Attempted to read an attachment blob from a frozen-loaded container without a live storage service. " +
-			"Fully-offline frozen loads must use pending state produced by `captureFullContainerState`, which inlines all referenced attachment blobs.",
+		"Attempted to read a blob from a frozen-loaded container without a live storage service. " +
+			"Fully-offline frozen loads must use pending state produced by `captureFullContainerState` with the default inline blob capture mode.",
 	);
 };
 

package/src/index.ts

@@ -41,6 +41,7 @@ export {
 	loaderCoreCompatDetails,
 	runtimeSupportRequirementsForLoader,
 	loaderCompatDetailsForRuntime,
+	loaderCompatDetailsForDriver,
 } from "./loaderLayerCompatState.js";
 export { loadContainerPaused } from "./loadPaused.js";
 export {

package/src/loadContainerToSequenceNumber.ts

@@ -24,8 +24,9 @@ import {
  * This is distinct from normal container loading. The supplied
  * {@link IContainerDriverServices.documentServiceFactory} must be able to materialize the document
  * at {@link ILoadContainerToSequenceNumberProps.loadToSequenceNumber} - i.e. it must implement the
- * point-in-time capability the loader detects. For ODSP, pass an
- * `IPointInTimeDocumentServiceFactory` created by `getOdspPointInTimeDocumentServiceFactory`.
+ * point-in-time capability the loader detects. For ODSP, call
+ * `createOdspDocumentServiceFactory` with the implementation imported from
+ * `@fluidframework/odsp-driver/legacy/point-in-time`.
  *
  * @legacy @beta
  */
@@ -58,9 +59,9 @@ export interface ILoadContainerToSequenceNumberProps
  * The supplied {@link IContainerDriverServices.documentServiceFactory} must support point-in-time
  * loading: it must be able to serve a snapshot at or before
  * {@link ILoadContainerToSequenceNumberProps.loadToSequenceNumber} and replay the document forward
- * through that sequence number. For ODSP, pass the result of
- * `getOdspPointInTimeDocumentServiceFactory` (from `@fluidframework/odsp-driver`) directly - the
- * loader materializes the point-in-time view itself, so no wrapping or decoration is required.
+ * through that sequence number. For ODSP, inject `createPointInTimeDocumentService` from the
+ * dedicated point-in-time entrypoint through `createOdspDocumentServiceFactory` options. The loader
+ * materializes the point-in-time view itself, so no wrapping or decoration is required.
  *
  * @param props - The load options, point-in-time-capable driver services, target sequence number, and
  * optional cancellation signal.
@@ -81,7 +82,7 @@ export async function loadContainerToSequenceNumber(
 	const capableFactory = asPointInTimeCapableFactory(documentServiceFactory);
 	if (capableFactory === undefined) {
 		throw new UsageError(
-			"The provided documentServiceFactory does not support point-in-time loading. For ODSP, pass the result of getOdspPointInTimeDocumentServiceFactory.",
+			"The provided documentServiceFactory does not support point-in-time loading. For ODSP, call createOdspDocumentServiceFactory with a point-in-time implementation.",
 		);
 	}
 

package/src/loader.ts

@@ -38,7 +38,7 @@ import type { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils/legacy
 import { v4 as uuid } from "uuid";
 
 import { Container } from "./container.js";
-import { DebugLogger } from "./debugLogger.js";
+import { mixinDebugLogger } from "./debugLogger.js";
 import { pkgVersion } from "./packageVersion.js";
 import type { ProtocolHandlerBuilder } from "./protocol.js";
 import type { IPendingContainerState } from "./serializedStateManager.js";
@@ -255,7 +255,7 @@ export class Loader implements IHostLoader {
 		};
 
 		const subMc = mixinMonitoringContext(
-			DebugLogger.mixinDebugLogger("fluid:telemetry", logger, {
+			mixinDebugLogger("fluid:telemetry", logger, {
 				all: telemetryProps,
 			}),
 			sessionStorageConfigProvider.value,