@fluidframework/container-runtime 2.0.0-rc.1.0.3 → 2.0.0-rc.2.0.0

package/src/gc/gcSummaryStateTracker.ts

@@ -13,10 +13,10 @@ import {
 	ISummaryTreeWithStats,
 } from "@fluidframework/runtime-definitions";
 import { mergeStats, SummaryTreeBuilder } from "@fluidframework/runtime-utils";
-import { IRefreshSummaryResult } from "../summary";
-import { GCVersion, IGarbageCollectorConfigs, IGCStats } from "./gcDefinitions";
-import { generateSortedGCState } from "./gcHelpers";
-import { IGarbageCollectionSnapshotData, IGarbageCollectionState } from "./gcSummaryDefinitions";
+import { IRefreshSummaryResult } from "../summary/index.js";
+import { GCVersion, IGarbageCollectorConfigs, IGCStats } from "./gcDefinitions.js";
+import { generateSortedGCState } from "./gcHelpers.js";
+import { IGarbageCollectionSnapshotData, IGarbageCollectionState } from "./gcSummaryDefinitions.js";
 
 export const gcStateBlobKey = `${gcBlobPrefix}_root`;
 
@@ -51,6 +51,18 @@ export class GCSummaryStateTracker {
 	// to unreferenced or vice-versa.
 	public updatedDSCountSinceLastSummary: number = 0;
 
+	/** API for ensuring the correct auto-recovery mitigations */
+	public autoRecovery = {
+		requestFullGCOnNextRun: () => {
+			this.fullGCModeForAutoRecovery = true;
+		},
+		fullGCRequested: () => {
+			return this.fullGCModeForAutoRecovery;
+		},
+	};
+	/** If true, the next GC run will do fullGC mode to regenerate the GC data for each node */
+	private fullGCModeForAutoRecovery: boolean = false;
+
 	constructor(
 		// Tells whether GC should run or not.
 		private readonly configs: Pick<
@@ -133,7 +145,6 @@ export class GCSummaryStateTracker {
 	 * If none of the components changed, it returns a summary handle for the entire GC data.
 	 */
 	public summarize(
-		fullTree: boolean,
 		trackState: boolean,
 		gcState: IGarbageCollectionState,
 		deletedNodes: Set<string>,
@@ -167,7 +178,7 @@ export class GCSummaryStateTracker {
 			serializedDeletedNodes,
 		};
 
-		if (trackState && !fullTree && this.latestSummaryData !== undefined) {
+		if (trackState && this.latestSummaryData !== undefined) {
 			// If nothing changed since last summary, send a summary handle for the entire GC data.
 			if (
 				this.latestSummaryData.serializedGCState === serializedGCState &&
@@ -267,7 +278,7 @@ export class GCSummaryStateTracker {
 	}
 
 	/**
-	 * Called to refresh the latest summary state. This happens when either a pending summary is acked.
+	 * Called to refresh the latest summary state. This happens when a pending summary is acked.
 	 */
 	public async refreshLatestSummary(result: IRefreshSummaryResult): Promise<void> {
 		if (!result.isSummaryTracked) {
@@ -287,6 +298,7 @@ export class GCSummaryStateTracker {
 		this.latestSummaryData = this.pendingSummaryData;
 		this.pendingSummaryData = undefined;
 		this.updatedDSCountSinceLastSummary = 0;
+		this.fullGCModeForAutoRecovery = false;
 		return;
 	}
 

package/src/gc/gcTelemetry.ts

@@ -3,16 +3,16 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryGenericEvent } from "@fluidframework/core-interfaces";
 import { IGarbageCollectionData } from "@fluidframework/runtime-definitions";
 import {
 	generateStack,
 	ITelemetryLoggerExt,
 	MonitoringContext,
 	tagCodeArtifacts,
+	type ITelemetryGenericEventExt,
 } from "@fluidframework/telemetry-utils";
-import { RuntimeHeaderData } from "../containerRuntime";
-import { ICreateContainerMetadata } from "../summary";
+import { RuntimeHeaderData } from "../containerRuntime.js";
+import { ICreateContainerMetadata } from "../summary/index.js";
 import {
 	GCNodeType,
 	UnreferencedState,
@@ -22,8 +22,8 @@ import {
 	throwOnTombstoneLoadOverrideKey,
 	runSweepKey,
 	GCFeatureMatrix,
-} from "./gcDefinitions";
-import { UnreferencedStateTracker } from "./gcUnreferencedStateTracker";
+} from "./gcDefinitions.js";
+import { UnreferencedStateTracker } from "./gcUnreferencedStateTracker.js";
 
 type NodeUsageType = "Changed" | "Loaded" | "Revived";
 
@@ -63,6 +63,7 @@ interface INodeUsageProps extends ICommonProps {
 	currentReferenceTimestampMs: number | undefined;
 	packagePath: readonly string[] | undefined;
 	fromId?: string;
+	autorecovery?: true;
 }
 
 /**
@@ -189,8 +190,6 @@ export class GCTelemetryTracker {
 		};
 
 		// If the node that is used is tombstoned, log a tombstone telemetry.
-		// Note that this is done before checking if "nodeStateTracker" is undefined below because unreferenced
-		// tracking may not have yet been enabled. That happens only after the client transitions to write mode.
 		if (nodeUsageProps.isTombstoned) {
 			this.logTombstoneUsageTelemetry(nodeUsageProps, unrefEventProps, nodeType, usageType);
 		}
@@ -344,7 +343,9 @@ export class GCTelemetryTracker {
 			}
 
 			if (missingExplicitRoutes.length > 0) {
-				logger.sendErrorEvent({
+				// Send as Generic not Error since there are known corner cases where this will fire.
+				// E.g. If an old client re-references a node via an attach op (that doesn't include GC Data)
+				logger.sendTelemetryEvent({
 					eventName: "gcUnknownOutboundReferences",
 					...tagCodeArtifacts({
 						id: nodeId,
@@ -412,7 +413,7 @@ export class GCTelemetryTracker {
  */
 export function sendGCUnexpectedUsageEvent(
 	mc: MonitoringContext,
-	event: ITelemetryGenericEvent & {
+	event: ITelemetryGenericEventExt & {
 		category: "error" | "generic";
 		gcTombstoneEnforcementAllowed: boolean | undefined;
 	},

package/src/gc/gcUnreferencedStateTracker.ts

@@ -5,7 +5,7 @@
 
 import { assert, Timer } from "@fluidframework/core-utils";
 import { validatePrecondition } from "@fluidframework/telemetry-utils";
-import { UnreferencedState } from "./gcDefinitions";
+import { UnreferencedState } from "./gcDefinitions.js";
 
 /** A wrapper around common-utils Timer that requires the timeout when calling start/restart */
 class TimerWithNoDefaultTimeout extends Timer {
@@ -25,6 +25,17 @@ class TimerWithNoDefaultTimeout extends Timer {
 	}
 }
 
+/** The collection of UnreferencedStateTrackers for all unreferenced nodes. Ensures stopTracking is called when deleting */
+export class UnreferencedStateTrackerMap extends Map<string, UnreferencedStateTracker> {
+	/** Delete the given key, and stop tracking if that node was actually unreferenced */
+	delete(key: string): boolean {
+		// Stop tracking so as to clear out any running timers.
+		this.get(key)?.stopTracking();
+		// Delete the node as we don't need to track it any more.
+		return super.delete(key);
+	}
+}
+
 /**
  * Helper class that tracks the state of an unreferenced node such as the time it was unreferenced and if it can
  * be tombstoned or deleted by the sweep phase.

package/src/gc/index.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-export { GarbageCollector } from "./garbageCollection";
+export { GarbageCollector } from "./garbageCollection.js";
 export {
 	nextGCVersion,
 	defaultInactiveTimeoutMs,
@@ -33,30 +33,32 @@ export {
 	runSessionExpiryKey,
 	runSweepKey,
 	stableGCVersion,
+	disableAutoRecoveryKey,
 	disableDatastoreSweepKey,
 	detectOutboundRoutesViaDDSKey,
 	UnreferencedState,
 	throwOnTombstoneLoadOverrideKey,
 	GarbageCollectionMessage,
+	GarbageCollectionMessageType,
 	ISweepMessage,
-} from "./gcDefinitions";
+} from "./gcDefinitions.js";
 export {
 	cloneGCData,
 	concatGarbageCollectionStates,
 	trimLeadingAndTrailingSlashes,
 	unpackChildNodesGCDetails,
-} from "./gcHelpers";
-export { runGarbageCollection } from "./gcReferenceGraphAlgorithm";
+} from "./gcHelpers.js";
+export { runGarbageCollection } from "./gcReferenceGraphAlgorithm.js";
 export {
 	IGarbageCollectionNodeData,
 	IGarbageCollectionSnapshotData,
 	IGarbageCollectionState,
 	IGarbageCollectionSummaryDetailsLegacy,
-} from "./gcSummaryDefinitions";
+} from "./gcSummaryDefinitions.js";
 export {
 	gcStateBlobKey,
 	GCSummaryStateTracker,
 	IGCSummaryTrackingData,
-} from "./gcSummaryStateTracker";
-export { GCTelemetryTracker, sendGCUnexpectedUsageEvent } from "./gcTelemetry";
-export { UnreferencedStateTracker } from "./gcUnreferencedStateTracker";
+} from "./gcSummaryStateTracker.js";
+export { GCTelemetryTracker, sendGCUnexpectedUsageEvent } from "./gcTelemetry.js";
+export { UnreferencedStateTracker } from "./gcUnreferencedStateTracker.js";

package/src/index.ts

@@ -14,25 +14,30 @@ export {
 	RuntimeMessage,
 	agentSchedulerId,
 	ContainerRuntime,
-	RuntimeHeaders,
-	AllowTombstoneRequestHeaderKey,
-	AllowInactiveRequestHeaderKey,
 	TombstoneResponseHeaderKey,
 	InactiveResponseHeaderKey,
 	ISummaryConfiguration,
 	DefaultSummaryConfiguration,
 	ICompressionRuntimeOptions,
 	CompressionAlgorithms,
-} from "./containerRuntime";
+} from "./containerRuntime.js";
 export {
 	ContainerMessageType,
 	ContainerRuntimeMessage,
 	IContainerRuntimeMessageCompatDetails,
 	CompatModeBehavior,
 	RecentlyAddedContainerRuntimeMessageDetails,
-} from "./messageTypes";
-export { IBlobManagerLoadInfo } from "./blobManager";
-export { FluidDataStoreRegistry } from "./dataStoreRegistry";
+	UnknownContainerRuntimeMessage,
+} from "./messageTypes.js";
+export { IBlobManagerLoadInfo } from "./blobManager.js";
+export { FluidDataStoreRegistry } from "./dataStoreRegistry.js";
+export {
+	detectOutboundReferences,
+	RuntimeHeaders,
+	ChannelCollectionFactory,
+	AllowTombstoneRequestHeaderKey,
+	AllowInactiveRequestHeaderKey,
+} from "./channelCollection.js";
 export {
 	GCNodeType,
 	IGCMetadata,
@@ -42,7 +47,7 @@ export {
 	IMarkPhaseStats,
 	ISweepPhaseStats,
 	IGCStats,
-} from "./gc";
+} from "./gc/index.js";
 export {
 	IAckedSummary,
 	ISummarizer,
@@ -91,22 +96,6 @@ export {
 	SummaryStage,
 	IRetriableFailureResult,
 	ISummarizeEventProps,
-} from "./summary";
-export { IChunkedOp, unpackRuntimeMessage } from "./opLifecycle";
-
-// Re-exports for backwards compatibility.
-// Will be removed in the future.
-export {
-	/**
-	 * @deprecated Import from `@fluidframework/id-compressor` instead.
-	 */
-	assertIsStableId,
-	/**
-	 * @deprecated Import from `@fluidframework/id-compressor` instead.
-	 */
-	generateStableId,
-	/**
-	 * @deprecated Import from `@fluidframework/id-compressor` instead.
-	 */
-	isStableId,
-} from "@fluidframework/id-compressor";
+	IdCompressorMode,
+} from "./summary/index.js";
+export { IChunkedOp, unpackRuntimeMessage } from "./opLifecycle/index.js";

package/src/messageTypes.ts

@@ -10,9 +10,9 @@ import {
 	IAttachMessage,
 } from "@fluidframework/runtime-definitions";
 import type { IdCreationRange } from "@fluidframework/id-compressor";
-import { IDataStoreAliasMessage } from "./dataStore";
-import { GarbageCollectionMessage } from "./gc";
-import { IChunkedOp } from "./opLifecycle";
+import { IDataStoreAliasMessage } from "./dataStore.js";
+import { GarbageCollectionMessage } from "./gc/index.js";
+import { IChunkedOp } from "./opLifecycle/index.js";
 
 /**
  * @alpha
@@ -133,7 +133,7 @@ export type ContainerRuntimeGCMessage = TypedContainerRuntimeMessage<
 >;
 
 /**
- * Represents an unrecognized {@link TypedContainerRuntimeMessage}, e.g. a message from a future version of the container runtime.
+ * Represents an unrecognized TypedContainerRuntimeMessage, e.g. a message from a future version of the container runtime.
  * @internal
  */
 export interface UnknownContainerRuntimeMessage

package/src/opLifecycle/README.md

@@ -65,8 +65,6 @@ Compression is relevant for both `FlushMode.TurnBased` and `FlushMode.Immediate`
 
 ## Grouped batching
 
-**Note: This feature is currently considered experimental and is not ready for production usage.**
-
 The `IContainerRuntimeOptions.enableGroupedBatching` option has been added to the container runtime layer and is **off by default**. This option will group all batch messages under a new "grouped" message to be sent to the service. Upon receiving this new "grouped" message, the batch messages will be extracted and given the sequence number of the parent "grouped" message.
 
 The purpose for enabling grouped batching on top of compression is that regular compression won't include the empty messages in the chunks. Thus, if we have batches with many messages (i.e. more than 4k), we will go over the batch size limit just on empty op envelopes alone.
@@ -75,7 +73,7 @@ See [below](#how-grouped-batching-works) for an example.
 
 ### Risks
 
-This option is experimental and should not be enabled yet in production. This option should **ONLY** be enabled after observing that 99.9% of your application sessions contains these changes (runtime version "2.0.0-internal.4.1.0" or later). Containers created with this option may not open in future versions of the framework.
+This option should **ONLY** be enabled after observing that 99.9% of your application sessions contains these changes (runtime version "2.0.0-internal.7.0.0" or later). Containers created with this option may not open in future versions of the framework.
 
 This option will change a couple of expectations around message structure and runtime layer expectations. Only enable this option after testing
 and verifying that the following expectation changes won't have any effects:
@@ -91,7 +89,7 @@ Therefore, when grouped batching is enabled, all batches with reentrant ops are
 
 ### How to enable
 
-**This feature is disabled by default, currently considered experimental and not ready for production usage.**
+**This feature is disabled by default**
 
 If all prerequisites in the previous section are met, enabling the feature can be done via the `IContainerRuntimeOptions` as following:
 

package/src/opLifecycle/batchManager.ts

@@ -3,8 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { ICompressionRuntimeOptions } from "../containerRuntime";
-import { BatchMessage, IBatch, IBatchCheckpoint } from "./definitions";
+import { ICompressionRuntimeOptions } from "../containerRuntime.js";
+import { BatchMessage, IBatch, IBatchCheckpoint } from "./definitions.js";
 
 export interface IBatchManagerOptions {
 	readonly hardLimit: number;

package/src/opLifecycle/definitions.ts

@@ -5,8 +5,8 @@
 
 import { IBatchMessage } from "@fluidframework/container-definitions";
 import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
-import { CompressionAlgorithms } from "../containerRuntime";
-import { ContainerMessageType } from "../messageTypes";
+import { CompressionAlgorithms } from "../containerRuntime.js";
+import { ContainerMessageType } from "../messageTypes.js";
 
 /**
  * Batch message type used internally by the runtime

package/src/opLifecycle/index.ts

@@ -3,17 +3,17 @@
  * Licensed under the MIT License.
  */
 
-export { BatchManager, estimateSocketSize, BatchSequenceNumbers } from "./batchManager";
+export { BatchManager, estimateSocketSize, BatchSequenceNumbers } from "./batchManager.js";
 export {
 	BatchMessage,
 	IBatch,
 	IBatchCheckpoint,
 	IChunkedOp,
 	IMessageProcessingResult,
-} from "./definitions";
-export { Outbox, getLongStack } from "./outbox";
-export { OpCompressor } from "./opCompressor";
-export { OpDecompressor } from "./opDecompressor";
-export { OpSplitter, splitOp } from "./opSplitter";
-export { RemoteMessageProcessor, unpackRuntimeMessage } from "./remoteMessageProcessor";
-export { OpGroupingManager } from "./opGroupingManager";
+} from "./definitions.js";
+export { Outbox, getLongStack } from "./outbox.js";
+export { OpCompressor } from "./opCompressor.js";
+export { OpDecompressor } from "./opDecompressor.js";
+export { OpSplitter, splitOp } from "./opSplitter.js";
+export { RemoteMessageProcessor, unpackRuntimeMessage } from "./remoteMessageProcessor.js";
+export { OpGroupingManager } from "./opGroupingManager.js";

package/src/opLifecycle/opCompressor.ts

@@ -8,9 +8,9 @@ import { assert } from "@fluidframework/core-utils";
 import { IsoBuffer } from "@fluid-internal/client-utils";
 import { compress } from "lz4js";
 import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
-import { CompressionAlgorithms } from "../containerRuntime";
-import { estimateSocketSize } from "./batchManager";
-import { IBatch, BatchMessage } from "./definitions";
+import { CompressionAlgorithms } from "../containerRuntime.js";
+import { estimateSocketSize } from "./batchManager.js";
+import { IBatch, BatchMessage } from "./definitions.js";
 
 /**
  * Compresses batches of ops. It generates a single compressed op that contains

package/src/opLifecycle/opDecompressor.ts

@@ -9,9 +9,9 @@ import { assert } from "@fluidframework/core-utils";
 import { IsoBuffer, Uint8ArrayToString } from "@fluid-internal/client-utils";
 import { createChildLogger } from "@fluidframework/telemetry-utils";
 import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
-import { CompressionAlgorithms } from "../containerRuntime";
-import { IBatchMetadata } from "../metadata";
-import { IMessageProcessingResult } from "./definitions";
+import { CompressionAlgorithms } from "../containerRuntime.js";
+import { IBatchMetadata } from "../metadata.js";
+import { IMessageProcessingResult } from "./definitions.js";
 
 /**
  * Compression makes assumptions about the shape of message contents. This interface codifies those assumptions, but does not validate them.

package/src/opLifecycle/opGroupingManager.ts

@@ -7,8 +7,8 @@ import { assert } from "@fluidframework/core-utils";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { createChildLogger } from "@fluidframework/telemetry-utils";
 import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
-import { ContainerMessageType } from "../messageTypes";
-import { IBatch } from "./definitions";
+import { ContainerMessageType } from "../messageTypes.js";
+import { IBatch } from "./definitions.js";
 
 /**
  * Grouping makes assumptions about the shape of message contents. This interface codifies those assumptions, but does not validate them.
@@ -96,21 +96,12 @@ export class OpGroupingManager {
 	}
 
 	public ungroupOp(op: ISequencedDocumentMessage): ISequencedDocumentMessage[] {
-		let fakeCsn = 1;
 		if (!isGroupContents(op.contents)) {
-			// Align the worlds of what clientSequenceNumber represents when grouped batching is enabled
-			if (this.config.groupedBatchingEnabled) {
-				return [
-					{
-						...op,
-						clientSequenceNumber: fakeCsn,
-					},
-				];
-			}
 			return [op];
 		}
 
 		const messages = op.contents.contents;
+		let fakeCsn = 1;
 		return messages.map((subMessage) => ({
 			...op,
 			clientSequenceNumber: fakeCsn++,

package/src/opLifecycle/opSplitter.ts

@@ -12,9 +12,9 @@ import { assert } from "@fluidframework/core-utils";
 import { IBatchMessage } from "@fluidframework/container-definitions";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
-import { ContainerMessageType, ContainerRuntimeChunkedOpMessage } from "../messageTypes";
-import { estimateSocketSize } from "./batchManager";
-import { BatchMessage, IBatch, IChunkedOp, IMessageProcessingResult } from "./definitions";
+import { ContainerMessageType, ContainerRuntimeChunkedOpMessage } from "../messageTypes.js";
+import { estimateSocketSize } from "./batchManager.js";
+import { BatchMessage, IBatch, IChunkedOp, IMessageProcessingResult } from "./definitions.js";
 
 /**
  * Responsible for creating and reconstructing chunked messages.

package/src/opLifecycle/outbox.ts

@@ -12,18 +12,19 @@ import {
 import { assert } from "@fluidframework/core-utils";
 import { IBatchMessage, ICriticalContainerError } from "@fluidframework/container-definitions";
 import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
-import { ICompressionRuntimeOptions } from "../containerRuntime";
-import { IPendingBatchMessage, PendingStateManager } from "../pendingStateManager";
+import { ICompressionRuntimeOptions } from "../containerRuntime.js";
+import { IPendingBatchMessage, PendingStateManager } from "../pendingStateManager.js";
+import { ContainerMessageType } from "../messageTypes.js";
 import {
 	BatchManager,
 	BatchSequenceNumbers,
 	estimateSocketSize,
 	sequenceNumbersMatch,
-} from "./batchManager";
-import { BatchMessage, IBatch, IBatchCheckpoint } from "./definitions";
-import { OpCompressor } from "./opCompressor";
-import { OpGroupingManager } from "./opGroupingManager";
-import { OpSplitter } from "./opSplitter";
+} from "./batchManager.js";
+import { BatchMessage, IBatch, IBatchCheckpoint } from "./definitions.js";
+import { OpCompressor } from "./opCompressor.js";
+import { OpGroupingManager } from "./opGroupingManager.js";
+import { OpSplitter } from "./opSplitter.js";
 
 export interface IOutboxConfig {
 	readonly compressionOptions: ICompressionRuntimeOptions;
@@ -136,10 +137,12 @@ export class Outbox {
 		const mainBatchSeqNums = this.mainBatch.sequenceNumbers;
 		const attachFlowBatchSeqNums = this.attachFlowBatch.sequenceNumbers;
 		const blobAttachSeqNums = this.blobAttachBatch.sequenceNumbers;
+		const idAllocSeqNums = this.idAllocationBatch.sequenceNumbers;
 		assert(
 			this.params.config.disablePartialFlush ||
 				(sequenceNumbersMatch(mainBatchSeqNums, attachFlowBatchSeqNums) &&
-					sequenceNumbersMatch(mainBatchSeqNums, blobAttachSeqNums)),
+					sequenceNumbersMatch(mainBatchSeqNums, blobAttachSeqNums) &&
+					sequenceNumbersMatch(mainBatchSeqNums, idAllocSeqNums)),
 			0x58d /* Reference sequence numbers from both batches must be in sync */,
 		);
 
@@ -148,7 +151,8 @@ export class Outbox {
 		if (
 			sequenceNumbersMatch(mainBatchSeqNums, currentSequenceNumbers) &&
 			sequenceNumbersMatch(attachFlowBatchSeqNums, currentSequenceNumbers) &&
-			sequenceNumbersMatch(blobAttachSeqNums, currentSequenceNumbers)
+			sequenceNumbersMatch(blobAttachSeqNums, currentSequenceNumbers) &&
+			sequenceNumbersMatch(idAllocSeqNums, currentSequenceNumbers)
 		) {
 			// The reference sequence numbers are stable, there is nothing to do
 			return;
@@ -178,12 +182,20 @@ export class Outbox {
 	}
 
 	public submit(message: BatchMessage) {
+		assert(
+			message.type !== ContainerMessageType.IdAllocation,
+			0x8f8 /* Allocation message submitted to mainBatch. */,
+		);
 		this.maybeFlushPartialBatch();
 
 		this.addMessageToBatchManager(this.mainBatch, message);
 	}
 
 	public submitAttach(message: BatchMessage) {
+		assert(
+			message.type === ContainerMessageType.Attach,
+			0x8f9 /* Non attach message submitted to attachFlowBatch. */,
+		);
 		this.maybeFlushPartialBatch();
 
 		if (
@@ -215,6 +227,10 @@ export class Outbox {
 	}
 
 	public submitBlobAttach(message: BatchMessage) {
+		assert(
+			message.type === ContainerMessageType.BlobAttach,
+			0x8fa /* Non blobAttach message submitted to blobAttachBatch. */,
+		);
 		this.maybeFlushPartialBatch();
 
 		this.addMessageToBatchManager(this.blobAttachBatch, message);
@@ -233,6 +249,10 @@ export class Outbox {
 	}
 
 	public submitIdAllocation(message: BatchMessage) {
+		assert(
+			message.type === ContainerMessageType.IdAllocation,
+			0x8fb /* Non allocation message submitted to idAllocationBatch. */,
+		);
 		this.maybeFlushPartialBatch();
 
 		if (

package/src/opLifecycle/remoteMessageProcessor.ts

@@ -10,10 +10,10 @@ import {
 	type InboundSequencedContainerRuntimeMessage,
 	type InboundSequencedContainerRuntimeMessageOrSystemMessage,
 	type InboundSequencedRecentlyAddedContainerRuntimeMessage,
-} from "../messageTypes";
-import { OpDecompressor } from "./opDecompressor";
-import { OpGroupingManager } from "./opGroupingManager";
-import { OpSplitter } from "./opSplitter";
+} from "../messageTypes.js";
+import { OpDecompressor } from "./opDecompressor.js";
+import { OpGroupingManager } from "./opGroupingManager.js";
+import { OpSplitter } from "./opSplitter.js";
 
 /**
  * Stateful class for processing incoming remote messages as the virtualization measures are unwrapped,

package/src/packageVersion.ts

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

package/src/pendingStateManager.ts

@@ -11,9 +11,9 @@ import { ICriticalContainerError } from "@fluidframework/container-definitions";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { DataProcessingError, ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 
-import { InboundSequencedContainerRuntimeMessage } from "./messageTypes";
-import { pkgVersion } from "./packageVersion";
-import { IBatchMetadata } from "./metadata";
+import { InboundSequencedContainerRuntimeMessage } from "./messageTypes.js";
+import { pkgVersion } from "./packageVersion.js";
+import { IBatchMetadata } from "./metadata.js";
 
 /**
  * This represents a message that has been submitted and is added to the pending queue when `submit` is called on the
@@ -48,6 +48,7 @@ export interface IRuntimeStateHandler {
 	reSubmit(message: IPendingBatchMessage): void;
 	reSubmitBatch(batch: IPendingBatchMessage[]): void;
 	isActiveConnection: () => boolean;
+	isAttached: () => boolean;
 }
 
 /** Union of keys of T */
@@ -182,28 +183,33 @@ export class PendingStateManager implements IDisposable {
 	public async applyStashedOpsAt(seqNum?: number) {
 		// apply stashed ops at sequence number
 		while (!this.initialMessages.isEmpty()) {
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			const nextMessage = this.initialMessages.peekFront()!;
 			if (seqNum !== undefined) {
-				if (nextMessage.referenceSequenceNumber > seqNum) {
+				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+				const peekMessage = this.initialMessages.peekFront()!;
+				if (peekMessage.referenceSequenceNumber > seqNum) {
 					break; // nothing left to do at this sequence number
 				}
-				if (nextMessage.referenceSequenceNumber < seqNum) {
+				if (peekMessage.referenceSequenceNumber < seqNum) {
 					throw new Error("loaded from snapshot too recent to apply stashed ops");
 				}
 			}
-
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			const nextMessage = this.initialMessages.shift()!;
 			try {
 				// applyStashedOp will cause the DDS to behave as if it has sent the op but not actually send it
 				const localOpMetadata = await this.stateHandler.applyStashedOp(nextMessage.content);
-				nextMessage.localOpMetadata = localOpMetadata;
+				if (!this.stateHandler.isAttached()) {
+					if (localOpMetadata !== undefined) {
+						throw new Error("Local Op Metadata must be undefined when not attached");
+					}
+				} else {
+					nextMessage.localOpMetadata = localOpMetadata;
+					// then we push onto pendingMessages which will cause PendingStateManager to resubmit when we connect
+					this.pendingMessages.push(nextMessage);
+				}
 			} catch (error) {
 				throw DataProcessingError.wrapIfUnrecognized(error, "applyStashedOp", nextMessage);
 			}
-
-			// then we push onto pendingMessages which will cause PendingStateManager to resubmit when we connect
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			this.pendingMessages.push(this.initialMessages.shift()!);
 		}
 	}