fix(driver-utils): prevent unhandled rejection in getSnapshotTree prefetch (#26173)

## Summary

- Fix unhandled promise rejections in `PrefetchDocumentStorageService`
fire-and-forget calls
- Add unit test for getSnapshotTree failure scenario

## Problem

This is a follow-up to PR #26151. After that fix was deployed, telemetry
showed 349 `uncaughtException` errors from
`ShreddedSummaryDocumentStorageService.readBlob` in test-service-load
tinylicious tests.

**Root cause:** PR #26151 attached `.catch()` to the inner promise in
`cachedRead()`, but that only handles ONE promise chain. The
fire-and-forget callers create a DIFFERENT chain:

1. **`void this.cachedRead(blob)`** - `cachedRead` is async, so it
returns a NEW promise wrapping the inner promise. The `.catch()` on the
inner promise doesn't prevent unhandled rejection on the async
function's returned promise.

2. **`void p.then(...)`** in `getSnapshotTree()` - creates a derived
promise that also rejects when `p` rejects.

## Solution

Fix all three fire-and-forget patterns:

```typescript
// Before (inner promise handled, but async wrapper not):
void this.cachedRead(blob);

// After (handles the async function's returned promise):
this.cachedRead(blob).catch(() => {});
```

```typescript
// Before (derived promise not handled):
void p.then((tree) => this.prefetchTree(tree));

// After (handles the derived promise):
void p.then(...).catch(() => {});
```

## Test plan

- [x] New unit test for `getSnapshotTree` failure scenario
- [x] All 5 PrefetchDocumentStorageService tests pass
- [x] Build passes

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: anthony-murphy <anthony.murphy@microsoft.com>

---------

Co-authored-by: anthony-murphy-agent <253562292+anthony-murphy-agent@users.noreply.github.com>
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,12 +31,17 @@ 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) => {
+			// 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.
+			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 +86,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
+	});
 });