@fluidframework/odsp-driver 2.117.0 → 3.0.0

package/src/index.ts

@@ -27,15 +27,16 @@ export { prefetchLatestSnapshot } from "./prefetchLatestSnapshot.js";
 // Factory
 export {
 	createLocalOdspDocumentServiceFactory,
+	createOdspDocumentServiceFactory,
+	type IOdspDocumentServiceFactoryOptions,
 	OdspDocumentServiceFactory,
 } from "./odspDocumentServiceFactory.js";
-export { OdspDocumentServiceFactoryCore } from "./odspDocumentServiceFactoryCore.js";
-/* eslint-disable import-x/no-internal-modules */
 export {
-	getOdspPointInTimeDocumentServiceFactory,
+	type IOdspPointInTimeDocumentServiceImplementationProps,
 	type IPointInTimeDocumentServiceFactory,
-} from "./pointInTimeDriver/odspPointInTimeDocumentServiceFactory.js";
-/* eslint-enable import-x/no-internal-modules */
+	type OdspPointInTimeDocumentServiceImplementation,
+	OdspDocumentServiceFactoryCore,
+} from "./odspDocumentServiceFactoryCore.js";
 
 // File creation
 export { createOdspCreateContainerRequest } from "./createOdspCreateContainerRequest.js";
@@ -75,4 +76,7 @@ export {
 } from "./compactSnapshotParser.js";
 
 // Layer Compat details
-export { odspDriverCompatDetailsForLoader } from "./odspLayerCompatState.js";
+export {
+	odspDriverCompatDetailsForLoader,
+	odspDriverCompatRequirementsForLoader,
+} from "./odspLayerCompatState.js";

package/src/odspDocumentServiceFactory.ts

@@ -15,7 +15,35 @@ import type {
 
 // eslint-disable-next-line import-x/no-internal-modules
 import { LocalOdspDocumentServiceFactory } from "./localOdspDriver/localOdspDocumentServiceFactory.js";
-import { OdspDocumentServiceFactoryCore } from "./odspDocumentServiceFactoryCore.js";
+import {
+	type IPointInTimeDocumentServiceFactory,
+	type OdspPointInTimeDocumentServiceImplementation,
+	OdspDocumentServiceFactoryCore,
+} from "./odspDocumentServiceFactoryCore.js";
+import { LocalPersistentCache } from "./odspCache.js";
+
+/**
+ * Options for creating an ODSP document service factory.
+ *
+ * @legacy @beta
+ */
+export interface IOdspDocumentServiceFactoryOptions {
+	/** Fetches storage access tokens. */
+	readonly getStorageToken: TokenFetcher<OdspResourceTokenFetchOptions>;
+	/** Fetches websocket access tokens, or `undefined` when unavailable. */
+	readonly getWebsocketToken: TokenFetcher<OdspResourceTokenFetchOptions> | undefined;
+	/** Persisted ODSP cache. When omitted, a local in-memory cache is used. */
+	readonly persistedCache?: IPersistedCache | undefined;
+	/** Host storage policy. When omitted, the default driver policies are used. */
+	readonly hostPolicy?: HostStoragePolicy | undefined;
+	/**
+	 * Enables point-in-time loading. Consumers that omit this implementation do not include the
+	 * feature code in their dependency graph.
+	 */
+	readonly pointInTimeDocumentServiceImplementation?:
+		| OdspPointInTimeDocumentServiceImplementation
+		| undefined;
+}
 
 /**
  * Factory for creating the sharepoint document service. Use this if you want to
@@ -34,6 +62,46 @@ export class OdspDocumentServiceFactory extends OdspDocumentServiceFactoryCore {
 	}
 }
 
+/**
+ * Creates an ODSP document service factory with optional consumer-provided features.
+ *
+ * @param options - Tokens, cache, host policy, and optional feature implementations.
+ * @returns The configured ODSP document service factory.
+ *
+ * @legacy @beta
+ */
+export function createOdspDocumentServiceFactory(
+	options: IOdspDocumentServiceFactoryOptions,
+): OdspDocumentServiceFactory {
+	const persistedCache = options.persistedCache ?? new LocalPersistentCache();
+	const pointInTimeImplementation = options.pointInTimeDocumentServiceImplementation;
+
+	class ConfiguredOdspDocumentServiceFactory extends OdspDocumentServiceFactory {
+		public override readonly createPointInTimeDocumentService:
+			| IPointInTimeDocumentServiceFactory["createPointInTimeDocumentService"]
+			| undefined =
+			pointInTimeImplementation === undefined
+				? undefined
+				: async (resolvedUrl, targetSequenceNumber, logger, clientIsSummarizer) =>
+						pointInTimeImplementation({
+							resolvedUrl,
+							targetSequenceNumber,
+							logger,
+							clientIsSummarizer,
+							persistedCache,
+							getStorageToken: options.getStorageToken,
+							createDocumentService: async (url, odspLogger, cacheAndTracker, isSummarizer) =>
+								this.createDocumentServiceCore(url, odspLogger, cacheAndTracker, isSummarizer),
+						});
+	}
+
+	return new ConfiguredOdspDocumentServiceFactory(
+		options.getStorageToken,
+		options.getWebsocketToken,
+		persistedCache,
+		options.hostPolicy,
+	);
+}
 /**
  * Creates a factory instance for creating a sharepoint document service from a provided snapshot.
  *

package/src/odspDocumentServiceFactoryCore.ts

@@ -41,7 +41,10 @@ import {
 	NonPersistentCache,
 } from "./odspCache.js";
 import { OdspDocumentService } from "./odspDocumentService.js";
-import { odspDriverCompatDetailsForLoader } from "./odspLayerCompatState.js";
+import {
+	odspDriverCompatDetailsForLoader,
+	odspDriverCompatRequirementsForLoader,
+} from "./odspLayerCompatState.js";
 import {
 	type IExistingFileInfo,
 	type INewFileInfo,
@@ -53,12 +56,83 @@ import {
 	toInstrumentedOdspTokenFetcher,
 } from "./odspUtils.js";
 
+/**
+ * An ODSP document service factory that supports point-in-time (sequence-number-based) loading.
+ *
+ * @remarks
+ * The loader detects this capability structurally, so hosts can pass this factory directly to
+ * {@link @fluidframework/container-loader#loadContainerToSequenceNumber}.
+ *
+ * @legacy @beta
+ */
+export interface IPointInTimeDocumentServiceFactory extends IDocumentServiceFactory {
+	/**
+	 * Creates a document service that materializes the document at the requested sequence number.
+	 *
+	 * @param resolvedUrl - The resolved ODSP {@link @fluidframework/driver-definitions#IResolvedUrl}.
+	 * @param targetSequenceNumber - The sequence number at which to materialize the document. See
+	 * {@link @fluidframework/container-loader#ILoadContainerToSequenceNumberProps.loadToSequenceNumber}.
+	 * @param logger - Optional {@link @fluidframework/core-interfaces#ITelemetryBaseLogger}.
+	 * @param clientIsSummarizer - Whether to apply summarizer policies and telemetry to the
+	 * underlying document services. Defaults to `false`.
+	 * @returns A read-only {@link @fluidframework/driver-definitions#IDocumentService} materialized
+	 * at the requested sequence number.
+	 */
+	createPointInTimeDocumentService(
+		resolvedUrl: IResolvedUrl,
+		targetSequenceNumber: number,
+		logger?: ITelemetryBaseLogger,
+		clientIsSummarizer?: boolean,
+	): Promise<IDocumentService>;
+}
+
+/**
+ * Inputs supplied by the ODSP document service factory to an injected point-in-time implementation.
+ *
+ * @legacy @beta
+ */
+export interface IOdspPointInTimeDocumentServiceImplementationProps {
+	/** The resolved ODSP URL for the document to materialize. */
+	readonly resolvedUrl: IResolvedUrl;
+	/** The sequence number at which to materialize the document. */
+	readonly targetSequenceNumber: number;
+	/** Optional telemetry logger for the point-in-time load. */
+	readonly logger?: ITelemetryBaseLogger;
+	/** Whether to apply summarizer policies and telemetry. Defaults to `false`. */
+	readonly clientIsSummarizer?: boolean;
+	/** The persisted ODSP cache supplied to the document service factory. */
+	readonly persistedCache: IPersistedCache;
+	/** Fetches storage access tokens for ODSP requests. */
+	readonly getStorageToken: TokenFetcher<OdspResourceTokenFetchOptions>;
+	/**
+	 * Creates an ODSP document service for a resolved URL.
+	 *
+	 * @param resolvedUrl - The resolved URL for the document or file version to load.
+	 * @param logger - The telemetry logger for the document service.
+	 * @param cacheAndTracker - The cache and epoch tracker shared by the point-in-time load.
+	 * @param clientIsSummarizer - Whether to apply summarizer policies and telemetry.
+	 * @returns The document service for the resolved URL.
+	 */
+	readonly createDocumentService: (
+		resolvedUrl: IResolvedUrl,
+		logger: ITelemetryBaseLogger,
+		cacheAndTracker: ICacheAndTracker,
+		clientIsSummarizer?: boolean,
+	) => Promise<IDocumentService>;
+}
+
+/**
+ * Consumer-provided implementation of ODSP point-in-time loading.
+ *
+ * @legacy @beta
+ */
+export type OdspPointInTimeDocumentServiceImplementation = (
+	props: IOdspPointInTimeDocumentServiceImplementationProps,
+) => Promise<IDocumentService>;
+
 /**
  * Factory for creating the sharepoint document service. Use this if you want to
  * use the sharepoint implementation.
- *
- * This constructor should be used by environments that support dynamic imports and that wish
- * to leverage code splitting as a means to keep bundles as small as possible.
  * @legacy
  * @beta
  */
@@ -256,6 +330,17 @@ export class OdspDocumentServiceFactoryCore
 	 */
 	public readonly ILayerCompatDetails?: unknown = odspDriverCompatDetailsForLoader;
 
+	/**
+	 * The requirements that the Loader layer must meet to be compatible with this ODSP Driver. This is exposed to
+	 * the Loader layer so that it can validate Loader / Driver compatibility on this Driver's behalf (the Driver has
+	 * no reference to the Loader to validate it directly).
+	 * @remarks This is for internal use only.
+	 * The type of this should be ILayerCompatSupportRequirements. However, ILayerCompatSupportRequirements is
+	 * internal and this class is currently marked as legacy alpha. So, using unknown here.
+	 */
+	public readonly ILayerCompatSupportRequirements?: unknown =
+		odspDriverCompatRequirementsForLoader;
+
 	public async createDocumentService(
 		resolvedUrl: IResolvedUrl,
 		logger?: ITelemetryBaseLogger,
@@ -269,6 +354,22 @@ export class OdspDocumentServiceFactoryCore
 		);
 	}
 
+	/**
+	 * Creates a document service that reads its snapshot from the closest file version at or before
+	 * the target and its deltas from the live document, materializing a requested sequence number
+	 * through replay.
+	 *
+	 * @param resolvedUrl - The resolved ODSP {@link @fluidframework/driver-definitions#IResolvedUrl}.
+	 * @param targetSequenceNumber - The sequence number at which to materialize the document. See
+	 * {@link @fluidframework/container-loader#ILoadContainerToSequenceNumberProps.loadToSequenceNumber}.
+	 * @param logger - Optional {@link @fluidframework/core-interfaces#ITelemetryBaseLogger}.
+	 * @param clientIsSummarizer - Whether to apply summarizer policies and telemetry to the
+	 * underlying document services. Defaults to `false`.
+	 * @returns A read-only {@link @fluidframework/driver-definitions#IDocumentService} materialized
+	 * at the requested sequence number.
+	 */
+	public readonly createPointInTimeDocumentService?: IPointInTimeDocumentServiceFactory["createPointInTimeDocumentService"];
+
 	protected async createDocumentServiceCore(
 		resolvedUrl: IResolvedUrl,
 		odspLogger: ITelemetryBaseLogger,

package/src/odspDocumentStorageManager.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { performanceNow } from "@fluid-internal/client-utils";
+import { ArrayBufferLikeToArrayBuffer, performanceNow } from "@fluid-internal/client-utils";
 import { LogLevel } from "@fluidframework/core-interfaces";
 import { assert, delay } from "@fluidframework/core-utils/internal";
 import { promiseRaceWithWinner } from "@fluidframework/driver-base/internal";
@@ -158,7 +158,7 @@ export class OdspDocumentStorageService extends OdspDocumentStorageServiceBase {
 						this.epochTracker.fetchAndParseAsJSON<ICreateBlobResponse>(
 							url,
 							{
-								body: file,
+								body: ArrayBufferLikeToArrayBuffer(file),
 								headers,
 								method,
 							},

package/src/odspLayerCompatState.ts

@@ -3,7 +3,12 @@
  * Licensed under the MIT License.
  */
 
-import { generation, type ILayerCompatDetails } from "@fluid-internal/client-utils";
+import {
+	generation,
+	LayerCompatibilityPolicyWindowMonths,
+	type ILayerCompatDetails,
+	type ILayerCompatSupportRequirements,
+} from "@fluid-internal/client-utils";
 
 import { pkgVersion } from "./packageVersion.js";
 
@@ -25,3 +30,26 @@ export const odspDriverCompatDetailsForLoader: ILayerCompatDetails = {
 	 */
 	supportedFeatures: new Set<string>(),
 };
+
+/**
+ * The requirements that the Loader layer must meet to be compatible with this ODSP Driver. This is published to
+ * the Loader layer (which holds the reference to this Driver) so that it can validate Loader / Driver compatibility
+ * on this Driver's behalf.
+ * @internal
+ */
+export const odspDriverCompatRequirementsForLoader: ILayerCompatSupportRequirements = {
+	/**
+	 * Minimum generation that Loader must be at to be compatible with this Driver. This is calculated based on the
+	 * LayerCompatibilityPolicyWindowMonths.NewDriverOldLoader value which defines how many months old can the Loader
+	 * layer be compared to the Driver layer for them to still be considered compatible.
+	 * The minimum valid generation value is 0.
+	 */
+	minSupportedGeneration: Math.max(
+		0,
+		generation - LayerCompatibilityPolicyWindowMonths.NewDriverOldLoader,
+	),
+	/**
+	 * The features that the Loader must support to be compatible with this Driver.
+	 */
+	requiredFeatures: [],
+};

package/src/odspVersionManager/DEV.md

@@ -36,8 +36,8 @@ Part 1 is built in three components:
 - **Component A — the version manager**: choose which file version to load or replay from. **This
   folder is Component A**, and this document is mostly about it.
 - **Component B — the recomposed driver**: load the chosen version and replay ops forward to the exact
-  target. **Built** in `../pointInTimeDriver/` (`getOdspPointInTimeDocumentServiceFactory` /
-  `OdspPointInTimeDocumentService`) — see [Part V](#part-v--components-b--c-as-built).
+  target. **Built** in `../pointInTimeDriver/`, exported through the consumer-injected
+  `../pointInTime.ts` entrypoint — see [Part V](#part-v--components-b--c-as-built).
 - **Component C — the loader hookup**: expose Component B through the container loader. **Built** in
   `@fluidframework/container-loader` (`loadContainerToSequenceNumber`) — see
   [Part V](#part-v--components-b--c-as-built). This is the current prototype-era package
@@ -556,9 +556,10 @@ is what ships today.
 
 ### Component B — how does the recomposed driver materialize the target?
 
-The factory returned by `getOdspPointInTimeDocumentServiceFactory` (in `../pointInTimeDriver/`)
-extends `OdspDocumentServiceFactoryCore` internally and adds
-`createPointInTimeDocumentService(resolvedUrl, targetSequenceNumber)`:
+The host imports `createPointInTimeDocumentService` from the dedicated point-in-time entrypoint and
+injects it through `createOdspDocumentServiceFactory`. The returned factory exposes the optional
+`createPointInTimeDocumentService(resolvedUrl, targetSequenceNumber)` capability as a thin delegate.
+The injected implementation:
 
 1. Build a version manager (Component A), sharing the single `EpochTracker` described below, and call
    `findBaseForSeq(target)`. It picks the closest version *and* proves that base shares the live
@@ -661,9 +662,9 @@ and the `opStream` endpoint is queried for exactly `[from, target]`.
 
 1. Validates `loadToSequenceNumber` is a non-negative integer (`UsageError` otherwise).
 2. Detects the point-in-time capability with `asPointInTimeCapableFactory`, which checks the passed
-   `documentServiceFactory` exposes `createPointInTimeDocumentService`. A plain factory is a
-   `UsageError` — the caller must pass the result of `getOdspPointInTimeDocumentServiceFactory`
-   directly, with no wrapping.
+  `documentServiceFactory` exposes `createPointInTimeDocumentService`. A plain factory is a
+  `UsageError` — the caller must inject the dedicated ODSP implementation through
+  `createOdspDocumentServiceFactory` options and pass that factory directly with no wrapping.
 3. Wraps it in a `PointInTimeDocumentServiceFactory` adapter so the container's normal
    `createDocumentService(resolvedUrl)` routes to `createPointInTimeDocumentService(resolvedUrl, target)`.
    (`createContainer` throws — the adapter is load-only.)

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/odsp-driver";
-export const pkgVersion = "2.117.0";
+export const pkgVersion = "3.0.0";

package/src/pointInTime.ts

@@ -0,0 +1,30 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * Optional ODSP point-in-time loading implementation for consumer injection.
+ *
+ * @packageDocumentation
+ */
+
+// eslint-disable-next-line import-x/no-internal-modules -- Dedicated entrypoint for the optional point-in-time implementation.
+export { createPointInTimeDocumentService } from "./pointInTimeDriver/createPointInTimeDocumentService.js";
+export type {
+	IOdspPointInTimeDocumentServiceImplementationProps,
+	OdspPointInTimeDocumentServiceImplementation,
+} from "./odspDocumentServiceFactoryCore.js";
+export type {
+	EpochTracker,
+	FetchType,
+	FetchTypeInternal,
+	ICacheAndTracker,
+} from "./epochTracker.js";
+export type {
+	INonPersistentCache,
+	IOdspCache,
+	IPersistedFileCache,
+	IPrefetchSnapshotContents,
+} from "./odspCache.js";
+export type { IOdspResponse } from "./odspUtils.js";

package/src/pointInTimeDriver/createPointInTimeDocumentService.ts

@@ -0,0 +1,193 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type {
+	IDocumentService,
+	IResolvedUrl,
+} from "@fluidframework/driver-definitions/internal";
+import { UsageError } from "@fluidframework/driver-utils/internal";
+import type {
+	IOdspResolvedUrl,
+	IOdspUrlParts,
+} from "@fluidframework/odsp-driver-definitions/internal";
+import {
+	createChildLogger,
+	type TelemetryLoggerExt,
+} from "@fluidframework/telemetry-utils/internal";
+
+import { createOdspCacheAndTracker, type EpochTracker } from "../epochTracker.js";
+import { NonPersistentCache } from "../odspCache.js";
+import { OdspDriverUrlResolver } from "../odspDriverUrlResolver.js";
+import type { IOdspPointInTimeDocumentServiceImplementationProps } from "../odspDocumentServiceFactoryCore.js";
+import {
+	createOdspLogger,
+	getOdspResolvedUrl,
+	toInstrumentedOdspStorageTokenFetcher,
+} from "../odspUtils.js";
+import {
+	createOdspVersionManager,
+	type IOdspVersionManager,
+	// eslint-disable-next-line import-x/no-internal-modules -- the feature implementation owns version selection
+} from "../odspVersionManager/odspVersionManager.js";
+
+import { OdspPointInTimeDocumentService } from "./odspPointInTimeDocumentService.js";
+
+interface IPointInTimeDocumentServiceDependencies {
+	readonly createVersionManager?: (
+		odspResolvedUrl: IOdspResolvedUrl,
+		logger: TelemetryLoggerExt,
+		epochTracker: EpochTracker,
+	) => IOdspVersionManager | Promise<IOdspVersionManager>;
+	readonly resolveFileVersion?: (
+		resolvedUrl: IResolvedUrl,
+		fileVersion: string,
+	) => IResolvedUrl | Promise<IResolvedUrl>;
+}
+
+async function createVersionManager(
+	odspResolvedUrl: IOdspResolvedUrl,
+	logger: TelemetryLoggerExt,
+	epochTracker: EpochTracker,
+	getStorageToken: IOdspPointInTimeDocumentServiceImplementationProps["getStorageToken"],
+): Promise<IOdspVersionManager> {
+	const urlParts: IOdspUrlParts = {
+		siteUrl: odspResolvedUrl.siteUrl,
+		driveId: odspResolvedUrl.driveId,
+		itemId: odspResolvedUrl.itemId,
+	};
+	const getAuthHeader = toInstrumentedOdspStorageTokenFetcher(
+		logger,
+		urlParts,
+		getStorageToken,
+	);
+	return createOdspVersionManager({
+		urlParts,
+		getAuthHeader,
+		epochTracker,
+		logger,
+	});
+}
+
+async function resolveFileVersion(
+	resolvedUrl: IResolvedUrl,
+	fileVersion: string,
+): Promise<IResolvedUrl> {
+	const odspResolvedUrl = getOdspResolvedUrl(resolvedUrl);
+	const query = new URLSearchParams({
+		driveId: odspResolvedUrl.driveId,
+		itemId: odspResolvedUrl.itemId,
+		fileVersion,
+	});
+	if (odspResolvedUrl.dataStorePath !== undefined) {
+		query.set("path", odspResolvedUrl.dataStorePath);
+	}
+	if (odspResolvedUrl.codeHint?.containerPackageName !== undefined) {
+		query.set("containerPackageName", odspResolvedUrl.codeHint.containerPackageName);
+	}
+	return new OdspDriverUrlResolver().resolve({
+		url: `${odspResolvedUrl.siteUrl}?${query.toString()}`,
+	});
+}
+
+/**
+ * ODSP's point-in-time document service implementation.
+ *
+ * @remarks Import this function from the dedicated point-in-time entrypoint and inject it through
+ * {@link IOdspDocumentServiceFactoryOptions.pointInTimeDocumentServiceImplementation}.
+ *
+ * @param props - ODSP service dependencies and point-in-time load parameters supplied by the factory.
+ * @returns A read-only ODSP document service materialized at the requested sequence number.
+ *
+ * @legacy @beta
+ */
+export async function createPointInTimeDocumentService(
+	props: IOdspPointInTimeDocumentServiceImplementationProps,
+): Promise<IDocumentService> {
+	return createPointInTimeDocumentServiceCore(props);
+}
+
+/**
+ * Creates the point-in-time service with replaceable dependencies for testing.
+ * @internal
+ */
+export async function createPointInTimeDocumentServiceCore(
+	{
+		resolvedUrl,
+		targetSequenceNumber,
+		logger,
+		clientIsSummarizer,
+		persistedCache,
+		getStorageToken,
+		createDocumentService,
+	}: IOdspPointInTimeDocumentServiceImplementationProps,
+	dependencies: IPointInTimeDocumentServiceDependencies = {},
+): Promise<OdspPointInTimeDocumentService> {
+	const odspLogger = createOdspLogger(logger);
+	const extLogger = createChildLogger({ logger: odspLogger });
+	const odspResolvedUrl = getOdspResolvedUrl(resolvedUrl);
+	const cacheAndTracker = createOdspCacheAndTracker(
+		persistedCache,
+		new NonPersistentCache(),
+		{
+			resolvedUrl: odspResolvedUrl,
+			docId: odspResolvedUrl.hashedDocumentId,
+			fileVersion: odspResolvedUrl.fileVersion,
+		},
+		extLogger,
+		clientIsSummarizer,
+	);
+
+	const versionManager = await (
+		dependencies.createVersionManager ??
+		(async (url, versionLogger, epochTracker) =>
+			createVersionManager(url, versionLogger, epochTracker, getStorageToken))
+	)(odspResolvedUrl, extLogger, cacheAndTracker.epochTracker);
+	const baseResult = await versionManager.findBaseForSeq(targetSequenceNumber);
+	if (baseResult.kind === "noBaseVersion") {
+		const oldestResolvedSequenceDetail =
+			baseResult.oldestResolvedSeq === undefined
+				? ""
+				: ` The oldest resolved file version is at sequence number ${baseResult.oldestResolvedSeq}.`;
+		throw new UsageError(
+			`No ODSP file version is available at or before sequence number ${targetSequenceNumber}.${oldestResolvedSequenceDetail}`,
+		);
+	}
+
+	const recoverableResolvedUrl = await (dependencies.resolveFileVersion ?? resolveFileVersion)(
+		resolvedUrl,
+		baseResult.base.versionId,
+	);
+	const recoverableDocumentService = await createDocumentService(
+		recoverableResolvedUrl,
+		odspLogger,
+		cacheAndTracker,
+		clientIsSummarizer,
+	);
+	let liveDocumentService: IDocumentService;
+	try {
+		liveDocumentService = await createDocumentService(
+			resolvedUrl,
+			odspLogger,
+			cacheAndTracker,
+			clientIsSummarizer,
+		);
+	} catch (error) {
+		try {
+			recoverableDocumentService.dispose();
+		} catch (disposeError) {
+			extLogger.sendErrorEvent(
+				{ eventName: "PointInTimeRecoverableDocumentServiceDisposeError" },
+				disposeError,
+			);
+		}
+		throw error;
+	}
+	return new OdspPointInTimeDocumentService(
+		recoverableResolvedUrl,
+		recoverableDocumentService,
+		liveDocumentService,
+		targetSequenceNumber,
+	);
+}

package/src/zipItDataRepresentationUtils.ts

@@ -8,7 +8,7 @@
  * https://microsoft.sharepoint-df.com/:w:/t/ODSPFileStore/ER06b64K_XdDjEyAKl-UT60BJiId39SCVkYSyo_2pvH9gQ?e=KYQ0c5
  */
 
-import { Uint8ArrayToArrayBuffer, Uint8ArrayToString } from "@fluid-internal/client-utils";
+import { Uint8ArrayToArrayBufferLike, Uint8ArrayToString } from "@fluid-internal/client-utils";
 import { assert } from "@fluidframework/core-utils/internal";
 import { NonRetryableError } from "@fluidframework/driver-utils/internal";
 import { OdspErrorTypes } from "@fluidframework/odsp-driver-definitions/internal";
@@ -186,7 +186,7 @@ class BlobDeepCopy extends BlobCore {
 	}
 
 	public get arrayBuffer(): ArrayBufferLike {
-		return Uint8ArrayToArrayBuffer(this.buffer);
+		return Uint8ArrayToArrayBufferLike(this.buffer);
 	}
 
 	public static read(buffer: ReadBuffer, lengthLen: number): BlobCore {
@@ -222,7 +222,7 @@ export class BlobShallowCopy extends BlobCore {
 		return this.data.subarray(this.start, this.end);
 	}
 
-	// Equivalent to Uint8ArrayToArrayBuffer(this.buffer)
+	// Equivalent to Uint8ArrayToArrayBufferLike(this.buffer)
 	public get arrayBuffer(): ArrayBufferLike {
 		const offset = this.data.byteOffset;
 		return this.data.buffer.slice(this.start + offset, this.end + offset);

package/tsconfig.json

@@ -1,5 +1,5 @@
 {
-	"extends": "../../../common/build/build-common/tsconfig.node16.json",
+	"extends": "../../../common/build/build-common/tsconfig.node20.json",
 	"include": ["src/**/*"],
 	"exclude": ["src/test/**/*"],
 	"compilerOptions": {

package/dist/pointInTimeDriver/odspPointInTimeDocumentServiceFactory.d.ts

@@ -1,41 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
-import type { IDocumentService, IDocumentServiceFactory, IPersistedCache, IResolvedUrl } from "@fluidframework/driver-definitions/internal";
-import type { HostStoragePolicy, OdspResourceTokenFetchOptions, TokenFetcher } from "@fluidframework/odsp-driver-definitions/internal";
-/**
- * An ODSP document service factory that supports point-in-time (sequence-number-based) loading.
- *
- * @remarks
- * The loader detects this capability structurally, so hosts can pass this factory directly to
- * `loadContainerToSequenceNumber`.
- *
- * @legacy @beta
- */
-export interface IPointInTimeDocumentServiceFactory extends IDocumentServiceFactory {
-    /**
-     * Creates a document service that materializes the document at the requested sequence number.
-     *
-     * @param resolvedUrl - The resolved ODSP document URL.
-     * @param targetSequenceNumber - The sequence number at which to materialize the document.
-     * @param logger - Optional telemetry logger.
-     * @param clientIsSummarizer - Whether the requesting client is a summarizer.
-     * @returns A read-only document service materialized at the requested sequence number.
-     */
-    createPointInTimeDocumentService(resolvedUrl: IResolvedUrl, targetSequenceNumber: number, logger?: ITelemetryBaseLogger, clientIsSummarizer?: boolean): Promise<IDocumentService>;
-}
-/**
- * Creates an ODSP document service factory that supports point-in-time loading.
- *
- * @param getStorageToken - Fetches storage access tokens.
- * @param getWebsocketToken - Fetches websocket access tokens, or `undefined` when unavailable.
- * @param persistedCache - Optional persisted ODSP cache.
- * @param hostPolicy - Optional host storage policy.
- * @returns An ODSP document service factory with point-in-time loading capability.
- *
- * @legacy @beta
- */
-export declare function getOdspPointInTimeDocumentServiceFactory(getStorageToken: TokenFetcher<OdspResourceTokenFetchOptions>, getWebsocketToken: TokenFetcher<OdspResourceTokenFetchOptions> | undefined, persistedCache?: IPersistedCache, hostPolicy?: HostStoragePolicy): IPointInTimeDocumentServiceFactory;
-//# sourceMappingURL=odspPointInTimeDocumentServiceFactory.d.ts.map

package/dist/pointInTimeDriver/odspPointInTimeDocumentServiceFactory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"odspPointInTimeDocumentServiceFactory.d.ts","sourceRoot":"","sources":["../../src/pointInTimeDriver/odspPointInTimeDocumentServiceFactory.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAC5E,OAAO,KAAK,EACX,gBAAgB,EAChB,uBAAuB,EACvB,eAAe,EACf,YAAY,EACZ,MAAM,6CAA6C,CAAC;AACrD,OAAO,KAAK,EACX,iBAAiB,EAGjB,6BAA6B,EAC7B,YAAY,EACZ,MAAM,kDAAkD,CAAC;AAuB1D;;;;;;;;GAQG;AACH,MAAM,WAAW,kCAAmC,SAAQ,uBAAuB;IAClF;;;;;;;;OAQG;IACH,gCAAgC,CAC/B,WAAW,EAAE,YAAY,EACzB,oBAAoB,EAAE,MAAM,EAC5B,MAAM,CAAC,EAAE,oBAAoB,EAC7B,kBAAkB,CAAC,EAAE,OAAO,GAC1B,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAC7B;AA0KD;;;;;;;;;;GAUG;AACH,wBAAgB,wCAAwC,CACvD,eAAe,EAAE,YAAY,CAAC,6BAA6B,CAAC,EAC5D,iBAAiB,EAAE,YAAY,CAAC,6BAA6B,CAAC,GAAG,SAAS,EAC1E,cAAc,CAAC,EAAE,eAAe,EAChC,UAAU,CAAC,EAAE,iBAAiB,GAC5B,kCAAkC,CAOpC"}