@fluidframework/container-runtime 2.51.0-347100 → 2.52.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @fluidframework/container-runtime
 
+## 2.52.0
+
+### Minor Changes
+
+- Moved MinimumVersionForCollab to @fluidframework/runtime-definitions ([#25059](https://github.com/microsoft/FluidFramework/pull/25059)) [4a7b370667](https://github.com/microsoft/FluidFramework/commit/4a7b3706675139af6d8aaae707b96b74081f1fc8)
+
+  MinimumVersionForCollab has been moved from @fluidframework/container-runtime to @fluidframework/runtime-definitions.
+  The export in @fluidframework/container-runtime is now deprecated and will be removed in a future version.
+  Consumers should import it from @fluidframework/runtime-definitions going forward.
+
+## 2.51.0
+
+Dependency updates only.
+
 ## 2.50.0
 
 Dependency updates only.

package/api-report/container-runtime.legacy.alpha.api.md

@@ -346,8 +346,7 @@ export interface LoadContainerRuntimeParams {
     runtimeOptions?: IContainerRuntimeOptions;
 }
 
-// @alpha @legacy
-export type MinimumVersionForCollab = `${1 | 2}.${bigint}.${bigint}` | `${1 | 2}.${bigint}.${bigint}-${string}`;
+export { MinimumVersionForCollab }
 
 // @alpha @deprecated @legacy (undocumented)
 export type OmitAttributesVersions<T> = Omit<T, "snapshotFormatVersion" | "summaryFormatVersion">;

package/dist/blobManager/blobManager.d.ts

@@ -2,9 +2,9 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+import { type IContainerStorageService } from "@fluidframework/container-definitions/internal";
 import { IContainerRuntime, IContainerRuntimeEvents } from "@fluidframework/container-runtime-definitions/internal";
 import type { IEventProvider, IFluidHandleContext, IFluidHandleInternalPayloadPending, ILocalFluidHandle, ILocalFluidHandleEvents, Listenable, PayloadState } from "@fluidframework/core-interfaces/internal";
-import { IDocumentStorageService, ICreateBlobResponse } from "@fluidframework/driver-definitions/internal";
 import { IGarbageCollectionData, ISummaryTreeWithStats, ITelemetryContext, type ISequencedMessageEnvelope } from "@fluidframework/runtime-definitions/internal";
 import { FluidHandleBase } from "@fluidframework/runtime-utils/internal";
 import { type IBlobManagerLoadInfo } from "./blobManagerSnapSum.js";
@@ -77,20 +77,17 @@ export declare class BlobManager {
      */
     private readonly opsInFlight;
     private readonly sendBlobAttachOp;
-    private stopAttaching;
     private readonly routeContext;
     private readonly storage;
     private readonly blobRequested;
     private readonly isBlobDeleted;
     private readonly runtime;
     private readonly localBlobIdGenerator;
-    private readonly pendingStashedBlobs;
-    readonly stashedBlobsUploadP: Promise<(void | ICreateBlobResponse)[]>;
     private readonly createBlobPayloadPending;
     constructor(props: {
         readonly routeContext: IFluidHandleContext;
         blobManagerLoadInfo: IBlobManagerLoadInfo;
-        readonly storage: IDocumentStorageService;
+        readonly storage: Pick<IContainerStorageService, "createBlob" | "readBlob">;
         /**
          * Submit a BlobAttach op. When a blob is uploaded, there is a short grace period before which the blob is
          * deleted. The BlobAttach op notifies the server that blob is in use. The server will then not delete the
@@ -101,7 +98,7 @@ export declare class BlobManager {
          * knowledge of which they cannot request the blob from storage. It's important that this op is sequenced
          * before any ops that reference the local ID, otherwise, an invalid handle could be added to the document.
          */
-        sendBlobAttachOp: (localId: string, storageId?: string) => void;
+        sendBlobAttachOp: (localId: string, storageId: string) => void;
         readonly blobRequested: (blobPath: string) => void;
         readonly isBlobDeleted: (blobPath: string) => boolean;
         readonly runtime: IBlobManagerRuntime;
@@ -112,7 +109,6 @@ export declare class BlobManager {
     get allBlobsAttached(): boolean;
     get hasPendingBlobs(): boolean;
     private createAbortError;
-    hasPendingStashedUploads(): boolean;
     hasBlob(blobId: string): boolean;
     /**
      * Retrieve the blob with the given local blob id.
@@ -179,6 +175,18 @@ export declare class BlobManager {
      */
     private verifyBlobNotDeleted;
     setRedirectTable(table: Map<string, string>): void;
+    /**
+     * To be used in getPendingLocalState flow. Get a serializable record of the blobs that are
+     * pending upload and/or their BlobAttach op, which can be given to a new BlobManager to
+     * resume work.
+     *
+     * @privateRemarks
+     * For now, we don't track any pending blobs since the getPendingBlobs flow doesn't enable
+     * restoring to a state where an accessible handle has been stored by the customer (and we'll
+     * just drop any BlobAttach ops on the ground during reSubmit). However, once we add support
+     * for payload-pending handles, this will return the blobs associated with those handles.
+     */
+    getPendingBlobs(): IPendingBlobs | undefined;
     /**
      * Part of container serialization when imminent closure is enabled (Currently when calling closeAndGetPendingLocalState).
      * This asynchronous function resolves all pending createBlob calls and waits for each blob

package/dist/blobManager/blobManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blobManager.d.ts","sourceRoot":"","sources":["../../src/blobManager/blobManager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"blobManager.d.ts","sourceRoot":"","sources":["../../src/blobManager/blobManager.ts"],"names":[],"mappings":"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"}

package/dist/blobManager/blobManager.js

@@ -6,12 +6,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isBlobPath = exports.BlobManager = exports.blobManagerBasePath = exports.BlobHandle = void 0;
 const client_utils_1 = require("@fluid-internal/client-utils");
-const container_definitions_1 = require("@fluidframework/container-definitions");
-const internal_1 = require("@fluidframework/core-utils/internal");
-const internal_2 = require("@fluidframework/driver-utils/internal");
-const internal_3 = require("@fluidframework/runtime-utils/internal");
-const internal_4 = require("@fluidframework/telemetry-utils/internal");
+const internal_1 = require("@fluidframework/container-definitions/internal");
+const internal_2 = require("@fluidframework/core-utils/internal");
+const internal_3 = require("@fluidframework/driver-utils/internal");
+const internal_4 = require("@fluidframework/runtime-utils/internal");
+const internal_5 = require("@fluidframework/telemetry-utils/internal");
 const uuid_1 = require("uuid");
+const metadata_js_1 = require("../metadata.js");
 const blobManagerSnapSum_js_1 = require("./blobManagerSnapSum.js");
 /**
  * This class represents blob (long string)
@@ -20,7 +21,7 @@ const blobManagerSnapSum_js_1 = require("./blobManagerSnapSum.js");
  * DataObject.request() recognizes requests in the form of `/blobs/<id>`
  * and loads blob.
  */
-class BlobHandle extends internal_3.FluidHandleBase {
+class BlobHandle extends internal_4.FluidHandleBase {
     get isAttached() {
         return this.routeContext.isAttached && this.attached;
     }
@@ -50,7 +51,7 @@ class BlobHandle extends internal_3.FluidHandleBase {
             this._payloadShareError = error;
             this._events?.emit("payloadShareFailed", error);
         };
-        this.absolutePath = (0, internal_3.generateHandleContextPath)(path, this.routeContext);
+        this.absolutePath = (0, internal_4.generateHandleContextPath)(path, this.routeContext);
     }
     attachGraph() {
         if (!this.attached) {
@@ -60,12 +61,6 @@ class BlobHandle extends internal_3.FluidHandleBase {
     }
 }
 exports.BlobHandle = BlobHandle;
-const stashedPendingBlobOverrides = {
-    stashedUpload: true,
-    storageId: undefined,
-    minTTLInSeconds: undefined,
-    uploadTime: undefined,
-};
 exports.blobManagerBasePath = "_blobs";
 class BlobManager {
     get events() {
@@ -84,9 +79,7 @@ class BlobManager {
          * because we know that the server will not delete the blob corresponding to that storage ID.
          */
         this.opsInFlight = new Map();
-        this.stopAttaching = false;
-        this.pendingStashedBlobs = new Map();
-        const { routeContext, blobManagerLoadInfo, storage, sendBlobAttachOp, blobRequested, isBlobDeleted, runtime, stashedBlobs, localBlobIdGenerator, createBlobPayloadPending, } = props;
+        const { routeContext, blobManagerLoadInfo, storage, sendBlobAttachOp, blobRequested, isBlobDeleted, runtime, localBlobIdGenerator, createBlobPayloadPending, } = props;
         this.routeContext = routeContext;
         this.storage = storage;
         this.blobRequested = blobRequested;
@@ -94,47 +87,14 @@ class BlobManager {
         this.runtime = runtime;
         this.localBlobIdGenerator = localBlobIdGenerator ?? uuid_1.v4;
         this.createBlobPayloadPending = createBlobPayloadPending;
-        this.mc = (0, internal_4.createChildMonitoringContext)({
+        this.mc = (0, internal_5.createChildMonitoringContext)({
             logger: this.runtime.baseLogger,
             namespace: "BlobManager",
         });
         this.redirectTable = (0, blobManagerSnapSum_js_1.toRedirectTable)(blobManagerLoadInfo, this.mc.logger, this.runtime.attachState);
-        // Begin uploading stashed blobs from previous container instance
-        for (const [localId, entry] of Object.entries(stashedBlobs ?? {})) {
-            const { acked, storageId, minTTLInSeconds, uploadTime } = entry;
-            const blob = (0, client_utils_1.stringToBuffer)(entry.blob, "base64");
-            const pendingEntry = {
-                blob,
-                opsent: true,
-                handleP: new internal_1.Deferred(),
-                storageId,
-                uploadP: undefined,
-                uploadTime,
-                minTTLInSeconds,
-                attached: true,
-                acked,
-            };
-            this.pendingBlobs.set(localId, pendingEntry);
-            if (storageId !== undefined && minTTLInSeconds && uploadTime) {
-                const timeLapseSinceLocalUpload = (Date.now() - uploadTime) / 1000;
-                // stashed entries with more than half-life in storage will not be reuploaded
-                if (minTTLInSeconds - timeLapseSinceLocalUpload > minTTLInSeconds / 2) {
-                    continue;
-                }
-            }
-            this.pendingStashedBlobs.set(localId, this.uploadBlob(localId, blob));
-            this.pendingBlobs.set(localId, {
-                ...pendingEntry,
-                ...stashedPendingBlobOverrides,
-                uploadP: this.pendingStashedBlobs.get(localId),
-            });
-        }
-        this.stashedBlobsUploadP = internal_4.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "BlobUploadProcessStashedChanges", count: this.pendingStashedBlobs.size }, async () => Promise.all(this.pendingStashedBlobs.values()), { start: true, end: true }).finally(() => {
-            this.pendingStashedBlobs.clear();
-        });
         this.sendBlobAttachOp = (localId, blobId) => {
             const pendingEntry = this.pendingBlobs.get(localId);
-            (0, internal_1.assert)(pendingEntry !== undefined, 0x725 /* Must have pending blob entry for upcoming op */);
+            (0, internal_2.assert)(pendingEntry !== undefined, 0x725 /* Must have pending blob entry for upcoming op */);
             if (pendingEntry?.uploadTime && pendingEntry?.minTTLInSeconds) {
                 const secondsSinceUpload = (Date.now() - pendingEntry.uploadTime) / 1000;
                 const expired = pendingEntry.minTTLInSeconds - secondsSinceUpload < 0;
@@ -170,18 +130,15 @@ class BlobManager {
         return true;
     }
     get hasPendingBlobs() {
-        return ((this.runtime.attachState !== container_definitions_1.AttachState.Attached && this.redirectTable.size > 0) ||
+        return ((this.runtime.attachState !== internal_1.AttachState.Attached && this.redirectTable.size > 0) ||
             this.pendingBlobs.size > 0);
     }
     createAbortError(pending) {
-        return new internal_4.LoggingError("uploadBlob aborted", {
+        return new internal_5.LoggingError("uploadBlob aborted", {
             acked: pending?.acked,
             uploadTime: pending?.uploadTime,
         });
     }
-    hasPendingStashedUploads() {
-        return [...this.pendingBlobs.values()].some((e) => e.stashedUpload === true);
-    }
     hasBlob(blobId) {
         return this.redirectTable.get(blobId) !== undefined;
     }
@@ -204,10 +161,10 @@ class BlobManager {
             return pending.blob;
         }
         let storageId;
-        if (this.runtime.attachState === container_definitions_1.AttachState.Detached) {
-            (0, internal_1.assert)(this.redirectTable.has(blobId), 0x383 /* requesting unknown blobs */);
+        if (this.runtime.attachState === internal_1.AttachState.Detached) {
+            (0, internal_2.assert)(this.redirectTable.has(blobId), 0x383 /* requesting unknown blobs */);
             // Blobs created while the container is detached are stored in IDetachedBlobStorage.
-            // The 'IDocumentStorageService.readBlob()' call below will retrieve these via localId.
+            // The 'IContainerStorageService.readBlob()' call below will retrieve these via localId.
             storageId = blobId;
         }
         else {
@@ -215,7 +172,7 @@ class BlobManager {
             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.
-                (0, internal_1.assert)(attachedStorageId !== undefined, 0x11f /* "requesting unknown blobs" */);
+                (0, internal_2.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
@@ -233,7 +190,7 @@ class BlobManager {
                         this.internalEvents.on("processedBlobAttach", onProcessBlobAttach);
                     }));
         }
-        return internal_4.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "AttachmentReadBlob", id: storageId }, async (event) => {
+        return internal_5.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "AttachmentReadBlob", id: storageId }, async (event) => {
             return this.storage.readBlob(storageId).catch((error) => {
                 if (this.runtime.disposed) {
                     // If the runtime is disposed, this is not an error we care to track, it's expected behavior.
@@ -244,7 +201,7 @@ class BlobManager {
         }, { end: true, cancel: "error" });
     }
     getBlobHandle(localId) {
-        (0, internal_1.assert)(this.redirectTable.has(localId) || this.pendingBlobs.has(localId), 0x384 /* requesting handle for unknown blob */);
+        (0, internal_2.assert)(this.redirectTable.has(localId) || this.pendingBlobs.has(localId), 0x384 /* requesting handle for unknown blob */);
         const pending = this.pendingBlobs.get(localId);
         // Create a callback function for once the handle has been attached
         const callback = pending
@@ -260,21 +217,21 @@ class BlobManager {
     }
     async createBlobDetached(blob) {
         // Blobs created while the container is detached are stored in IDetachedBlobStorage.
-        // The 'IDocumentStorageService.createBlob()' call below will respond with a localId.
+        // 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);
     }
     async createBlob(blob, signal) {
-        if (this.runtime.attachState === container_definitions_1.AttachState.Detached) {
+        if (this.runtime.attachState === internal_1.AttachState.Detached) {
             return this.createBlobDetached(blob);
         }
-        if (this.runtime.attachState === container_definitions_1.AttachState.Attaching) {
+        if (this.runtime.attachState === internal_1.AttachState.Attaching) {
             // blob upload is not supported in "Attaching" state
             this.mc.logger.sendTelemetryEvent({ eventName: "CreateBlobWhileAttaching" });
             await new Promise((resolve) => this.runtime.once("attached", resolve));
         }
-        (0, internal_1.assert)(this.runtime.attachState === container_definitions_1.AttachState.Attached, 0x385 /* For clarity and paranoid defense against adding future attachment states */);
+        (0, internal_2.assert)(this.runtime.attachState === internal_1.AttachState.Attached, 0x385 /* For clarity and paranoid defense against adding future attachment states */);
         return this.createBlobPayloadPending
             ? this.createBlobWithPayloadPending(blob)
             : this.createBlobLegacy(blob, signal);
@@ -288,7 +245,7 @@ class BlobManager {
         const localId = this.localBlobIdGenerator();
         const pendingEntry = {
             blob,
-            handleP: new internal_1.Deferred(),
+            handleP: new internal_2.Deferred(),
             uploadP: this.uploadBlob(localId, blob),
             attached: false,
             acked: false,
@@ -312,7 +269,7 @@ class BlobManager {
         () => {
             const pendingEntry = {
                 blob,
-                handleP: new internal_1.Deferred(),
+                handleP: new internal_2.Deferred(),
                 uploadP: this.uploadBlob(localId, blob),
                 attached: true,
                 acked: false,
@@ -337,15 +294,15 @@ class BlobManager {
         return blobHandle;
     }
     async uploadBlob(localId, blob) {
-        return (0, internal_2.runWithRetry)(async () => {
+        return (0, internal_3.runWithRetry)(async () => {
             try {
                 return await this.storage.createBlob(blob);
             }
             catch (error) {
                 const entry = this.pendingBlobs.get(localId);
-                (0, internal_1.assert)(!!entry, 0x387 /* Must have pending blob entry for blob which failed to upload */);
-                if (entry.opsent && !(0, internal_2.canRetryOnError)(error)) {
-                    throw (0, internal_4.wrapError)(error, () => new internal_4.LoggingError(`uploadBlob error`, { canRetry: true }));
+                (0, internal_2.assert)(!!entry, 0x387 /* Must have pending blob entry for blob which failed to upload */);
+                if (entry.opsent && !(0, internal_3.canRetryOnError)(error)) {
+                    throw (0, internal_5.wrapError)(error, () => new internal_5.LoggingError(`uploadBlob error`, { canRetry: true }));
                 }
                 throw error;
             }
@@ -389,17 +346,8 @@ class BlobManager {
     }
     onUploadResolve(localId, response) {
         const entry = this.pendingBlobs.get(localId);
-        if (entry === undefined && this.pendingStashedBlobs.has(localId)) {
-            // The blob was already processed and deleted. This can happen if the blob was reuploaded by
-            // the stashing process and the original upload was processed before the stashed upload.
-            this.mc.logger.sendTelemetryEvent({
-                eventName: "StashedBlobAlreadyProcessed",
-                localId,
-            });
-            return;
-        }
-        (0, internal_1.assert)(entry !== undefined, 0x6c8 /* pending blob entry not found for uploaded blob */);
-        if ((entry.abortSignal?.aborted === true && !entry.opsent) || this.stopAttaching) {
+        (0, internal_2.assert)(entry !== undefined, 0x6c8 /* pending blob entry not found for uploaded blob */);
+        if (entry.abortSignal?.aborted === true && !entry.opsent) {
             this.mc.logger.sendTelemetryEvent({
                 eventName: "BlobAborted",
                 localId,
@@ -407,8 +355,7 @@ class BlobManager {
             this.deletePendingBlob(localId);
             return;
         }
-        (0, internal_1.assert)(entry.storageId === undefined, 0x386 /* Must have pending blob entry for uploaded blob */);
-        entry.stashedUpload = undefined;
+        (0, internal_2.assert)(entry.storageId === undefined, 0x386 /* Must have pending blob entry for uploaded blob */);
         entry.storageId = response.id;
         entry.uploadTime = Date.now();
         entry.minTTLInSeconds = response.minTTLInSeconds;
@@ -452,38 +399,29 @@ class BlobManager {
      * @param metadata - op metadata containing storage and/or local IDs
      */
     reSubmit(metadata) {
-        (0, internal_1.assert)(!!metadata, 0x38b /* Resubmitted ops must have metadata */);
+        (0, internal_2.assert)((0, metadata_js_1.isBlobMetadata)(metadata), 0xc01 /* Expected blob metadata for a BlobAttach op */);
         const { localId, blobId } = metadata;
-        (0, internal_1.assert)(localId !== undefined, 0x50d /* local ID not available on reSubmit */);
-        const pendingEntry = this.pendingBlobs.get(localId);
-        if (!blobId) {
-            // We submitted this op while offline. The blob should have been uploaded by now.
-            (0, internal_1.assert)(pendingEntry?.opsent === true && !!pendingEntry?.storageId, 0x38d /* blob must be uploaded before resubmitting BlobAttach op */);
-            return this.sendBlobAttachOp(localId, pendingEntry?.storageId);
+        // 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
+        // their handle attached - these won't have a pendingBlobs entry and we shouldn't
+        // 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);
         }
-        return this.sendBlobAttachOp(localId, blobId);
     }
     processBlobAttachMessage(message, local) {
-        const localId = message.metadata?.localId;
-        const blobId = message.metadata?.blobId;
-        if (localId) {
-            const pendingEntry = this.pendingBlobs.get(localId);
-            if (pendingEntry?.abortSignal?.aborted) {
-                this.deletePendingBlob(localId);
-                return;
-            }
-        }
-        (0, internal_1.assert)(blobId !== undefined, 0x12a /* "Missing blob id on metadata" */);
-        // Set up a mapping from local ID to storage ID. This is crucial since without this the blob cannot be
-        // requested from the server.
-        // Note: The check for undefined is needed for back-compat when localId was not part of the BlobAttach op that
-        // was sent when online.
-        if (localId !== undefined) {
-            this.setRedirection(localId, blobId);
+        (0, internal_2.assert)((0, metadata_js_1.isBlobMetadata)(message.metadata), 0xc02 /* Expected blob metadata for a BlobAttach op */);
+        const { localId, blobId } = message.metadata;
+        const pendingEntry = this.pendingBlobs.get(localId);
+        if (pendingEntry?.abortSignal?.aborted) {
+            this.deletePendingBlob(localId);
+            return;
         }
+        this.setRedirection(localId, blobId);
         // set identity (id -> id) entry
         this.setRedirection(blobId, blobId);
-        (0, internal_1.assert)(localId !== undefined, 0x50e /* local ID not present in blob attach message */);
         if (local) {
             const waitingBlobs = this.opsInFlight.get(blobId);
             if (waitingBlobs !== undefined) {
@@ -492,7 +430,7 @@ class BlobManager {
                 // storage ID is already in flight and any op containing this local ID will be sequenced after that.
                 for (const pendingLocalId of waitingBlobs) {
                     const entry = this.pendingBlobs.get(pendingLocalId);
-                    (0, internal_1.assert)(entry !== undefined, 0x38f /* local online BlobAttach op with no pending blob entry */);
+                    (0, internal_2.assert)(entry !== undefined, 0x38f /* local online BlobAttach op with no pending blob entry */);
                     this.setRedirection(pendingLocalId, blobId);
                     entry.acked = true;
                     const blobHandle = this.getBlobHandle(pendingLocalId);
@@ -525,7 +463,7 @@ class BlobManager {
     getGCData(fullGC = false) {
         const gcData = { gcNodes: {} };
         for (const [localId, storageId] of this.redirectTable) {
-            (0, internal_1.assert)(!!storageId, 0x390 /* Must be attached to get GC data */);
+            (0, internal_2.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
@@ -584,14 +522,14 @@ class BlobManager {
                 continue;
             }
             const storageId = this.redirectTable.get(blobId);
-            (0, internal_1.assert)(!!storageId, 0x5bb /* Must be attached to run GC */);
+            (0, internal_2.assert)(!!storageId, 0x5bb /* Must be attached to run GC */);
             maybeUnusedStorageIds.add(storageId);
             this.redirectTable.delete(blobId);
         }
         // 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()) {
-            (0, internal_1.assert)(!!storageId, 0x5bc /* Must be attached to run GC */);
+            (0, internal_2.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) {
                 maybeUnusedStorageIds.delete(storageId);
@@ -612,7 +550,7 @@ class BlobManager {
             return;
         }
         const request = { url: blobId };
-        const error = (0, internal_3.responseToException)((0, internal_3.createResponseError)(404, `Blob was deleted`, request), request);
+        const error = (0, internal_4.responseToException)((0, internal_4.createResponseError)(404, `Blob was deleted`, request), request);
         // Only log deleted events. Tombstone events are logged by garbage collector.
         this.mc.logger.sendErrorEvent({
             eventName: "GC_Deleted_Blob_Requested",
@@ -621,15 +559,29 @@ class BlobManager {
         throw error;
     }
     setRedirectTable(table) {
-        (0, internal_1.assert)(this.runtime.attachState === container_definitions_1.AttachState.Detached, 0x252 /* "redirect table can only be set in detached container" */);
-        (0, internal_1.assert)(this.redirectTable.size === table.size, 0x391 /* Redirect table size must match BlobManager's local ID count */);
+        (0, internal_2.assert)(this.runtime.attachState === internal_1.AttachState.Detached, 0x252 /* "redirect table can only be set in detached container" */);
+        (0, internal_2.assert)(this.redirectTable.size === table.size, 0x391 /* Redirect table size must match BlobManager's local ID count */);
         for (const [localId, storageId] of table) {
-            (0, internal_1.assert)(this.redirectTable.has(localId), 0x254 /* "unrecognized id in redirect table" */);
+            (0, internal_2.assert)(this.redirectTable.has(localId), 0x254 /* "unrecognized id in redirect table" */);
             this.setRedirection(localId, storageId);
             // set identity (id -> id) entry
             this.setRedirection(storageId, storageId);
         }
     }
+    /**
+     * To be used in getPendingLocalState flow. Get a serializable record of the blobs that are
+     * pending upload and/or their BlobAttach op, which can be given to a new BlobManager to
+     * resume work.
+     *
+     * @privateRemarks
+     * For now, we don't track any pending blobs since the getPendingBlobs flow doesn't enable
+     * restoring to a state where an accessible handle has been stored by the customer (and we'll
+     * just drop any BlobAttach ops on the ground during reSubmit). However, once we add support
+     * for payload-pending handles, this will return the blobs associated with those handles.
+     */
+    getPendingBlobs() {
+        return undefined;
+    }
     /**
      * Part of container serialization when imminent closure is enabled (Currently when calling closeAndGetPendingLocalState).
      * This asynchronous function resolves all pending createBlob calls and waits for each blob
@@ -641,73 +593,7 @@ class BlobManager {
      * or undefined if no blobs were processed.
      */
     async attachAndGetPendingBlobs(stopBlobAttachingSignal) {
-        return internal_4.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "GetPendingBlobs" }, async () => {
-            if (this.pendingBlobs.size === 0) {
-                return;
-            }
-            const blobs = {};
-            const localBlobs = new Set();
-            // This while is used to stash blobs created while attaching and getting blobs
-            while (localBlobs.size < this.pendingBlobs.size) {
-                const attachHandlesP = [];
-                for (const [localId, entry] of this.pendingBlobs) {
-                    if (!localBlobs.has(entry)) {
-                        localBlobs.add(entry);
-                        // In order to follow natural blob creation flow we need to:
-                        // 1 send the blob attach op
-                        // 2 resolve the blob handle
-                        // 3 wait for op referencing the blob
-                        if (!entry.opsent) {
-                            this.sendBlobAttachOp(localId, entry.storageId);
-                        }
-                        // Resolving the blob handle to let hosts continue with their operations (it will resolve
-                        // original createBlob call) and let them attach the blob. This is a lie we told since the upload
-                        // hasn't finished yet, but it's fine since we will retry on rehydration.
-                        entry.handleP.resolve(this.getBlobHandle(localId));
-                        // Array of promises that will resolve when handles get attached.
-                        attachHandlesP.push(new Promise((resolve, reject) => {
-                            stopBlobAttachingSignal?.addEventListener("abort", () => {
-                                this.stopAttaching = true;
-                                reject(new Error("Operation aborted"));
-                            }, { once: true });
-                            const onHandleAttached = (attachedEntry) => {
-                                if (attachedEntry === entry) {
-                                    this.internalEvents.off("handleAttached", onHandleAttached);
-                                    resolve();
-                                }
-                            };
-                            if (entry.attached) {
-                                resolve();
-                            }
-                            else {
-                                this.internalEvents.on("handleAttached", onHandleAttached);
-                            }
-                        }));
-                    }
-                }
-                // Wait for all blobs to be attached. This is important, otherwise serialized container
-                // could send the blobAttach op without any op that references the blob, making it useless.
-                await Promise.allSettled(attachHandlesP);
-            }
-            for (const [localId, entry] of this.pendingBlobs) {
-                if (stopBlobAttachingSignal?.aborted && !entry.attached) {
-                    this.mc.logger.sendTelemetryEvent({
-                        eventName: "UnableToStashBlob",
-                        id: localId,
-                    });
-                    continue;
-                }
-                (0, internal_1.assert)(entry.attached === true, 0x790 /* stashed blob should be attached */);
-                blobs[localId] = {
-                    blob: (0, client_utils_1.bufferToString)(entry.blob, "base64"),
-                    storageId: entry.storageId,
-                    acked: entry.acked,
-                    minTTLInSeconds: entry.minTTLInSeconds,
-                    uploadTime: entry.uploadTime,
-                };
-            }
-            return Object.keys(blobs).length > 0 ? blobs : undefined;
-        });
+        throw new internal_5.UsageError("attachAndGetPendingBlobs is no longer supported");
     }
 }
 exports.BlobManager = BlobManager;
@@ -722,7 +608,7 @@ const getGCNodePathFromBlobId = (blobId) => `/${exports.blobManagerBasePath}/${b
  */
 const getBlobIdFromGCNodePath = (nodePath) => {
     const pathParts = nodePath.split("/");
-    (0, internal_1.assert)(areBlobPathParts(pathParts), 0x5bd /* Invalid blob node path */);
+    (0, internal_2.assert)(areBlobPathParts(pathParts), 0x5bd /* Invalid blob node path */);
     return pathParts[2];
 };
 /**