fix(driver-utils): prevent unhandled rejection in prefetch fire-and-forget calls

Fix three fire-and-forget patterns that cause unhandled rejections:

1. getSnapshotTree(): `void p.then(...)` creates a derived promise that
   rejects when p rejects. Added `.catch()` to the promise chain.

2. prefetchTree()/prefetchTreeCore(): `void this.cachedRead(blob)` discards
   the async function's returned promise. Since cachedRead is async, it
   returns a separate promise chain from the inner prefetchedBlobPFromStorage.
   The existing `.catch()` inside cachedRead only handles the inner promise,
   not the async function's returned promise. Changed to
   `this.cachedRead(blob).catch(() => {})`.

The root cause: attaching `.catch()` to a promise P only prevents unhandled
rejection for P's chain. When an async function returns P, the function's
returned promise is a DIFFERENT chain that also rejects - and needs its own
`.catch()` handler.

This is a follow-up to PR #26151 which only fixed the inner promise in
cachedRead but didn't fix the callers' fire-and-forget patterns.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Co-Authored-By: anthony-murphy <anthony.murphy@microsoft.com>

Author: 3 people

packages/loader/driver-utils/src/prefetchDocumentStorageService.ts

@@ -31,13 +31,20 @@ export class PrefetchDocumentStorageService extends DocumentStorageServiceProxy
 	public async getSnapshotTree(version?: IVersion): Promise<ISnapshotTree | null> {
 		const p = this.internalStorageService.getSnapshotTree(version);
 		if (this.prefetchEnabled) {
-			// We don't care if the prefetch succeeds
-			void p.then((tree: ISnapshotTree | null | undefined) => {
-				if (tree === null || tree === undefined) {
-					return;
-				}
-				this.prefetchTree(tree);
-			});
+			// Fire-and-forget prefetch - we don't care if it succeeds.
+			// The .catch() prevents unhandled rejection when p rejects, since
+			// p.then() creates a derived promise that also rejects if p rejects.
+			// Callers awaiting the returned p will still receive the error.
+			void p
+				.then((tree: ISnapshotTree | null | undefined) => {
+					if (tree === null || tree === undefined) {
+						return;
+					}
+					this.prefetchTree(tree);
+				})
+				.catch(() => {
+					// Intentionally empty - error will be handled by caller awaiting p
+				});
 		}
 		return p;
 	}
@@ -81,17 +88,19 @@ export class PrefetchDocumentStorageService extends DocumentStorageServiceProxy
 		this.prefetchTreeCore(tree, secondary);
 
 		for (const blob of secondary) {
-			// We don't care if the prefetch succeeds
-			void this.cachedRead(blob);
+			// Fire-and-forget prefetch. The .catch() prevents unhandled rejection
+			// since cachedRead is async and returns a separate promise chain.
+			this.cachedRead(blob).catch(() => {});
 		}
 	}
 
 	private prefetchTreeCore(tree: ISnapshotTree, secondary: string[]): void {
 		for (const [blobKey, blob] of Object.entries(tree.blobs)) {
 			if (blobKey.startsWith(".") || blobKey === "header" || blobKey.startsWith("quorum")) {
 				if (blob !== null) {
-					// We don't care if the prefetch succeeds
-					void this.cachedRead(blob);
+					// Fire-and-forget prefetch. The .catch() prevents unhandled rejection
+					// since cachedRead is async and returns a separate promise chain.
+					this.cachedRead(blob).catch(() => {});
 				}
 			} else if (!blobKey.startsWith("deltas")) {
 				if (blob !== null) {

packages/loader/driver-utils/src/test/prefetchDocumentStorageService.spec.ts

@@ -37,6 +37,8 @@ class MockStorageService implements Partial<IDocumentStorageService> {
 	public readBlobCalls: string[] = [];
 	public shouldFail = false;
 	public failureError = new Error("Mock read failure");
+	public shouldGetSnapshotTreeFail = false;
+	public getSnapshotTreeError = new Error("Mock getSnapshotTree failure");
 
 	public async readBlob(blobId: string): Promise<ArrayBufferLike> {
 		this.readBlobCalls.push(blobId);
@@ -47,6 +49,9 @@ class MockStorageService implements Partial<IDocumentStorageService> {
 	}
 
 	public async getSnapshotTree(): Promise<ISnapshotTree | null> {
+		if (this.shouldGetSnapshotTreeFail) {
+			throw this.getSnapshotTreeError;
+		}
 		return {
 			blobs: {
 				".metadata": "blob1",
@@ -160,4 +165,27 @@ describe("PrefetchDocumentStorageService", () => {
 			"Explicit readBlob should still receive the error",
 		);
 	});
+
+	it("should not cause unhandled rejections when getSnapshotTree fails", async () => {
+		// Set up getSnapshotTree to fail (e.g., network timeout)
+		const networkError = new Error("Socket timeout");
+		mockStorage.shouldGetSnapshotTreeFail = true;
+		mockStorage.getSnapshotTreeError = networkError;
+
+		// getSnapshotTree internally does: void p.then(...).catch(...)
+		// Without the .catch(), if p rejects, the derived promise from .then() also
+		// rejects and causes an unhandled rejection. This test verifies the fix.
+		await assert.rejects(
+			async () => prefetchService.getSnapshotTree(),
+			(error: Error) => error.message === "Socket timeout",
+			"Caller should receive the error",
+		);
+
+		// Allow microtask queue to flush - if there's an unhandled rejection,
+		// it would surface here or cause the test to fail
+		await Promise.resolve();
+		await new Promise((resolve) => setTimeout(resolve, 10));
+
+		// If we reach here without unhandled rejection, the test passes
+	});
 });