@fluidframework/odsp-driver 2.117.0 → 2.118.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluidframework/odsp-driver",
-  "version": "2.117.0",
+  "version": "2.118.0",
   "description": "Socket storage implementation for SPO and ODC",
   "homepage": "https://fluidframework.com",
   "repository": {
@@ -43,6 +43,16 @@
         "default": "./dist/index.js"
       }
     },
+    "./legacy/point-in-time": {
+      "import": {
+        "types": "./lib/pointInTime.d.ts",
+        "default": "./lib/pointInTime.js"
+      },
+      "require": {
+        "types": "./dist/pointInTime.d.ts",
+        "default": "./dist/pointInTime.js"
+      }
+    },
     "./internal": {
       "import": {
         "types": "./lib/index.d.ts",
@@ -79,22 +89,22 @@
     "temp-directory": "nyc/.nyc_output"
   },
   "dependencies": {
-    "@fluid-internal/client-utils": "~2.117.0",
-    "@fluidframework/core-interfaces": "~2.117.0",
-    "@fluidframework/core-utils": "~2.117.0",
-    "@fluidframework/driver-base": "~2.117.0",
-    "@fluidframework/driver-definitions": "~2.117.0",
-    "@fluidframework/driver-utils": "~2.117.0",
-    "@fluidframework/odsp-doclib-utils": "~2.117.0",
-    "@fluidframework/odsp-driver-definitions": "~2.117.0",
-    "@fluidframework/telemetry-utils": "~2.117.0",
+    "@fluid-internal/client-utils": "~2.118.0",
+    "@fluidframework/core-interfaces": "~2.118.0",
+    "@fluidframework/core-utils": "~2.118.0",
+    "@fluidframework/driver-base": "~2.118.0",
+    "@fluidframework/driver-definitions": "~2.118.0",
+    "@fluidframework/driver-utils": "~2.118.0",
+    "@fluidframework/odsp-doclib-utils": "~2.118.0",
+    "@fluidframework/odsp-driver-definitions": "~2.118.0",
+    "@fluidframework/telemetry-utils": "~2.118.0",
     "socket.io-client": "^4.8.3",
     "uuid": "^11.1.0"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",
     "@biomejs/biome": "~2.4.5",
-    "@fluid-internal/mocha-test-setup": "~2.117.0",
+    "@fluid-internal/mocha-test-setup": "~2.118.0",
     "@fluid-tools/build-cli": "^0.67.0",
     "@fluidframework/build-common": "^2.0.3",
     "@fluidframework/build-tools": "^0.67.0",
@@ -125,6 +135,7 @@
     "build:api-reports": "concurrently \"npm:build:api-reports:*\"",
     "build:api-reports:current": "api-extractor run --local --config api-extractor/api-extractor.current.json",
     "build:api-reports:legacy": "api-extractor run --local --config api-extractor/api-extractor.legacy.json",
+    "build:api-reports:pointInTime": "api-extractor run --local --config api-extractor/api-extractor-report.pointInTime.json",
     "build:commonjs": "fluid-build . --task commonjs",
     "build:compile": "fluid-build . --task compile",
     "build:docs": "api-extractor run --local",
@@ -142,14 +153,17 @@
     "check:exports:bundle-release-tags": "api-extractor run --config api-extractor/api-extractor-lint-bundle.json",
     "check:exports:cjs:legacy": "api-extractor run --config api-extractor/api-extractor-lint-legacy.cjs.json",
     "check:exports:cjs:legacyAlpha": "api-extractor run --config api-extractor/api-extractor-lint-legacyAlpha.cjs.json",
+    "check:exports:cjs:pointInTime": "api-extractor run --config api-extractor/api-extractor-lint-pointInTime.cjs.json",
     "check:exports:cjs:public": "api-extractor run --config api-extractor/api-extractor-lint-public.cjs.json",
     "check:exports:esm:legacy": "api-extractor run --config api-extractor/api-extractor-lint-legacy.esm.json",
     "check:exports:esm:legacyAlpha": "api-extractor run --config api-extractor/api-extractor-lint-legacyAlpha.esm.json",
+    "check:exports:esm:pointInTime": "api-extractor run --config api-extractor/api-extractor-lint-pointInTime.esm.json",
     "check:exports:esm:public": "api-extractor run --config api-extractor/api-extractor-lint-public.esm.json",
     "check:format": "npm run check:biome",
     "ci:build:api-reports": "concurrently \"npm:ci:build:api-reports:*\"",
     "ci:build:api-reports:current": "api-extractor run --config api-extractor/api-extractor.current.json",
     "ci:build:api-reports:legacy": "api-extractor run --config api-extractor/api-extractor.legacy.json",
+    "ci:build:api-reports:pointInTime": "api-extractor run --config api-extractor/api-extractor-report.pointInTime.json",
     "ci:build:docs": "api-extractor run",
     "clean": "rimraf --glob dist lib {alpha,beta,internal,legacy}.d.ts legacyAlpha.d.ts \"**/*.tsbuildinfo\" \"**/*.build.log\" _api-extractor-temp nyc",
     "eslint": "eslint --quiet --format stylish src",

package/src/index.ts

@@ -27,15 +27,17 @@ export { prefetchLatestSnapshot } from "./prefetchLatestSnapshot.js";
 // Factory
 export {
 	createLocalOdspDocumentServiceFactory,
+	createOdspDocumentServiceFactory,
+	getOdspPointInTimeDocumentServiceFactory,
+	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";

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,80 @@ 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 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.
+ *
+ * @deprecated Use
+ * {@link createOdspDocumentServiceFactory} with a point-in-time implementation instead.
+ * See {@link https://github.com/microsoft/FluidFramework/issues/26500} for context.
+ *
+ * @legacy @beta
+ */
+export function getOdspPointInTimeDocumentServiceFactory(
+	getStorageToken: TokenFetcher<OdspResourceTokenFetchOptions>,
+	getWebsocketToken: TokenFetcher<OdspResourceTokenFetchOptions> | undefined,
+	persistedCache?: IPersistedCache,
+	hostPolicy?: HostStoragePolicy,
+): IPointInTimeDocumentServiceFactory {
+	return createOdspDocumentServiceFactory({
+		getStorageToken,
+		getWebsocketToken,
+		persistedCache,
+		hostPolicy,
+		pointInTimeDocumentServiceImplementation: async (props) => {
+			const { createPointInTimeDocumentService } = await import("./pointInTime.js");
+			return createPointInTimeDocumentService(props);
+		},
+	}) as IPointInTimeDocumentServiceFactory;
+}
+
 /**
  * Creates a factory instance for creating a sharepoint document service from a provided snapshot.
  *

package/src/odspDocumentServiceFactoryCore.ts

@@ -53,12 +53,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
  */
@@ -269,6 +340,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/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 = "2.118.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,180 @@
+/*!
+ * 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,
+	);
+	const liveDocumentService = await createDocumentService(
+		resolvedUrl,
+		odspLogger,
+		cacheAndTracker,
+		clientIsSummarizer,
+	);
+	return new OdspPointInTimeDocumentService(
+		recoverableResolvedUrl,
+		recoverableDocumentService,
+		liveDocumentService,
+		targetSequenceNumber,
+	);
+}

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"}