@fluidframework/container-runtime 2.60.0 → 2.61.0-355516

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluidframework/container-runtime",
-  "version": "2.60.0",
+  "version": "2.61.0-355516",
   "description": "Fluid container runtime",
   "homepage": "https://fluidframework.com",
   "repository": {
@@ -119,18 +119,18 @@
     "temp-directory": "nyc/.nyc_output"
   },
   "dependencies": {
-    "@fluid-internal/client-utils": "~2.60.0",
-    "@fluidframework/container-definitions": "~2.60.0",
-    "@fluidframework/container-runtime-definitions": "~2.60.0",
-    "@fluidframework/core-interfaces": "~2.60.0",
-    "@fluidframework/core-utils": "~2.60.0",
-    "@fluidframework/datastore": "~2.60.0",
-    "@fluidframework/driver-definitions": "~2.60.0",
-    "@fluidframework/driver-utils": "~2.60.0",
-    "@fluidframework/id-compressor": "~2.60.0",
-    "@fluidframework/runtime-definitions": "~2.60.0",
-    "@fluidframework/runtime-utils": "~2.60.0",
-    "@fluidframework/telemetry-utils": "~2.60.0",
+    "@fluid-internal/client-utils": "2.61.0-355516",
+    "@fluidframework/container-definitions": "2.61.0-355516",
+    "@fluidframework/container-runtime-definitions": "2.61.0-355516",
+    "@fluidframework/core-interfaces": "2.61.0-355516",
+    "@fluidframework/core-utils": "2.61.0-355516",
+    "@fluidframework/datastore": "2.61.0-355516",
+    "@fluidframework/driver-definitions": "2.61.0-355516",
+    "@fluidframework/driver-utils": "2.61.0-355516",
+    "@fluidframework/id-compressor": "2.61.0-355516",
+    "@fluidframework/runtime-definitions": "2.61.0-355516",
+    "@fluidframework/runtime-utils": "2.61.0-355516",
+    "@fluidframework/telemetry-utils": "2.61.0-355516",
     "@tylerbu/sorted-btree-es6": "^1.8.0",
     "double-ended-queue": "^2.1.0-0",
     "lz4js": "^0.2.0",
@@ -140,23 +140,23 @@
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.17.1",
     "@biomejs/biome": "~1.9.3",
-    "@fluid-internal/mocha-test-setup": "~2.60.0",
-    "@fluid-private/stochastic-test-utils": "~2.60.0",
-    "@fluid-private/test-pairwise-generator": "~2.60.0",
+    "@fluid-internal/mocha-test-setup": "2.61.0-355516",
+    "@fluid-private/stochastic-test-utils": "2.61.0-355516",
+    "@fluid-private/test-pairwise-generator": "2.61.0-355516",
     "@fluid-tools/benchmark": "^0.51.0",
-    "@fluid-tools/build-cli": "^0.57.0",
+    "@fluid-tools/build-cli": "^0.58.1",
     "@fluidframework/build-common": "^2.0.3",
-    "@fluidframework/build-tools": "^0.57.0",
-    "@fluidframework/container-runtime-previous": "npm:@fluidframework/container-runtime@2.53.0",
+    "@fluidframework/build-tools": "^0.58.1",
+    "@fluidframework/container-runtime-previous": "npm:@fluidframework/container-runtime@2.60.0",
     "@fluidframework/eslint-config-fluid": "^6.0.0",
-    "@fluidframework/test-runtime-utils": "~2.60.0",
-    "@microsoft/api-extractor": "7.52.8",
+    "@fluidframework/test-runtime-utils": "2.61.0-355516",
+    "@microsoft/api-extractor": "7.52.11",
     "@types/double-ended-queue": "^2.1.0",
     "@types/lz4js": "^0.2.0",
     "@types/mocha": "^10.0.10",
     "@types/node": "^18.19.0",
     "@types/sinon": "^17.0.3",
-    "c8": "^8.0.1",
+    "c8": "^10.1.3",
     "concurrently": "^8.2.1",
     "copyfiles": "^2.4.1",
     "cross-env": "^7.0.3",
@@ -173,8 +173,8 @@
   },
   "scripts": {
     "api": "fluid-build . --task api",
-    "api-extractor:commonjs": "flub generate entrypoints --outDir ./dist",
-    "api-extractor:esnext": "flub generate entrypoints --outDir ./lib --node10TypeCompat",
+    "api-extractor:commonjs": "flub generate entrypoints --outFileLegacyBeta legacy --outDir ./dist",
+    "api-extractor:esnext": "flub generate entrypoints --outFileLegacyBeta legacy --outDir ./lib --node10TypeCompat",
     "build": "fluid-build . --task build",
     "build:api-reports": "concurrently \"npm:build:api-reports:*\"",
     "build:api-reports:current": "api-extractor run --local --config api-extractor/api-extractor.current.json",
@@ -210,11 +210,11 @@
     "pack:tests": "tar -cf ./container-runtime.test-files.tar ./src/test ./dist/test ./lib/test",
     "place:cjs:package-stub": "copyfiles -f ../../../common/build/build-common/src/cjs/package.json ./dist",
     "test": "npm run test:mocha",
-    "test:benchmark:report": "mocha --timeout 10s --perfMode --parentProcess --fgrep @Benchmark --fgrep @ExecutionTime --reporter @fluid-tools/benchmark/dist/MochaReporter.js \"./dist/**/*.perf.spec.*js\"",
+    "test:benchmark:report": "cross-env \"MOCHA_SPEC=dist/**/*.perf.spec.*js\" mocha --timeout 10s --perfMode --parentProcess --fgrep @Benchmark --fgrep @ExecutionTime --reporter @fluid-tools/benchmark/dist/MochaReporter.js",
     "test:coverage": "c8 npm test",
     "test:mocha": "npm run test:mocha:esm && echo skipping cjs to avoid overhead - npm run test:mocha:cjs",
-    "test:mocha:cjs": "mocha --recursive \"dist/test/**/*.spec.*js\"",
-    "test:mocha:esm": "mocha --recursive \"lib/test/**/*.spec.*js\"",
+    "test:mocha:cjs": "cross-env MOCHA_SPEC=dist/test mocha",
+    "test:mocha:esm": "mocha",
     "test:mocha:verbose": "cross-env FLUID_TEST_VERBOSE=1 npm run test:mocha",
     "tsc": "fluid-tsc commonjs --project ./tsconfig.cjs.json && npm run place:cjs:package-stub",
     "tsc:watch": "npm run place:cjs:package-stub && fluid-tsc commonjs --project ./tsconfig.cjs.json --watch",

package/src/blobManager/blobManager.ts

@@ -129,7 +129,7 @@ export class BlobHandle
 // the contract explicit and reduces the amount of mocking required for tests.
 export type IBlobManagerRuntime = Pick<
 	IContainerRuntime,
-	"attachState" | "connected" | "baseLogger" | "clientDetails" | "disposed"
+	"attachState" | "baseLogger" | "disposed"
 > &
 	IEventProvider<IContainerRuntimeEvents>;
 
@@ -181,13 +181,12 @@ export class BlobManager {
 	private readonly internalEvents = createEmitter<IBlobManagerInternalEvents>();
 
 	/**
-	 * Map of local IDs to storage IDs. Contains identity entries (storageId → storageId) for storage IDs. All requested IDs should
-	 * be a key in this map. Blobs created while the container is detached are stored in IDetachedBlobStorage which
-	 * gives local IDs; the storage IDs are filled in at attach time.
-	 * Note: It contains mappings from all clients, i.e., from remote clients as well. local ID comes from the client
-	 * that uploaded the blob but its mapping to storage ID is needed in all clients in order to retrieve the blob.
+	 * Map of local IDs to storage IDs. Also includes identity mappings of storage ID to storage ID for all known
+	 * storage IDs. All requested IDs must be a key in this map. Blobs created while the container is detached are
+	 * stored in IDetachedBlobStorage which gives pseudo storage IDs; the real storage IDs are filled in at attach
+	 * time via setRedirectTable().
 	 */
-	private readonly redirectTable: Map<string, string | undefined>;
+	private readonly redirectTable: Map<string, string>;
 
 	/**
 	 * Blobs which we have not yet seen a BlobAttach op round-trip and not yet attached to a DDS.
@@ -206,13 +205,13 @@ export class BlobManager {
 	private readonly routeContext: IFluidHandleContext;
 	private readonly storage: Pick<IContainerStorageService, "createBlob" | "readBlob">;
 	// Called when a blob node is requested. blobPath is the path of the blob's node in GC's graph.
-	// blobPath's format - `/<basePath>/<blobId>`.
+	// blobPath's format - `/<basePath>/<localId>`.
 	private readonly blobRequested: (blobPath: string) => void;
 	// Called to check if a blob has been deleted by GC.
-	// blobPath's format - `/<basePath>/<blobId>`.
+	// blobPath's format - `/<basePath>/<localId>`.
 	private readonly isBlobDeleted: (blobPath: string) => boolean;
 	private readonly runtime: IBlobManagerRuntime;
-	private readonly localBlobIdGenerator: () => string;
+	private readonly localIdGenerator: () => string;
 
 	private readonly createBlobPayloadPending: boolean;
 
@@ -233,14 +232,14 @@ export class BlobManager {
 		 */
 		sendBlobAttachOp: (localId: string, storageId: string) => void;
 		// Called when a blob node is requested. blobPath is the path of the blob's node in GC's graph.
-		// blobPath's format - `/<basePath>/<blobId>`.
+		// blobPath's format - `/<basePath>/<localId>`.
 		readonly blobRequested: (blobPath: string) => void;
 		// Called to check if a blob has been deleted by GC.
-		// blobPath's format - `/<basePath>/<blobId>`.
+		// blobPath's format - `/<basePath>/<localId>`.
 		readonly isBlobDeleted: (blobPath: string) => boolean;
 		readonly runtime: IBlobManagerRuntime;
 		stashedBlobs: IPendingBlobs | undefined;
-		readonly localBlobIdGenerator?: (() => string) | undefined;
+		readonly localIdGenerator?: (() => string) | undefined;
 		readonly createBlobPayloadPending: boolean;
 	}) {
 		const {
@@ -251,7 +250,7 @@ export class BlobManager {
 			blobRequested,
 			isBlobDeleted,
 			runtime,
-			localBlobIdGenerator,
+			localIdGenerator,
 			createBlobPayloadPending,
 		} = props;
 		this.routeContext = routeContext;
@@ -259,7 +258,7 @@ export class BlobManager {
 		this.blobRequested = blobRequested;
 		this.isBlobDeleted = isBlobDeleted;
 		this.runtime = runtime;
-		this.localBlobIdGenerator = localBlobIdGenerator ?? uuid;
+		this.localIdGenerator = localIdGenerator ?? uuid;
 		this.createBlobPayloadPending = createBlobPayloadPending;
 
 		this.mc = createChildMonitoringContext({
@@ -267,13 +266,9 @@ export class BlobManager {
 			namespace: "BlobManager",
 		});
 
-		this.redirectTable = toRedirectTable(
-			blobManagerLoadInfo,
-			this.mc.logger,
-			this.runtime.attachState,
-		);
+		this.redirectTable = toRedirectTable(blobManagerLoadInfo, this.mc.logger);
 
-		this.sendBlobAttachOp = (localId: string, blobId: string) => {
+		this.sendBlobAttachOp = (localId: string, storageId: string) => {
 			const pendingEntry = this.pendingBlobs.get(localId);
 			assert(
 				pendingEntry !== undefined,
@@ -302,7 +297,7 @@ export class BlobManager {
 				}
 			}
 			pendingEntry.opsent = true;
-			sendBlobAttachOp(localId, blobId);
+			sendBlobAttachOp(localId, storageId);
 		};
 	}
 
@@ -329,59 +324,67 @@ export class BlobManager {
 		});
 	}
 
-	public hasBlob(blobId: string): boolean {
-		return this.redirectTable.get(blobId) !== undefined;
+	public hasBlob(localId: string): boolean {
+		return this.redirectTable.get(localId) !== undefined;
+	}
+
+	/**
+	 * Lookup the blob storage ID for a given local blob id.
+	 * @param localId - The local blob id. Likely coming from a handle.
+	 * @returns The storage ID if found and the blob is not pending, undefined otherwise.
+	 * @remarks
+	 * For blobs with pending payloads (localId exists but upload hasn't finished), this is expected to return undefined.
+	 * Consumers should use the observability APIs on the handle (handle.payloadState, payloadShared event)
+	 * to understand/wait for storage ID availability.
+	 * Similarly, when the runtime is detached, this will return undefined as no blobs have been uploaded to storage.
+	 */
+	public lookupTemporaryBlobStorageId(localId: string): string | undefined {
+		if (this.runtime.attachState === AttachState.Detached) {
+			return undefined;
+		}
+		// Get the storage ID from the redirect table
+		return this.redirectTable.get(localId);
 	}
 
 	/**
 	 * Retrieve the blob with the given local blob id.
-	 * @param blobId - The local blob id.  Likely coming from a handle.
+	 * @param localId - The local blob id.  Likely coming from a handle.
 	 * @param payloadPending - Whether we suspect the payload may be pending and not available yet.
 	 * @returns A promise which resolves to the blob contents
 	 */
-	public async getBlob(blobId: string, payloadPending: boolean): Promise<ArrayBufferLike> {
+	public async getBlob(localId: string, payloadPending: boolean): Promise<ArrayBufferLike> {
 		// Verify that the blob is not deleted, i.e., it has not been garbage collected. If it is, this will throw
 		// an error, failing the call.
-		this.verifyBlobNotDeleted(blobId);
+		this.verifyBlobNotDeleted(localId);
 		// Let runtime know that the corresponding GC node was requested.
 		// Note that this will throw if the blob is inactive or tombstoned and throwing on incorrect usage
 		// is configured.
-		this.blobRequested(getGCNodePathFromBlobId(blobId));
+		this.blobRequested(getGCNodePathFromLocalId(localId));
 
-		const pending = this.pendingBlobs.get(blobId);
+		const pending = this.pendingBlobs.get(localId);
 		if (pending) {
 			return pending.blob;
 		}
 
-		let storageId: string;
-		if (this.runtime.attachState === AttachState.Detached) {
-			assert(this.redirectTable.has(blobId), 0x383 /* requesting unknown blobs */);
-
-			// Blobs created while the container is detached are stored in IDetachedBlobStorage.
-			// The 'IContainerStorageService.readBlob()' call below will retrieve these via localId.
-			storageId = blobId;
-		} else {
-			const attachedStorageId = this.redirectTable.get(blobId);
-			if (!payloadPending) {
-				// Only blob handles explicitly marked with pending payload are permitted to exist without
-				// yet knowing their storage id. Otherwise they must already be associated with a storage id.
-				assert(attachedStorageId !== undefined, 0x11f /* "requesting unknown blobs" */);
-			}
-			// If we didn't find it in the redirectTable, assume the attach op is coming eventually and wait.
-			// We do this even if the local client doesn't have the blob payloadPending flag enabled, in case a
-			// remote client does have it enabled. This wait may be infinite if the uploading client failed
-			// the upload and doesn't exist anymore.
-			storageId =
-				attachedStorageId ??
-				(await new Promise<string>((resolve) => {
-					const onProcessBlobAttach = (localId: string, _storageId: string): void => {
-						if (localId === blobId) {
-							this.internalEvents.off("processedBlobAttach", onProcessBlobAttach);
-							resolve(_storageId);
-						}
-					};
-					this.internalEvents.on("processedBlobAttach", onProcessBlobAttach);
-				}));
+		let storageId = this.redirectTable.get(localId);
+		if (storageId === undefined) {
+			// Only blob handles explicitly marked with pending payload are permitted to exist without
+			// yet knowing their storage id. Otherwise they must already be associated with a storage id.
+			// Handles for detached blobs are not payload pending.
+			assert(payloadPending, 0x11f /* "requesting unknown blobs" */);
+			// If we didn't find it in the redirectTable and it's payloadPending, assume the attach op is coming
+			// eventually and wait. We do this even if the local client doesn't have the blob payloadPending flag
+			// enabled, in case a remote client does have it enabled. This wait may be infinite if the uploading
+			// client failed the upload and doesn't exist anymore.
+			storageId = await new Promise<string>((resolve) => {
+				const onProcessBlobAttach = (_localId: string, _storageId: string): void => {
+					if (_localId === localId) {
+						this.internalEvents.off("processedBlobAttach", onProcessBlobAttach);
+						resolve(_storageId);
+					}
+				};
+				this.internalEvents.on("processedBlobAttach", onProcessBlobAttach);
+			});
 		}
 
 		return PerformanceEvent.timedExecAsync(
@@ -417,7 +420,7 @@ export class BlobManager {
 				}
 			: undefined;
 		return new BlobHandle(
-			getGCNodePathFromBlobId(localId),
+			getGCNodePathFromLocalId(localId),
 			this.routeContext,
 			async () => this.getBlob(localId, false),
 			false, // payloadPending
@@ -428,11 +431,13 @@ export class BlobManager {
 	private async createBlobDetached(
 		blob: ArrayBufferLike,
 	): Promise<IFluidHandleInternalPayloadPending<ArrayBufferLike>> {
+		const localId = this.localIdGenerator();
 		// Blobs created while the container is detached are stored in IDetachedBlobStorage.
-		// The 'IContainerStorageService.createBlob()' call below will respond with a localId.
-		const response = await this.storage.createBlob(blob);
-		this.setRedirection(response.id, undefined);
-		return this.getBlobHandle(response.id);
+		// The 'IContainerStorageService.createBlob()' call below will respond with a pseudo storage ID.
+		// That pseudo storage ID will be replaced with the real storage ID at attach time.
+		const { id: detachedStorageId } = await this.storage.createBlob(blob);
+		this.setRedirection(localId, detachedStorageId);
+		return this.getBlobHandle(localId);
 	}
 
 	public async createBlob(
@@ -467,7 +472,7 @@ export class BlobManager {
 
 		// Create a local ID for the blob. After uploading it to storage and before returning it, a local ID to
 		// storage ID mapping is created.
-		const localId = this.localBlobIdGenerator();
+		const localId = this.localIdGenerator();
 		const pendingEntry: PendingBlob = {
 			blob,
 			handleP: new Deferred(),
@@ -494,10 +499,10 @@ export class BlobManager {
 	private createBlobWithPayloadPending(
 		blob: ArrayBufferLike,
 	): IFluidHandleInternalPayloadPending<ArrayBufferLike> {
-		const localId = this.localBlobIdGenerator();
+		const localId = this.localIdGenerator();
 
 		const blobHandle = new BlobHandle(
-			getGCNodePathFromBlobId(localId),
+			getGCNodePathFromLocalId(localId),
 			this.routeContext,
 			async () => blob,
 			true, // payloadPending
@@ -581,7 +586,7 @@ export class BlobManager {
 	 * Set up a mapping in the redirect table from fromId to toId. Also, notify the runtime that a reference is added
 	 * which is required for GC.
 	 */
-	private setRedirection(fromId: string, toId: string | undefined): void {
+	private setRedirection(fromId: string, toId: string): void {
 		this.redirectTable.set(fromId, toId);
 	}
 
@@ -630,7 +635,7 @@ export class BlobManager {
 		if (!entry.opsent) {
 			this.sendBlobAttachOp(localId, response.id);
 		}
-		const storageIds = getStorageIds(this.redirectTable, this.runtime.attachState);
+		const storageIds = getStorageIds(this.redirectTable);
 		if (storageIds.has(response.id)) {
 			// The blob is de-duped. Set up a local ID to storage ID mapping and return the blob. Since this is
 			// an existing blob, we don't have to wait for the op to be ack'd since this step has already
@@ -663,7 +668,7 @@ export class BlobManager {
 	 */
 	public reSubmit(metadata: Record<string, unknown> | undefined): void {
 		assert(isBlobMetadata(metadata), 0xc01 /* Expected blob metadata for a BlobAttach op */);
-		const { localId, blobId } = metadata;
+		const { localId, blobId: storageId } = metadata;
 		// Any blob that we're actively trying to advance to attached state must have a
 		// pendingBlobs entry. Decline to resubmit for anything else.
 		// For example, we might be asked to resubmit stashed ops for blobs that never had
@@ -671,7 +676,7 @@ export class BlobManager {
 		// try to attach them since they won't be accessible to the customer and would just
 		// be considered garbage immediately.
 		if (this.pendingBlobs.has(localId)) {
-			this.sendBlobAttachOp(localId, blobId);
+			this.sendBlobAttachOp(localId, storageId);
 		}
 	}
 
@@ -680,19 +685,19 @@ export class BlobManager {
 			isBlobMetadata(message.metadata),
 			0xc02 /* Expected blob metadata for a BlobAttach op */,
 		);
-		const { localId, blobId } = message.metadata;
+		const { localId, blobId: storageId } = message.metadata;
 		const pendingEntry = this.pendingBlobs.get(localId);
 		if (pendingEntry?.abortSignal?.aborted) {
 			this.deletePendingBlob(localId);
 			return;
 		}
 
-		this.setRedirection(localId, blobId);
+		this.setRedirection(localId, storageId);
 		// set identity (id -> id) entry
-		this.setRedirection(blobId, blobId);
+		this.setRedirection(storageId, storageId);
 
 		if (local) {
-			const waitingBlobs = this.opsInFlight.get(blobId);
+			const waitingBlobs = this.opsInFlight.get(storageId);
 			if (waitingBlobs !== undefined) {
 				// For each op corresponding to this storage ID that we are waiting for, resolve the pending blob.
 				// This is safe because the server will keep the blob alive and the op containing the local ID to
@@ -703,14 +708,14 @@ export class BlobManager {
 						entry !== undefined,
 						0x38f /* local online BlobAttach op with no pending blob entry */,
 					);
-					this.setRedirection(pendingLocalId, blobId);
+					this.setRedirection(pendingLocalId, storageId);
 					entry.acked = true;
 					const blobHandle = this.getBlobHandle(pendingLocalId);
 					blobHandle.notifyShared();
 					entry.handleP.resolve(blobHandle);
 					this.deletePendingBlobMaybe(pendingLocalId);
 				}
-				this.opsInFlight.delete(blobId);
+				this.opsInFlight.delete(storageId);
 			}
 			const localEntry = this.pendingBlobs.get(localId);
 			if (localEntry) {
@@ -721,11 +726,11 @@ export class BlobManager {
 				this.deletePendingBlobMaybe(localId);
 			}
 		}
-		this.internalEvents.emit("processedBlobAttach", localId, blobId);
+		this.internalEvents.emit("processedBlobAttach", localId, storageId);
 	}
 
 	public summarize(telemetryContext?: ITelemetryContext): ISummaryTreeWithStats {
-		return summarizeBlobManagerState(this.redirectTable, this.runtime.attachState);
+		return summarizeBlobManagerState(this.redirectTable);
 	}
 
 	/**
@@ -737,13 +742,12 @@ export class BlobManager {
 	public getGCData(fullGC: boolean = false): IGarbageCollectionData {
 		const gcData: IGarbageCollectionData = { gcNodes: {} };
 		for (const [localId, storageId] of this.redirectTable) {
-			assert(!!storageId, 0x390 /* Must be attached to get GC data */);
-			// Only return local ids as GC nodes because a blob can only be referenced via its local id. The storage
-			// id entries have the same key and value, ignore them.
-			// The outbound routes are empty because a blob node cannot reference other nodes. It can only be referenced
-			// by adding its handle to a referenced DDS.
+			// Don't report the identity mappings to GC - these exist to service old handles that referenced the storage
+			// IDs directly. We'll implicitly clean them up if all of their localId references get GC'd first.
 			if (localId !== storageId) {
-				gcData.gcNodes[getGCNodePathFromBlobId(localId)] = [];
+				// The outbound routes are empty because a blob node cannot reference other nodes. It can only be referenced
+				// by adding its handle to a referenced DDS.
+				gcData.gcNodes[getGCNodePathFromLocalId(localId)] = [];
 			}
 		}
 		return gcData;
@@ -764,58 +768,55 @@ export class BlobManager {
 	 * Delete blobs with the given routes from the redirect table.
 	 *
 	 * @remarks
-	 * The routes are GC nodes paths of format -`/<blobManagerBasePath>/<blobId>`. The blob ids are all local ids.
+	 * The routes are GC nodes paths of format -`/<blobManagerBasePath>/<localId>`.
 	 * Deleting the blobs involves 2 steps:
 	 *
 	 * 1. The redirect table entry for the local ids are deleted.
 	 *
-	 * 2. If the storage ids corresponding to the deleted local ids are not in-use anymore, the redirect table entries
-	 * for the storage ids are deleted as well.
+	 * 2. If the storage ids corresponding to the deleted local ids are not referenced by any further local ids, the
+	 * identity mappings in the redirect table are deleted as well.
 	 *
 	 * Note that this does not delete the blobs from storage service immediately. Deleting the blobs from redirect table
-	 * will remove them the next summary. The service would them delete them some time in the future.
+	 * will ensure we don't create an attachment blob for them at the next summary. The service would then delete them
+	 * some time in the future.
 	 */
 	private deleteBlobsFromRedirectTable(blobRoutes: readonly string[]): void {
-		if (blobRoutes.length === 0) {
-			return;
-		}
-
-		// This tracks the storage ids of local ids that are deleted. After the local ids have been deleted, if any of
-		// these storage ids are unused, they will be deleted as well.
+		// maybeUnusedStorageIds is used to compute the set of storage IDs that *used to have a local ID*, but that
+		// local ID is being deleted.
 		const maybeUnusedStorageIds: Set<string> = new Set();
 		for (const route of blobRoutes) {
-			const blobId = getBlobIdFromGCNodePath(route);
+			const localId = getLocalIdFromGCNodePath(route);
 			// If the blob hasn't already been deleted, log an error because this should never happen.
 			// If the blob has already been deleted, log a telemetry event. This can happen because multiple GC
 			// sweep ops can contain the same data store. It would be interesting to track how often this happens.
 			const alreadyDeleted = this.isBlobDeleted(route);
-			if (!this.redirectTable.has(blobId)) {
+			const storageId = this.redirectTable.get(localId);
+			if (storageId === undefined) {
 				this.mc.logger.sendTelemetryEvent({
 					eventName: "DeletedAttachmentBlobNotFound",
 					category: alreadyDeleted ? "generic" : "error",
-					blobId,
+					blobId: localId,
 					details: { alreadyDeleted },
 				});
 				continue;
 			}
-			const storageId = this.redirectTable.get(blobId);
-			assert(!!storageId, 0x5bb /* Must be attached to run GC */);
 			maybeUnusedStorageIds.add(storageId);
-			this.redirectTable.delete(blobId);
+			this.redirectTable.delete(localId);
 		}
 
-		// Find out storage ids that are in-use and remove them from maybeUnusedStorageIds. A storage id is in-use if
-		// the redirect table has a local id -> storage id entry for it.
-		for (const [localId, storageId] of this.redirectTable.entries()) {
-			assert(!!storageId, 0x5bc /* Must be attached to run GC */);
-			// For every storage id, the redirect table has a id -> id entry. These do not make the storage id in-use.
-			if (maybeUnusedStorageIds.has(storageId) && localId !== storageId) {
+		// Remove any storage IDs that still have local IDs referring to them (excluding the identity mapping).
+		for (const [localId, storageId] of this.redirectTable) {
+			if (localId !== storageId) {
 				maybeUnusedStorageIds.delete(storageId);
 			}
 		}
 
-		// For unused storage ids, delete their id -> id entries from the redirect table.
-		// This way they'll be absent from the next summary, and the service is free to delete them from storage.
+		// Now delete any identity mappings (storage ID -> storage ID) from the redirect table that used to be
+		// referenced by a distinct local ID. This way they'll be absent from the next summary, and the service
+		// is free to delete them from storage.
+		// WARNING: This can potentially delete identity mappings that are still referenced, if storage deduping
+		// has let us add a local ID -> storage ID mapping that is later deleted.  AB#47337 tracks this issue
+		// and possible solutions.
 		for (const storageId of maybeUnusedStorageIds) {
 			this.redirectTable.delete(storageId);
 		}
@@ -825,12 +826,12 @@ export class BlobManager {
 	 * Verifies that the blob with given id is not deleted, i.e., it has not been garbage collected. If the blob is GC'd,
 	 * log an error and throw if necessary.
 	 */
-	private verifyBlobNotDeleted(blobId: string): void {
-		if (!this.isBlobDeleted(getGCNodePathFromBlobId(blobId))) {
+	private verifyBlobNotDeleted(localId: string): void {
+		if (!this.isBlobDeleted(getGCNodePathFromLocalId(localId))) {
 			return;
 		}
 
-		const request = { url: blobId };
+		const request = { url: localId };
 		const error = responseToException(
 			createResponseError(404, `Blob was deleted`, request),
 			request,
@@ -846,22 +847,36 @@ export class BlobManager {
 		throw error;
 	}
 
-	public setRedirectTable(table: Map<string, string>): void {
+	/**
+	 * Called in detached state just prior to attaching, this will update the redirect table by
+	 * converting the pseudo storage IDs into real storage IDs using the provided detachedStorageTable.
+	 * The provided table must have exactly the same set of pseudo storage IDs as are found in the redirect table.
+	 * @param detachedStorageTable - A map of pseudo storage IDs to real storage IDs.
+	 */
+	public readonly patchRedirectTable = (detachedStorageTable: Map<string, string>): void => {
 		assert(
 			this.runtime.attachState === AttachState.Detached,
 			0x252 /* "redirect table can only be set in detached container" */,
 		);
+		// The values of the redirect table are the pseudo storage IDs, which are the keys of the
+		// detachedStorageTable. We expect to have a many:1 mapping from local IDs to pseudo
+		// storage IDs (many in the case that the storage dedupes the blob).
 		assert(
-			this.redirectTable.size === table.size,
+			new Set(this.redirectTable.values()).size === detachedStorageTable.size,
 			0x391 /* Redirect table size must match BlobManager's local ID count */,
 		);
-		for (const [localId, storageId] of table) {
-			assert(this.redirectTable.has(localId), 0x254 /* "unrecognized id in redirect table" */);
-			this.setRedirection(localId, storageId);
+		// Taking a snapshot of the redirect table entries before iterating, because
+		// we will be adding identity mappings to the the redirect table as we iterate
+		// and we don't want to include those in the iteration.
+		const redirectTableEntries = [...this.redirectTable.entries()];
+		for (const [localId, detachedStorageId] of redirectTableEntries) {
+			const newStorageId = detachedStorageTable.get(detachedStorageId);
+			assert(newStorageId !== undefined, "Couldn't find a matching storage ID");
+			this.setRedirection(localId, newStorageId);
 			// set identity (id -> id) entry
-			this.setRedirection(storageId, storageId);
+			this.setRedirection(newStorageId, newStorageId);
 		}
-	}
+	};
 
 	/**
 	 * To be used in getPendingLocalState flow. Get a serializable record of the blobs that are
@@ -896,17 +911,17 @@ export class BlobManager {
 }
 
 /**
- * For a blobId, returns its path in GC's graph. The node path is of the format `/<blobManagerBasePath>/<blobId>`.
+ * For a localId, returns its path in GC's graph. The node path is of the format `/<blobManagerBasePath>/<localId>`.
  * This path must match the path of the blob handle returned by the createBlob API because blobs are marked
  * referenced by storing these handles in a referenced DDS.
  */
-const getGCNodePathFromBlobId = (blobId: string): string =>
-	`/${blobManagerBasePath}/${blobId}`;
+const getGCNodePathFromLocalId = (localId: string): string =>
+	`/${blobManagerBasePath}/${localId}`;
 
 /**
- * For a given GC node path, return the blobId. The node path is of the format `/<basePath>/<blobId>`.
+ * For a given GC node path, return the localId. The node path is of the format `/<basePath>/<localId>`.
  */
-const getBlobIdFromGCNodePath = (nodePath: string): string => {
+const getLocalIdFromGCNodePath = (nodePath: string): string => {
 	const pathParts = nodePath.split("/");
 	assert(areBlobPathParts(pathParts), 0x5bd /* Invalid blob node path */);
 	return pathParts[2];