@fluidframework/container-runtime 2.0.0-dev-rc.4.0.0.261659 → 2.0.0-dev-rc.5.0.0.265721

package/src/dataStore.ts

@@ -4,7 +4,8 @@
  */
 
 import { AttachState } from "@fluidframework/container-definitions";
-import { FluidObject, IFluidHandle } from "@fluidframework/core-interfaces";
+import { FluidObject } from "@fluidframework/core-interfaces";
+import { type IFluidHandleInternal } from "@fluidframework/core-interfaces/internal";
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
 import {
 	AliasResult,
@@ -169,7 +170,7 @@ class DataStore implements IDataStore {
 	/**
 	 * {@inheritDoc @fluidframework/runtime-definitions#IDataStore.entryPoint}
 	 */
-	get entryPoint(): IFluidHandle<FluidObject> {
+	get entryPoint(): IFluidHandleInternal<FluidObject> {
 		return this.fluidDataStoreChannel.entryPoint;
 	}
 

package/src/dataStoreContext.ts

@@ -4,19 +4,27 @@
  */
 
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
-import { AttachState, IAudience, IDeltaManager } from "@fluidframework/container-definitions";
+import { AttachState, IAudience } from "@fluidframework/container-definitions";
+import { IDeltaManager } from "@fluidframework/container-definitions/internal";
 import {
 	FluidObject,
 	IDisposable,
-	IEvent,
-	IFluidHandle,
 	IRequest,
 	IResponse,
 	ITelemetryBaseProperties,
+	type IEvent,
 } from "@fluidframework/core-interfaces";
+import { type IFluidHandleInternal } from "@fluidframework/core-interfaces/internal";
 import { assert, LazyPromise, unreachableCase } from "@fluidframework/core-utils/internal";
-import { IDocumentStorageService } from "@fluidframework/driver-definitions/internal";
-import { BlobTreeEntry, readAndParse } from "@fluidframework/driver-utils/internal";
+import {
+	IDocumentStorageService,
+	type ISnapshot,
+} from "@fluidframework/driver-definitions/internal";
+import {
+	BlobTreeEntry,
+	isInstanceOfISnapshot,
+	readAndParse,
+} from "@fluidframework/driver-utils/internal";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 import {
 	IClientDetails,
@@ -26,13 +34,11 @@ import {
 	ISnapshotTree,
 	ITreeEntry,
 } from "@fluidframework/protocol-definitions";
+import { IInboundSignalMessage } from "@fluidframework/runtime-definitions";
 import {
-	IGarbageCollectionData,
-	IInboundSignalMessage,
 	ISummaryTreeWithStats,
 	ITelemetryContext,
-} from "@fluidframework/runtime-definitions";
-import {
+	IGarbageCollectionData,
 	CreateChildSummarizerNodeFn,
 	CreateChildSummarizerNodeParam,
 	FluidDataStoreRegistryEntry,
@@ -52,7 +58,11 @@ import {
 	channelsTreeName,
 	gcDataBlobKey,
 } from "@fluidframework/runtime-definitions/internal";
-import { addBlobToSummary } from "@fluidframework/runtime-utils/internal";
+import {
+	addBlobToSummary,
+	isSnapshotFetchRequiredForLoadingGroupId,
+	toFluidHandleInternal,
+} from "@fluidframework/runtime-utils/internal";
 import {
 	DataCorruptionError,
 	DataProcessingError,
@@ -67,6 +77,7 @@ import {
 
 import { detectOutboundRoutesViaDDSKey, sendGCUnexpectedUsageEvent } from "./gc/index.js";
 import {
+	// eslint-disable-next-line import/no-deprecated
 	ReadFluidDataStoreAttributes,
 	WriteFluidDataStoreAttributes,
 	dataStoreAttributesBlobName,
@@ -164,7 +175,7 @@ export interface ILocalDetachedFluidDataStoreContextProps extends ILocalFluidDat
  * @internal
  */
 export interface IRemoteFluidDataStoreContextProps extends IFluidDataStoreContextProps {
-	readonly snapshotTree: ISnapshotTree | undefined;
+	readonly snapshot: ISnapshotTree | ISnapshot | undefined;
 }
 
 // back-compat: To be removed in the future.
@@ -199,8 +210,8 @@ export abstract class FluidDataStoreContext
 		return this.parentContext.clientDetails;
 	}
 
-	public get logger() {
-		return this.parentContext.logger;
+	public get baseLogger() {
+		return this.parentContext.baseLogger;
 	}
 
 	public get deltaManager(): IDeltaManager<ISequencedDocumentMessage, IDocumentMessage> {
@@ -371,7 +382,7 @@ export abstract class FluidDataStoreContext
 		);
 
 		this.mc = createChildMonitoringContext({
-			logger: this.logger,
+			logger: this.baseLogger,
 			namespace: "FluidDataStoreContext",
 			properties: {
 				all: tagCodeArtifacts({
@@ -722,11 +733,17 @@ export abstract class FluidDataStoreContext
 	 * @param srcHandle - The handle of the node that added the reference.
 	 * @param outboundHandle - The handle of the outbound node that is referenced.
 	 */
-	public addedGCOutboundReference(srcHandle: IFluidHandle, outboundHandle: IFluidHandle) {
+	public addedGCOutboundReference(
+		srcHandle: IFluidHandleInternal,
+		outboundHandle: IFluidHandleInternal,
+	): void {
 		// By default, skip this call since the ContainerRuntime will detect the outbound route directly.
 		if (this.mc.config.getBoolean(detectOutboundRoutesViaDDSKey) === true) {
 			// Note: The ContainerRuntime code will check this same setting to avoid double counting.
-			this.parentContext.addedGCOutboundReference?.(srcHandle, outboundHandle);
+			this.parentContext.addedGCOutboundReference?.(
+				toFluidHandleInternal(srcHandle),
+				toFluidHandleInternal(outboundHandle),
+			);
 		}
 	}
 
@@ -1054,7 +1071,7 @@ export abstract class FluidDataStoreContext
 	public async uploadBlob(
 		blob: ArrayBufferLike,
 		signal?: AbortSignal,
-	): Promise<IFluidHandle<ArrayBufferLike>> {
+	): Promise<IFluidHandleInternal<ArrayBufferLike>> {
 		return this.parentContext.uploadBlob(blob, signal);
 	}
 }
@@ -1062,23 +1079,28 @@ export abstract class FluidDataStoreContext
 /** @internal */
 export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
 	// Tells whether we need to fetch the snapshot before use. This is to support Data Virtualization.
-	private snapshotFetchRequired: boolean;
+	private snapshotFetchRequired: boolean | undefined;
 	private readonly runtime: IContainerRuntimeBase;
+	private readonly blobContents: Map<string, ArrayBuffer> | undefined;
 
 	constructor(props: IRemoteFluidDataStoreContextProps) {
 		super(props, true /* existing */, false /* isLocalDataStore */, () => {
 			throw new Error("Already attached");
 		});
 
-		this._baseSnapshot = props.snapshotTree;
-		this.snapshotFetchRequired = !!props.snapshotTree?.omitted;
 		this.runtime = props.parentContext.containerRuntime;
-		if (props.snapshotTree !== undefined) {
-			this.summarizerNode.updateBaseSummaryState(props.snapshotTree);
+		if (isInstanceOfISnapshot(props.snapshot)) {
+			this.blobContents = props.snapshot.blobContents;
+			this._baseSnapshot = props.snapshot.snapshotTree;
+		} else {
+			this._baseSnapshot = props.snapshot;
+		}
+		if (this._baseSnapshot !== undefined) {
+			this.summarizerNode.updateBaseSummaryState(this._baseSnapshot);
 		}
 	}
 
-	/* 
+	/*
 	This API should not be called for RemoteFluidDataStoreContext. But here is one scenario where it's not the case:
 	The scenario (hit by stashedOps.spec.ts, "resends attach op" UT is the following (as far as I understand):
 	1. data store is being attached in attached container
@@ -1093,6 +1115,21 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
 	private readonly initialSnapshotDetailsP = new LazyPromise<ISnapshotDetails>(async () => {
 		// Sequence number of the snapshot.
 		let sequenceNumber: number | undefined;
+		// Check whether we need to fetch the snapshot first to load.
+		if (this.snapshotFetchRequired === undefined && this._baseSnapshot?.groupId !== undefined) {
+			assert(
+				this.blobContents !== undefined,
+				0x97a /* Blob contents should be present to evaluate */,
+			);
+			assert(
+				this._baseSnapshot !== undefined,
+				0x97b /* snapshotTree should be present to evaluate */,
+			);
+			this.snapshotFetchRequired = isSnapshotFetchRequiredForLoadingGroupId(
+				this._baseSnapshot,
+				this.blobContents,
+			);
+		}
 		if (this.snapshotFetchRequired) {
 			assert(
 				this.loadingGroupId !== undefined,
@@ -1111,6 +1148,7 @@ export class RemoteFluidDataStoreContext extends FluidDataStoreContext {
 
 		if (!!tree && tree.blobs[dataStoreAttributesBlobName] !== undefined) {
 			// Need to get through snapshot and use that to populate extraBlobs
+			// eslint-disable-next-line import/no-deprecated
 			const attributes = await readAndParse<ReadFluidDataStoreAttributes>(
 				this.storage,
 				tree.blobs[dataStoreAttributesBlobName],
@@ -1287,6 +1325,7 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
 
 	private readonly initialSnapshotDetailsP = new LazyPromise<ISnapshotDetails>(async () => {
 		let snapshot = this.snapshotTree;
+		// eslint-disable-next-line import/no-deprecated
 		let attributes: ReadFluidDataStoreAttributes;
 		let isRootDataStore = false;
 		if (snapshot !== undefined) {

package/src/{deltaManagerSummarizerProxy.ts → deltaManagerProxies.ts}

@@ -11,9 +11,9 @@ import type {
 	IDeltaQueue,
 	IDeltaSender,
 	ReadOnlyInfo,
-} from "@fluidframework/container-definitions";
+} from "@fluidframework/container-definitions/internal";
 import type { IErrorBase } from "@fluidframework/core-interfaces";
-import type { IAnyDriverError } from "@fluidframework/driver-definitions";
+import type { IAnyDriverError } from "@fluidframework/driver-definitions/internal";
 import {
 	IClientConfiguration,
 	IClientDetails,
@@ -23,6 +23,7 @@ import {
 } from "@fluidframework/protocol-definitions";
 
 import { summarizerClientType } from "./summary/index.js";
+import type { PendingStateManager } from "./pendingStateManager.js";
 
 /**
  * Base class for DeltaManager proxy that proxy's access to the real DeltaManager.
@@ -139,7 +140,10 @@ export abstract class BaseDeltaManagerProxy
 	private readonly onSubmitOp = (message: IDocumentMessage): void => {
 		this.emit("submitOp", message);
 	};
-	private readonly onOp = (message: ISequencedDocumentMessage, processingTime: number): void => {
+	protected readonly onOp = (
+		message: ISequencedDocumentMessage,
+		processingTime: number,
+	): void => {
 		this.emit("op", message, processingTime);
 	};
 	private readonly onPong = (latency: number): void => {
@@ -194,3 +198,51 @@ export class DeltaManagerSummarizerProxy extends BaseDeltaManagerProxy {
 		this.isSummarizerClient = this.deltaManager.clientDetails.type === summarizerClientType;
 	}
 }
+
+export class DeltaManagerPendingOpsProxy extends BaseDeltaManagerProxy {
+	public get minimumSequenceNumber(): number {
+		const minPendingSeqNum = this.pendingStateManager.minimumPendingMessageSequenceNumber;
+		// There is a chance that minPendingSeqNum is greater than minimum sequence number.
+		// minPendingSeqNum is based on the pending ops, so it's based on ref seq number.
+		// Imagine an op has just be sent while there's another client that has been lagging behind,
+		// it will likely have a ref seq number greater than the minimum seq number.
+		if (
+			minPendingSeqNum !== undefined &&
+			minPendingSeqNum < this.deltaManager.minimumSequenceNumber
+		) {
+			return minPendingSeqNum;
+		}
+		return this.deltaManager.minimumSequenceNumber;
+	}
+
+	public get lastMessage() {
+		if (this.deltaManager.lastMessage === undefined) {
+			return this.deltaManager.lastMessage;
+		}
+		return {
+			...this.deltaManager.lastMessage,
+			minimumSequenceNumber: this.minimumSequenceNumber,
+		};
+	}
+
+	protected readonly onOp = (
+		message: ISequencedDocumentMessage,
+		processingTime: number,
+	): void => {
+		const messageIntercept = {
+			...message,
+			minimumSequenceNumber: this.minimumSequenceNumber,
+		};
+		this.emit("op", messageIntercept, processingTime);
+	};
+
+	constructor(
+		protected readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
+		private readonly pendingStateManager: Pick<
+			PendingStateManager,
+			"minimumPendingMessageSequenceNumber"
+		>,
+	) {
+		super(deltaManager);
+	}
+}

package/src/deltaScheduler.ts

@@ -4,7 +4,7 @@
  */
 
 import { performance } from "@fluid-internal/client-utils";
-import { IDeltaManager } from "@fluidframework/container-definitions";
+import { IDeltaManager } from "@fluidframework/container-definitions/internal";
 import { IDocumentMessage, ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { ITelemetryLoggerExt, formatTick } from "@fluidframework/telemetry-utils/internal";
 

package/src/gc/garbageCollection.md

@@ -88,14 +88,6 @@ for apps to override settings easily, e.g. by backing their `IConfigProviderBase
 In cases where a behavior is controlled by both a Config Setting and GC Option, you may experiment at first using Config Settings
 and then later update the passed-in GC Options to finalize the configuration in your code.
 
-### Disabling Mark Phase
-
-If you wish to disable Mark Phase for newly-created documents, set the `gcAllowed` GC Option to `false`.
-Note that this will disable GC permanently (including the sweep phase) for the container during its lifetime.
-
-Mark Phase can also be disabled just for the session, among other behaviors,
-covered in the [Advanced Configuration](./gcEarlyAdoption.md#more-advanced-configurations) docs.
-
 ### Enabling Sweep Phase
 
 To enable the Sweep Phase for new documents, you must set the `enableGCSweep` GC Option to true.

package/src/gc/garbageCollection.ts

@@ -5,11 +5,12 @@
 
 import { IRequest } from "@fluidframework/core-interfaces";
 import { assert, LazyPromise, Timer } from "@fluidframework/core-utils/internal";
-import { IGarbageCollectionData, ITelemetryContext } from "@fluidframework/runtime-definitions";
 import {
 	IGarbageCollectionDetailsBase,
 	ISummarizeResult,
 	gcTreeKey,
+	type IGarbageCollectionData,
+	type ITelemetryContext,
 } from "@fluidframework/runtime-definitions/internal";
 import { createResponseError, responseToException } from "@fluidframework/runtime-utils/internal";
 import {

package/src/gc/gcConfigs.ts

@@ -28,7 +28,7 @@ import {
 	gcTestModeKey,
 	maxSnapshotCacheExpiryMs,
 	oneDayMs,
-	runGCKey,
+	runGCTestKey,
 	runSessionExpiryKey,
 	runSweepKey,
 	throwOnTombstoneLoadOverrideKey,
@@ -54,7 +54,7 @@ export function generateGCConfigs(
 		isSummarizerClient: boolean;
 	},
 ): IGarbageCollectorConfigs {
-	let gcEnabled: boolean;
+	let gcDisabled: boolean = false;
 	let sessionExpiryTimeoutMs: number | undefined;
 	let tombstoneTimeoutMs: number | undefined;
 	let persistedGcFeatureMatrix: GCFeatureMatrix | undefined;
@@ -70,9 +70,9 @@ export function generateGCConfigs(
 	if (createParams.existing) {
 		const metadata = createParams.metadata;
 		gcVersionInBaseSnapshot = getGCVersion(metadata);
-		// Existing documents which did not have metadata blob or had GC disabled have version as 0. For all
-		// other existing documents, GC is enabled.
-		gcEnabled = gcVersionInBaseSnapshot > 0;
+		// Existing documents which did not have metadata blob or had GC disabled have GC version as 0. GC will be
+		// disabled for these documents.
+		gcDisabled = gcVersionInBaseSnapshot === 0;
 		sessionExpiryTimeoutMs = metadata?.sessionExpiryTimeoutMs;
 		const legacyPersistedSweepTimeoutMs = (metadata as IGCMetadata_Deprecated)?.sweepTimeoutMs;
 		tombstoneTimeoutMs =
@@ -86,12 +86,8 @@ export function generateGCConfigs(
 			"Fluid.GarbageCollection.TestOverride.TombstoneTimeoutMs",
 		);
 
-		// For new documents, GC is enabled by default. It can be explicitly disabled by setting the gcAllowed
-		// flag in GC options to false.
-		gcEnabled = createParams.gcOptions.gcAllowed !== false;
-
-		// Set the Session Expiry if GC is enabled and session expiry flag isn't explicitly set to false.
-		if (gcEnabled && mc.config.getBoolean(runSessionExpiryKey) !== false) {
+		// Set the Session Expiry if session expiry flag isn't explicitly set to false.
+		if (mc.config.getBoolean(runSessionExpiryKey) !== false) {
 			sessionExpiryTimeoutMs =
 				createParams.gcOptions.sessionExpiryTimeoutMs ?? defaultSessionExpiryDurationMs;
 		}
@@ -122,15 +118,12 @@ export function generateGCConfigs(
 
 	/**
 	 * Whether GC should run or not. The following conditions have to be met to run sweep:
-	 * 1. GC should be enabled for this container.
-	 * 2. GC should not be disabled via disableGC GC option.
-	 * 3. The current GC version should be greater or equal to the GC version in the base snapshot.
+	 * 1. GC should not be disabled for this container.
+	 * 2. The current GC version should be greater or equal to the GC version in the base snapshot.
 	 *
-	 * These conditions can be overridden via the RunGC feature flag.
+	 * These conditions can be overridden via the RunGC feature flag for testing.
 	 */
-	const shouldRunGC =
-		mc.config.getBoolean(runGCKey) ??
-		(gcEnabled && !createParams.gcOptions.disableGC && isGCVersionUpToDate);
+	const shouldRunGC = mc.config.getBoolean(runGCTestKey) ?? (!gcDisabled && isGCVersionUpToDate);
 
 	/**
 	 * Whether sweep should run or not. This refers to whether Tombstones should fail on load and whether
@@ -195,7 +188,7 @@ export function generateGCConfigs(
 		!createParams.isSummarizerClient;
 
 	return {
-		gcEnabled, // For this document
+		gcEnabled: !gcDisabled, // For this document
 		sweepEnabled: sweepAllowed, // For this document (based on current GC Generation option)
 		shouldRunGC, // For this session
 		shouldRunSweep, // For this session

package/src/gc/gcDefinitions.ts

@@ -6,8 +6,9 @@
 import { ICriticalContainerError } from "@fluidframework/container-definitions";
 import { IRequest } from "@fluidframework/core-interfaces";
 import { ISnapshotTree } from "@fluidframework/protocol-definitions";
-import { IGarbageCollectionData, ITelemetryContext } from "@fluidframework/runtime-definitions";
 import {
+	ITelemetryContext,
+	IGarbageCollectionData,
 	IGarbageCollectionDetailsBase,
 	ISummarizeResult,
 } from "@fluidframework/runtime-definitions/internal";
@@ -59,8 +60,6 @@ export const gcDisableDataStoreSweepOptionName = "disableDataStoreSweep";
  */
 export const gcGenerationOptionName = "gcGeneration";
 
-/** Config key to turn GC on / off. */
-export const runGCKey = "Fluid.GarbageCollection.RunGC";
 /** Config key to turn GC sweep on / off. */
 export const runSweepKey = "Fluid.GarbageCollection.RunSweep";
 /** Config key to turn GC test mode on / off. */
@@ -82,6 +81,8 @@ export const disableDatastoreSweepKey = "Fluid.GarbageCollection.DisableDataStor
 export const detectOutboundRoutesViaDDSKey = "Fluid.GarbageCollection.DetectOutboundRoutesViaDDS";
 /** Config key to disable auto-recovery mechanism that protects Tombstones that are loaded from being swept (use true) */
 export const disableAutoRecoveryKey = "Fluid.GarbageCollection.DisableAutoRecovery";
+/** Config key to turn GC on / off for testing. */
+export const runGCTestKey = "Fluid.GarbageCollection.Test.RunGC";
 
 // One day in milliseconds.
 export const oneDayMs = 1 * 24 * 60 * 60 * 1000;
@@ -421,24 +422,6 @@ export interface IGarbageCollectorCreateParams {
  * @alpha
  */
 export interface IGCRuntimeOptions {
-	/**
-	 * Flag that if true, will enable running garbage collection (GC) for a new container.
-	 *
-	 * GC has mark phase and sweep phase. In mark phase, unreferenced objects are identified
-	 * and marked as such in the summary. This option enables the mark phase.
-	 * In sweep phase, unreferenced objects are eventually deleted from the container if they meet certain conditions.
-	 * Sweep phase can be enabled using the "enableGCSweep" option.
-	 *
-	 * Note: This setting is persisted in the container's summary and cannot be changed.
-	 */
-	gcAllowed?: boolean;
-
-	/**
-	 * Flag that if true, will disable garbage collection for the session.
-	 * Can be used to disable running GC on containers where it is allowed via the gcAllowed option.
-	 */
-	disableGC?: boolean;
-
 	/**
 	 * Flag that if true, will enable the full Sweep Phase of garbage collection for this session,
 	 * where Tombstoned objects are permanently deleted from the container.
@@ -481,8 +464,7 @@ export interface IGCRuntimeOptions {
  */
 export interface IGarbageCollectorConfigs {
 	/**
-	 * Tracks if GC is enabled for this document. This is specified during document creation and doesn't change
-	 * throughout its lifetime.
+	 * Tracks if GC is enabled for this document. GC may not be enabled for old documents created pre-GC.
 	 */
 	readonly gcEnabled: boolean;
 	/**

package/src/gc/gcHelpers.ts

@@ -5,12 +5,12 @@
 
 import { assert } from "@fluidframework/core-utils/internal";
 import { ISnapshotTree } from "@fluidframework/protocol-definitions";
-import { IGarbageCollectionData } from "@fluidframework/runtime-definitions";
 import {
 	IGarbageCollectionDetailsBase,
 	gcBlobPrefix,
 	gcDeletedBlobKey,
 	gcTombstoneBlobKey,
+	IGarbageCollectionData,
 } from "@fluidframework/runtime-definitions/internal";
 import type { IConfigProvider } from "@fluidframework/telemetry-utils/internal";
 

package/src/gc/gcSummaryDefinitions.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { IGarbageCollectionData } from "@fluidframework/runtime-definitions";
+import { IGarbageCollectionData } from "@fluidframework/runtime-definitions/internal";
 
 /**
  * The garbage collection data of each node in the reference graph. Each node's GC data is written in the summary

package/src/gc/gcSummaryStateTracker.ts

@@ -4,8 +4,8 @@
  */
 
 import { SummaryType } from "@fluidframework/protocol-definitions";
-import { ISummaryTreeWithStats } from "@fluidframework/runtime-definitions";
 import {
+	ISummaryTreeWithStats,
 	ISummarizeResult,
 	gcBlobPrefix,
 	gcDeletedBlobKey,

package/src/gc/gcTelemetry.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { IGarbageCollectionData } from "@fluidframework/runtime-definitions";
+import { IGarbageCollectionData } from "@fluidframework/runtime-definitions/internal";
 import {
 	ITelemetryLoggerExt,
 	MonitoringContext,

package/src/gc/index.ts

@@ -30,7 +30,7 @@ export {
 	ISweepPhaseStats,
 	IGCStats,
 	oneDayMs,
-	runGCKey,
+	runGCTestKey,
 	runSessionExpiryKey,
 	runSweepKey,
 	stableGCVersion,

package/src/index.ts

@@ -97,7 +97,7 @@ export {
 	ICancellableSummarizerController,
 	SubmitSummaryFailureData,
 	SummaryStage,
-	IRetriableFailureResult,
+	IRetriableFailureError,
 	ISummarizeEventProps,
 	IdCompressorMode,
 	IDocumentSchema,
@@ -107,6 +107,11 @@ export {
 	DocumentsSchemaController,
 	IDocumentSchemaChangeMessage,
 	IDocumentSchemaFeatures,
+	ReadFluidDataStoreAttributes,
+	IFluidDataStoreAttributes0,
+	IFluidDataStoreAttributes1,
+	IFluidDataStoreAttributes2,
+	OmitAttributesVersions,
 } from "./summary/index.js";
 export { IChunkedOp, unpackRuntimeMessage } from "./opLifecycle/index.js";
 export { ChannelCollection } from "./channelCollection.js";

package/src/messageTypes.ts

@@ -175,11 +175,13 @@ export type InboundContainerRuntimeMessage =
 	| UnknownContainerRuntimeMessage
 	| ContainerRuntimeDocumentSchemaMessage;
 
-/** A {@link TypedContainerRuntimeMessage} that has been generated by the container runtime but is not yet being sent to the server. */
+/**
+ * A {@link TypedContainerRuntimeMessage} that has been generated by the container runtime but is not yet being sent to the server.
+ * These are messages generated by the local runtime, before the outbox's op virtualization step.
+ */
 export type LocalContainerRuntimeMessage =
 	| ContainerRuntimeDataStoreOpMessage
 	| OutboundContainerRuntimeAttachMessage
-	| ContainerRuntimeChunkedOpMessage
 	| ContainerRuntimeBlobAttachMessage
 	| ContainerRuntimeRejoinMessage
 	| ContainerRuntimeAliasMessage

package/src/opLifecycle/batchManager.ts

@@ -10,6 +10,11 @@ import { BatchMessage, IBatch, IBatchCheckpoint } from "./definitions.js";
 export interface IBatchManagerOptions {
 	readonly hardLimit: number;
 	readonly compressionOptions?: ICompressionRuntimeOptions;
+
+	/**
+	 * If true, the outbox is allowed to rebase the batch during flushing.
+	 */
+	readonly canRebase: boolean;
 }
 
 export interface BatchSequenceNumbers {

package/src/opLifecycle/outbox.ts

@@ -112,9 +112,9 @@ export class Outbox {
 		// We need to allow infinite size batches if we enable compression
 		const hardLimit = isCompressionEnabled ? Infinity : this.params.config.maxBatchSizeInBytes;
 
-		this.mainBatch = new BatchManager({ hardLimit });
-		this.blobAttachBatch = new BatchManager({ hardLimit });
-		this.idAllocationBatch = new BatchManager({ hardLimit });
+		this.mainBatch = new BatchManager({ hardLimit, canRebase: true });
+		this.blobAttachBatch = new BatchManager({ hardLimit, canRebase: true });
+		this.idAllocationBatch = new BatchManager({ hardLimit, canRebase: false });
 	}
 
 	public get messageCount(): number {
@@ -201,32 +201,7 @@ export class Outbox {
 	public submitIdAllocation(message: BatchMessage) {
 		this.maybeFlushPartialBatch();
 
-		if (
-			!this.idAllocationBatch.push(
-				message,
-				this.isContextReentrant(),
-				this.params.getCurrentSequenceNumbers().clientSequenceNumber,
-			)
-		) {
-			// BatchManager has two limits - soft limit & hard limit. Soft limit is only engaged
-			// when queue is not empty.
-			// Flush queue & retry. Failure on retry would mean - single message is bigger than hard limit
-			this.flushInternal(this.idAllocationBatch);
-
-			this.addMessageToBatchManager(this.idAllocationBatch, message);
-		}
-
-		// If compression is enabled, we will always successfully receive
-		// attach ops and compress then send them at the next JS turn, regardless
-		// of the overall size of the accumulated ops in the batch.
-		// However, it is more efficient to flush these ops faster, preferably
-		// after they reach a size which would benefit from compression.
-		if (
-			this.idAllocationBatch.contentSizeInBytes >=
-			this.params.config.compressionOptions.minimumBatchSizeInBytes
-		) {
-			this.flushInternal(this.idAllocationBatch);
-		}
+		this.addMessageToBatchManager(this.idAllocationBatch, message);
 	}
 
 	private addMessageToBatchManager(batchManager: BatchManager, message: BatchMessage) {
@@ -270,7 +245,7 @@ export class Outbox {
 		const rawBatch = batchManager.popBatch();
 		const shouldGroup =
 			!disableGroupedBatching && this.params.groupingManager.shouldGroup(rawBatch);
-		if (rawBatch.hasReentrantOps === true && shouldGroup) {
+		if (batchManager.options.canRebase && rawBatch.hasReentrantOps === true && shouldGroup) {
 			assert(!this.rebasing, 0x6fa /* A rebased batch should never have reentrant ops */);
 			// If a batch contains reentrant ops (ops created as a result from processing another op)
 			// it needs to be rebased so that we can ensure consistent reference sequence numbers
@@ -300,6 +275,7 @@ export class Outbox {
 	 */
 	private rebase(rawBatch: IBatch, batchManager: BatchManager) {
 		assert(!this.rebasing, 0x6fb /* Reentrancy */);
+		assert(batchManager.options.canRebase, "BatchManager does not support rebase");
 
 		this.rebasing = true;
 		for (const message of rawBatch.content) {
@@ -433,6 +409,7 @@ export class Outbox {
 		const mainBatch: IBatchCheckpoint = this.mainBatch.checkpoint();
 		return {
 			mainBatch,
+			idAllocationBatch: this.idAllocationBatch.checkpoint(),
 			blobAttachBatch: this.blobAttachBatch.checkpoint(),
 		};
 	}

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.0.0-dev-rc.4.0.0.261659";
+export const pkgVersion = "2.0.0-dev-rc.5.0.0.265721";