@fluidframework/container-loader 2.100.0 → 2.101.0

package/src/captureReferencedContents.ts

@@ -0,0 +1,446 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { bufferToString } from "@fluid-internal/client-utils";
+import type {
+	IDocumentStorageService,
+	ISequencedDocumentMessage,
+	ISnapshot,
+	ISnapshotTree,
+} from "@fluidframework/driver-definitions/internal";
+import { readAndParse } from "@fluidframework/driver-utils/internal";
+
+import type {
+	IBase64BlobContents,
+	ISerializableBlobContents,
+} from "./containerStorageAdapter.js";
+
+/**
+ * Wire-format constants this module needs to walk and filter snapshots.
+ * Authoritative definitions live in `container-runtime` and
+ * `runtime-definitions`; the values are duplicated here to avoid a
+ * loader → runtime layering dependency. A contract test in
+ * `packages/test/local-server-tests` asserts these match the authoritative
+ * values; do not change them in isolation.
+ *
+ * Authoritative sources:
+ * - `blobsTreeName`, `redirectTableBlobName`: `packages/runtime/container-runtime/src/blobManager/blobManagerSnapSum.ts`
+ * - `blobManagerBasePath`: `packages/runtime/container-runtime/src/blobManager/blobManager.ts`
+ * - `gcTreeKey`, `gcBlobPrefix`, `gcTombstoneBlobKey`, `gcDeletedBlobKey`: `packages/runtime/runtime-definitions/src/garbageCollectionDefinitions.ts`
+ *
+ * @internal
+ */
+export const wireFormatConstants = {
+	blobsTreeName: ".blobs",
+	redirectTableBlobName: ".redirectTable",
+	blobManagerBasePath: "_blobs",
+	gcTreeKey: "gc",
+	gcBlobPrefix: "__gc",
+	gcTombstoneBlobKey: "__tombstones",
+	gcDeletedBlobKey: "__deletedNodes",
+} as const;
+
+const {
+	blobsTreeName,
+	redirectTableBlobName,
+	blobManagerBasePath,
+	gcTreeKey,
+	gcBlobPrefix,
+	gcTombstoneBlobKey,
+	gcDeletedBlobKey,
+} = wireFormatConstants;
+
+interface IGcNodeData {
+	outboundRoutes: string[];
+	unreferencedTimestampMs?: number;
+}
+
+interface IGcState {
+	gcNodes: { [id: string]: IGcNodeData };
+}
+
+/**
+ * The parsed subset of the `gc` subtree that drives reachability decisions.
+ */
+export interface IGcSnapshotData {
+	gcState: IGcState | undefined;
+	tombstones: string[] | undefined;
+	deletedNodes: string[] | undefined;
+}
+
+/** Reader that returns a blob's contents for a given storage id. */
+type BlobReader = (id: string) => Promise<ArrayBufferLike>;
+
+/**
+ * Upper bound on concurrent `readBlob` calls. Driver/service back-pressure is
+ * real for large documents, and unbounded `Promise.all` can trigger throttling
+ * or spike memory. The value is a pragmatic middle ground — high enough to
+ * keep a typical driver's request pipeline full, low enough to avoid storms.
+ */
+const maxReadConcurrency = 32;
+
+/**
+ * Runs `fn` over `items` with at most `limit` promises in flight. Preserves
+ * input order on output (not that any caller depends on it today).
+ *
+ * Exported for unit tests; not part of the package public API.
+ *
+ * @internal
+ */
+export async function mapWithConcurrency<T, R>(
+	items: readonly T[],
+	limit: number,
+	fn: (item: T) => Promise<R>,
+): Promise<R[]> {
+	const results: R[] = Array.from({ length: items.length });
+	let cursor = 0;
+	const workerCount = Math.min(limit, items.length);
+	const workers = Array.from({ length: workerCount }, async () => {
+		while (cursor < items.length) {
+			const index = cursor++;
+			const item = items[index];
+			if (item !== undefined) {
+				results[index] = await fn(item);
+			}
+		}
+	});
+	await Promise.all(workers);
+	return results;
+}
+
+/**
+ * Parses the `gc` subtree of a base snapshot. Returns `undefined` if the
+ * snapshot has no GC tree (GC disabled or pre-GC document).
+ */
+export async function parseGcSnapshotData(
+	baseSnapshot: ISnapshotTree,
+	storage: Pick<IDocumentStorageService, "readBlob">,
+): Promise<IGcSnapshotData | undefined> {
+	const gcSnapshotTree: ISnapshotTree | undefined = baseSnapshot.trees[gcTreeKey];
+	if (gcSnapshotTree === undefined) {
+		return undefined;
+	}
+	let gcState: IGcState | undefined;
+	let tombstones: string[] | undefined;
+	let deletedNodes: string[] | undefined;
+	for (const [key, blobId] of Object.entries(gcSnapshotTree.blobs)) {
+		if (key === gcDeletedBlobKey) {
+			deletedNodes = await readAndParse<string[]>(storage, blobId);
+		} else if (key === gcTombstoneBlobKey) {
+			tombstones = await readAndParse<string[]>(storage, blobId);
+		} else if (key.startsWith(gcBlobPrefix)) {
+			const partial = await readAndParse<IGcState>(storage, blobId);
+			if (gcState === undefined) {
+				gcState = { gcNodes: { ...partial.gcNodes } };
+			} else {
+				for (const [nodeId, nodeData] of Object.entries(partial.gcNodes)) {
+					gcState.gcNodes[nodeId] ??= nodeData;
+				}
+			}
+		}
+	}
+	return { gcState, tombstones, deletedNodes };
+}
+
+/**
+ * Walks a snapshot and inlines the contents of every blob reachable without
+ * crossing an `unreferenced` subtree boundary. Subtrees flagged
+ * `unreferenced: true` are skipped entirely — the summarizer sets that flag
+ * from GC state, so honouring it filters out dead subtrees without a
+ * separate GC-path traversal.
+ *
+ * The root-level `.blobs` subtree is special-cased: only its `.redirectTable`
+ * blob is read, because attachment blob contents are captured separately via
+ * {@link captureReferencedAttachmentBlobs}.
+ */
+export async function readReferencedSnapshotBlobs(
+	snapshot: ISnapshot | ISnapshotTree,
+	storage: Pick<IDocumentStorageService, "readBlob">,
+): Promise<ISerializableBlobContents> {
+	const { tree, read } = toTreeAndReader(snapshot, storage);
+	const ids = new Set<string>();
+	collectReferencedBlobIds(tree, true, ids);
+	const blobs: ISerializableBlobContents = {};
+	await mapWithConcurrency([...ids], maxReadConcurrency, async (id) => {
+		const data = await read(id);
+		blobs[id] = bufferToString(data, "utf8");
+	});
+	return blobs;
+}
+
+/**
+ * Synchronously walks the snapshot tree and gathers the set of blob ids that
+ * should be inlined. Subtrees flagged `unreferenced: true` are skipped
+ * entirely. The root-level `.blobs` subtree is special-cased: only its
+ * `.redirectTable` id is collected, because attachment blob contents are
+ * captured separately via {@link captureReferencedAttachmentBlobs}.
+ */
+function collectReferencedBlobIds(
+	tree: ISnapshotTree,
+	isRoot: boolean,
+	ids: Set<string>,
+): void {
+	if (tree.unreferenced === true) {
+		return;
+	}
+	for (const blobId of Object.values(tree.blobs)) {
+		ids.add(blobId);
+	}
+	for (const [key, subTree] of Object.entries(tree.trees)) {
+		if (isRoot && key === blobsTreeName) {
+			const tableBlobId = subTree.blobs[redirectTableBlobName];
+			if (tableBlobId !== undefined) {
+				ids.add(tableBlobId);
+			}
+		} else {
+			collectReferencedBlobIds(subTree, false, ids);
+		}
+	}
+}
+
+function toTreeAndReader(
+	snapshot: ISnapshot | ISnapshotTree,
+	storage: Pick<IDocumentStorageService, "readBlob">,
+): { tree: ISnapshotTree; read: BlobReader } {
+	if ("snapshotTree" in snapshot) {
+		const blobContents = snapshot.blobContents;
+		return {
+			tree: snapshot.snapshotTree,
+			read: async (id) => blobContents.get(id) ?? storage.readBlob(id),
+		};
+	}
+	return { tree: snapshot, read: async (id) => storage.readBlob(id) };
+}
+
+/**
+ * Fetches attachment blob contents from a snapshot, filtered by GC
+ * reachability. Blobs GC has explicitly marked unreferenced, tombstoned, or
+ * deleted are skipped. Blobs absent from the GC graph are kept — GC state
+ * lags behind recent attachments and dropping them would lose live data.
+ * If `gcData` is `undefined`, every attachment blob is returned.
+ *
+ * The returned map is keyed by attachment blob storage id. Values are the
+ * raw bytes encoded as **base64** strings — attachment blobs may carry
+ * arbitrary binary payloads (images, encrypted data, etc.) and a
+ * UTF-8 round-trip would silently corrupt non-UTF-8 byte sequences with
+ * replacement characters. The runtime's own pending-blob serializer uses
+ * base64 for the same reason. This diverges from the structural-blob path
+ * in {@link readReferencedSnapshotBlobs}, which encodes UTF-8 because those
+ * blobs are JSON or other text the runtime authored. Callers must keep the
+ * two encodings on separate fields of the pending state so the load side
+ * can decode each correctly.
+ */
+export async function captureReferencedAttachmentBlobs(
+	baseSnapshot: ISnapshotTree,
+	storage: Pick<IDocumentStorageService, "readBlob">,
+	gcData: IGcSnapshotData | undefined,
+): Promise<IBase64BlobContents> {
+	const blobsTree: ISnapshotTree | undefined = baseSnapshot.trees[blobsTreeName];
+	if (blobsTree === undefined) {
+		return {};
+	}
+	const localIdToStorageId = await readRedirectTable(blobsTree, storage);
+	if (localIdToStorageId.size === 0) {
+		return {};
+	}
+
+	const unreferencedLocalIds =
+		gcData === undefined ? undefined : collectUnreferencedBlobLocalIds(gcData);
+
+	const storageIdsToFetch = new Set<string>();
+	for (const [localId, storageId] of localIdToStorageId) {
+		if (unreferencedLocalIds?.has(localId) !== true) {
+			storageIdsToFetch.add(storageId);
+		}
+	}
+
+	const contents: IBase64BlobContents = {};
+	await mapWithConcurrency([...storageIdsToFetch], maxReadConcurrency, async (storageId) => {
+		const buffer = await storage.readBlob(storageId);
+		contents[storageId] = bufferToString(buffer, "base64");
+	});
+	return contents;
+}
+
+/**
+ * Reconstructs the BlobManager's redirect table from a `.blobs` subtree.
+ * Mirrors `toRedirectTable` in blobManagerSnapSum.ts.
+ */
+async function readRedirectTable(
+	blobsTree: ISnapshotTree,
+	storage: Pick<IDocumentStorageService, "readBlob">,
+): Promise<Map<string, string>> {
+	const redirectTable = new Map<string, string>();
+	const tableBlobId: string | undefined = blobsTree.blobs[redirectTableBlobName];
+	if (tableBlobId !== undefined) {
+		const entries = await readAndParse<[string, string][]>(storage, tableBlobId);
+		for (const [localId, storageId] of entries) {
+			redirectTable.set(localId, storageId);
+		}
+	}
+	for (const [key, storageId] of Object.entries(blobsTree.blobs)) {
+		if (key !== redirectTableBlobName) {
+			// Identity mapping: storage ids referenced directly in handles (legacy).
+			redirectTable.set(storageId, storageId);
+		}
+	}
+	return redirectTable;
+}
+
+/**
+ * Collects the set of blob localIds that GC has explicitly marked as
+ * unreferenced (via `unreferencedTimestampMs` on a gc node), tombstoned, or
+ * deleted. Tombstones and deletedNodes are applied regardless of whether
+ * `gcState` is present — they are authoritative on their own and must not
+ * be silently dropped when gc state is absent but tombstone/deleted lists
+ * exist.
+ */
+function collectUnreferencedBlobLocalIds(gcData: IGcSnapshotData): Set<string> {
+	const blobPathPrefix = `/${blobManagerBasePath}/`;
+	const unreferenced = new Set<string>();
+	if (gcData.gcState !== undefined) {
+		for (const [nodePath, nodeData] of Object.entries(gcData.gcState.gcNodes)) {
+			if (
+				nodePath.startsWith(blobPathPrefix) &&
+				nodeData.unreferencedTimestampMs !== undefined
+			) {
+				unreferenced.add(nodePath.slice(blobPathPrefix.length));
+			}
+		}
+	}
+	for (const nodePath of [...(gcData.tombstones ?? []), ...(gcData.deletedNodes ?? [])]) {
+		if (nodePath.startsWith(blobPathPrefix)) {
+			unreferenced.add(nodePath.slice(blobPathPrefix.length));
+		}
+	}
+	return unreferenced;
+}
+
+/**
+ * A blob reference extracted from a `BlobAttach` op. `localId` is the
+ * `BlobManager` GC identity for the blob; `storageId` is the id used for
+ * `IDocumentStorageService.readBlob`.
+ *
+ * @internal
+ */
+export interface IBlobAttachReference {
+	readonly localId: string;
+	readonly storageId: string;
+}
+
+interface IBlobAttachLikeMetadata {
+	readonly localId: string;
+	readonly blobId: string;
+}
+
+function isBlobAttachLikeMetadata(metadata: unknown): metadata is IBlobAttachLikeMetadata {
+	if (typeof metadata !== "object" || metadata === null) {
+		return false;
+	}
+	const candidate = metadata as { localId?: unknown; blobId?: unknown };
+	return typeof candidate.localId === "string" && typeof candidate.blobId === "string";
+}
+
+/**
+ * Extracts every `BlobAttach` reference an op carries. Returns an empty array
+ * for non-blobAttach ops.
+ *
+ * This is the single place in the loader that interprets the BlobAttach
+ * wire format. Capture and load-side reasoning about ops should call into
+ * this function rather than reading `op.metadata` directly, so a future
+ * protocol change touches one site.
+ *
+ * BlobAttach ops carry `(localId, storageId)` directly on
+ * `ISequencedDocumentMessage.metadata` and are not grouped — the container
+ * runtime routes them through a separate `outbox.submitBlobAttach` lane,
+ * and `OpGroupingManager.groupBatch` asserts (0x5dd) that no op carrying
+ * non-batch metadata enters a grouped batch. If either guarantee changes,
+ * extend this function rather than each call site.
+ *
+ * @internal
+ */
+export function extractBlobAttachReferences(
+	op: Pick<ISequencedDocumentMessage, "metadata">,
+): IBlobAttachReference[] {
+	if (!isBlobAttachLikeMetadata(op.metadata)) {
+		return [];
+	}
+	return [{ localId: op.metadata.localId, storageId: op.metadata.blobId }];
+}
+
+/**
+ * Set of attachment-blob localIds that GC has marked unreferenced,
+ * tombstoned, or deleted in the base snapshot. `undefined` if `gcData`
+ * is `undefined` (GC disabled / pre-GC document).
+ *
+ * @internal
+ */
+export function unreferencedAttachmentBlobLocalIds(
+	gcData: IGcSnapshotData | undefined,
+): Set<string> | undefined {
+	return gcData === undefined ? undefined : collectUnreferencedBlobLocalIds(gcData);
+}
+
+/**
+ * Inline attachment blob contents for the given `(localId, storageId)`
+ * references. Skips entries already present in `existing` (de-dupe with
+ * the snapshot path) and entries whose `localId` is in
+ * `unreferencedLocalIds`. Returns only the freshly-read entries; the
+ * caller merges them into the existing map.
+ *
+ * @internal
+ */
+export async function inlineAttachmentBlobsByReference(
+	references: readonly IBlobAttachReference[],
+	storage: Pick<IDocumentStorageService, "readBlob">,
+	unreferencedLocalIds: ReadonlySet<string> | undefined,
+	existing: Readonly<IBase64BlobContents>,
+): Promise<IBase64BlobContents> {
+	const storageIdsToFetch = new Set<string>();
+	for (const { localId, storageId } of references) {
+		if (unreferencedLocalIds?.has(localId) === true) {
+			continue;
+		}
+		if (existing[storageId] !== undefined) {
+			continue;
+		}
+		storageIdsToFetch.add(storageId);
+	}
+	const added: IBase64BlobContents = {};
+	if (storageIdsToFetch.size === 0) {
+		return added;
+	}
+	await mapWithConcurrency([...storageIdsToFetch], maxReadConcurrency, async (storageId) => {
+		const buffer = await storage.readBlob(storageId);
+		added[storageId] = bufferToString(buffer, "base64");
+	});
+	return added;
+}
+
+/**
+ * Returns true if any referenced subtree of `baseSnapshot` declares a
+ * `groupId` — the snapshot-tree wire field that carries the runtime's
+ * loading-group identifier. Subtrees flagged `unreferenced` are skipped —
+ * a dead subtree's `groupId` would not be loaded by the runtime either.
+ *
+ * `captureFullContainerState` does not yet support loading groups: prefetching
+ * per-group snapshots adds a code path that has no end-to-end coverage and no
+ * known production consumer. Callers use this to fail fast with a `UsageError`
+ * rather than silently producing a pending state that omits group data.
+ */
+export function snapshotHasLoadingGroups(baseSnapshot: ISnapshotTree): boolean {
+	if (baseSnapshot.unreferenced === true) {
+		return false;
+	}
+	if (baseSnapshot.groupId !== undefined) {
+		return true;
+	}
+	for (const child of Object.values(baseSnapshot.trees)) {
+		if (snapshotHasLoadingGroups(child)) {
+			return true;
+		}
+	}
+	return false;
+}

package/src/connectionManager.ts

@@ -63,7 +63,11 @@ import {
 	ReconnectMode,
 } from "./contracts.js";
 import { DeltaQueue } from "./deltaQueue.js";
-import { FrozenDeltaStream, isFrozenDeltaStreamConnection } from "./frozenServices.js";
+import {
+	FrozenDeltaStream,
+	isFrozenDeltaStreamConnection,
+	isWritableFrozenDeltaStreamConnection,
+} from "./frozenServices.js";
 import { SignalType } from "./protocol.js";
 import { isDeltaStreamConnectionForbiddenError } from "./utils.js";
 
@@ -582,9 +586,9 @@ export class ConnectionManager implements IConnectionManager {
 					LogLevel.verbose,
 				);
 				if (isDeltaStreamConnectionForbiddenError(origError)) {
-					connection = new FrozenDeltaStream(origError.storageOnlyReason, {
-						text: origError.message,
-						error: origError,
+					connection = new FrozenDeltaStream({
+						storageOnlyReason: origError.storageOnlyReason,
+						readonlyConnectionReason: { text: origError.message, error: origError },
 					});
 					requestedMode = "read";
 					break;
@@ -592,11 +596,10 @@ export class ConnectionManager implements IConnectionManager {
 					isFluidError(origError) &&
 					origError.errorType === DriverErrorTypes.outOfStorageError
 				) {
-					// If we get out of storage error from calling joinsession, then use the NoDeltaStream object so
+					// If we get out of storage error from calling joinsession, then use the FrozenDeltaStream object so
 					// that user can at least load the container.
-					connection = new FrozenDeltaStream(undefined, {
-						text: origError.message,
-						error: origError,
+					connection = new FrozenDeltaStream({
+						readonlyConnectionReason: { text: origError.message, error: origError },
 					});
 					requestedMode = "read";
 					break;
@@ -1089,6 +1092,25 @@ export class ConnectionManager implements IConnectionManager {
 
 	public sendMessages(messages: IDocumentMessage[]): void {
 		assert(this.connected, 0x2b4 /* "not connected on sending ops!" */);
+		// WritableFrozenDeltaStream short-circuit: writable-frozen containers
+		// (`loadFrozenContainerFromPendingState({ readOnly: false })`) attach a
+		// WritableFrozenDeltaStream as the live connection. Its `mode` is "read" (advertising
+		// "write" would imply quorum membership we cannot honor), so a runtime submit
+		// would otherwise fall into the read-mode reconnect branch below. That branch
+		// schedules `reconnect("write")`, which under `ReconnectMode.Never`
+		// (`allowReconnect: false`) calls `closeHandler` and closes the container — the
+		// opposite of what writable-frozen wants. Drop the messages here: the runtime's
+		// outbox keeps them in `pendingStateManager` so `getPendingLocalState()` can
+		// capture them, which is the entire point of the writable-frozen flow.
+		//
+		// Match only the writable variant (a sibling class, not a subclass) so the read-only
+		// `FrozenDeltaStream` retains its `submit` 403-nack tripwire — a stray submit on a
+		// storage-only frozen connection signals an upstream invariant break and should
+		// remain observable. The read-only variant shouldn't reach here in normal flow anyway
+		// (its `storageOnly` policy keeps the runtime from submitting).
+		if (isWritableFrozenDeltaStreamConnection(this.connection)) {
+			return;
+		}
 		// If connection is "read" or implicit "read" (got leave op for "write" connection),
 		// then op can't make it through - we will get a nack if op is sent.
 		// We can short-circuit this process.

package/src/connectionStateHandler.ts

@@ -5,6 +5,7 @@
 
 import type { IDeltaManager } from "@fluidframework/container-definitions/internal";
 import type { ITelemetryBaseProperties } from "@fluidframework/core-interfaces";
+import { LogLevel } from "@fluidframework/core-interfaces";
 import { assert, Timer } from "@fluidframework/core-utils/internal";
 import type { IClient, ISequencedClient } from "@fluidframework/driver-definitions";
 import type { IAnyDriverError } from "@fluidframework/driver-definitions/internal";
@@ -687,15 +688,19 @@ export class ConnectionStateHandler implements IConnectionStateHandler {
 				this.prevClientLeftTimer.restart();
 			} else {
 				// Adding this event temporarily so that we can get help debugging if something goes wrong.
-				this.handler.logger.sendTelemetryEvent({
-					eventName: "noWaitOnDisconnected",
-					details: JSON.stringify({
-						clientId: this._clientId,
-						inQuorum: currentClientInQuorum,
-						waitingForLeaveOp: this.waitingForLeaveOp,
-						hadOutstandingOps: this.handler.shouldClientJoinWrite(),
-					}),
-				});
+				this.handler.logger.sendTelemetryEvent(
+					{
+						eventName: "noWaitOnDisconnected",
+						details: JSON.stringify({
+							clientId: this._clientId,
+							inQuorum: currentClientInQuorum,
+							waitingForLeaveOp: this.waitingForLeaveOp,
+							hadOutstandingOps: this.handler.shouldClientJoinWrite(),
+						}),
+					},
+					undefined, // error
+					LogLevel.info,
+				);
 			}
 		}
 

package/src/container.ts

@@ -1070,6 +1070,7 @@ export class Container
 
 				this.connectionStateHandler.dispose();
 				this.serializedStateManager.dispose();
+				this._runtime?.close?.();
 			} catch (newError) {
 				this.mc.logger.sendErrorEvent({ eventName: "ContainerCloseException" }, newError);
 			}
@@ -1104,6 +1105,8 @@ export class Container
 						eventName: "ContainerDispose",
 						// Only log error if container isn't closed
 						category: !this.closed && error !== undefined ? "error" : "generic",
+						isDirty: this.isDirty,
+						lastSequenceNumber: this._deltaManager.lastSequenceNumber,
 					},
 					error,
 				);
@@ -2394,6 +2397,9 @@ export class Container
 				this.subLogger,
 				{ eventName: "CodeLoad" },
 				async () => this.codeLoader.load(codeDetails),
+				undefined, // markers
+				undefined, // sampleThreshold
+				LogLevel.info,
 			);
 
 			this._loadedModule = {

package/src/containerStorageAdapter.ts

@@ -36,13 +36,32 @@ import type {
 import { convertSnapshotInfoToSnapshot } from "./utils.js";
 
 /**
- * Stringified blobs from a summary/snapshot tree.
+ * Stringified blobs from a summary/snapshot tree, keyed by blob id.
+ * Values are **UTF-8-encoded** — this is the right encoding for JSON or
+ * other text the runtime authors and consumes through this map. For
+ * arbitrary binary payloads (e.g. attachment blob contents), use
+ * {@link IBase64BlobContents} instead; a UTF-8 round-trip silently
+ * corrupts non-UTF-8 byte sequences with replacement characters.
  * @internal
  */
 export interface ISerializableBlobContents {
 	[id: string]: string;
 }
 
+/**
+ * Stringified blobs inlined in a summary/snapshot tree, keyed by blob id.
+ * Values are **base64-encoded** raw bytes. Used for attachment-blob
+ * payloads, which may carry arbitrary binary data (images, encrypted
+ * blobs, etc.). Mirrors the encoding used by the runtime's own
+ * pending-blob serializer in `BlobManager`. Structurally identical to
+ * {@link ISerializableBlobContents}; the two types exist to keep the
+ * encoding contract visible at every call site.
+ * @internal
+ */
+export interface IBase64BlobContents {
+	[id: string]: string;
+}
+
 /**
  * This class wraps the actual storage and make sure no wrong apis are called according to
  * container attach state.