@fluidframework/container-runtime 2.0.0-dev-rc.1.0.0.224419 → 2.0.0-dev-rc.1.0.0.228517

package/src/dataStores.ts

@@ -33,6 +33,7 @@ import {
 	create404Response,
 	createResponseError,
 	GCDataBuilder,
+	isSerializedHandle,
 	responseToException,
 	SummaryTreeBuilder,
 	unpackChildNodesUsedRoutes,
@@ -61,7 +62,7 @@ import {
 } from "./dataStoreContext";
 import { StorageServiceWithAttachBlobs } from "./storageServiceWithAttachBlobs";
 import { IDataStoreAliasMessage, isDataStoreAliasMessage } from "./dataStore";
-import { GCNodeType, disableDatastoreSweepKey } from "./gc";
+import { GCNodeType, detectOutboundRoutesViaDDSKey, disableDatastoreSweepKey } from "./gc";
 import { IContainerRuntimeMetadata, nonDataStorePaths, rootHasIsolatedChannels } from "./summary";
 
 type PendingAliasResolve = (success: boolean) => void;
@@ -441,6 +442,7 @@ export class DataStores implements IDisposable {
 		message: ISequencedDocumentMessage,
 		local: boolean,
 		localMessageMetadata: unknown,
+		addedOutboundReference: (fromNodePath: string, toNodePath: string) => void,
 	) {
 		const envelope = message.contents as IEnvelope;
 		const transformed = { ...message, contents: envelope.contents };
@@ -462,6 +464,13 @@ export class DataStores implements IDisposable {
 		assert(!!context, 0x162 /* "There should be a store context for the op" */);
 		context.process(transformed, local, localMessageMetadata);
 
+		// By default, we use the new behavior of detecting outbound routes here.
+		// If this setting is true, then DataStoreContext would be notifying GC instead.
+		if (this.mc.config.getBoolean(detectOutboundRoutesViaDDSKey) !== true) {
+			// Notify GC of any outbound references that were added by this op.
+			detectOutboundReferences(envelope, addedOutboundReference);
+		}
+
 		// Notify that a GC node for the data store changed. This is used to detect if a deleted data store is
 		// being used.
 		this.gcNodeUpdated(
@@ -830,12 +839,15 @@ export class DataStores implements IDisposable {
 
 			const dataStoreContext = this.contexts.get(dataStoreId);
 			if (dataStoreContext === undefined) {
-				this.mc.logger.sendErrorEvent({
+				// If the data store hasn't already been deleted, log an error because this should never happen.
+				// If the data store has already been deleted, log a telemetry event. This can happen because multiple GC
+				// sweep ops can contain the same data store. It would be interesting to track how often this happens.
+				const alreadyDeleted = this.isDataStoreDeleted(`/${dataStoreId}`);
+				this.mc.logger.sendTelemetryEvent({
 					eventName: "DeletedDataStoreNotFound",
+					category: alreadyDeleted ? "generic" : "error",
 					...tagCodeArtifacts({ id: dataStoreId }),
-					details: {
-						alreadyDeleted: this.isDataStoreDeleted(dataStoreId),
-					},
+					details: { alreadyDeleted },
 				});
 				continue;
 			}
@@ -851,8 +863,11 @@ export class DataStores implements IDisposable {
 	}
 
 	/**
-	 * This is called to update objects whose routes are tombstones. Tombstoned datastore contexts enable testing
-	 * scenarios with accessing deleted content without actually deleting content from summaries.
+	 * This is called to update objects whose routes are tombstones.
+	 *
+	 * A Tombstoned object has been unreferenced long enough that GC knows it won't be referenced again.
+	 * Tombstoned objects are eventually deleted by GC.
+	 *
 	 * @param tombstonedRoutes - The routes that are tombstones in all data stores in this Container.
 	 */
 	public updateTombstonedRoutes(tombstonedRoutes: readonly string[]) {
@@ -944,3 +959,42 @@ export function getSummaryForDatastores(
 		};
 	}
 }
+
+/**
+ * Traverse this op's contents and detect any outbound routes that were added by this op.
+ */
+export function detectOutboundReferences(
+	envelope: IEnvelope,
+	addedOutboundReference: (fromNodePath: string, toNodePath: string) => void,
+): void {
+	// These will be built up as we traverse the envelope contents
+	const outboundPaths: string[] = [];
+	let ddsAddress: string | undefined;
+
+	function recursivelyFindHandles(obj: unknown) {
+		if (typeof obj === "object" && obj !== null) {
+			for (const [key, value] of Object.entries(obj)) {
+				// If 'value' is a serialized IFluidHandle, it represents a new outbound route.
+				if (isSerializedHandle(value)) {
+					outboundPaths.push(value.url);
+				}
+
+				// NOTE: This is taking a hard dependency on the fact that in our DataStore implementation,
+				// the address of the DDS is stored in a property called "address".  This is not ideal.
+				// An alternative would be for the op envelope to include the absolute path (built up as it is submitted)
+				if (key === "address" && ddsAddress === undefined) {
+					ddsAddress = value;
+				}
+
+				recursivelyFindHandles(value);
+			}
+		}
+	}
+
+	recursivelyFindHandles(envelope.contents);
+
+	// GC node paths are all absolute paths, hence the "" prefix.
+	// e.g. this will yield "/dataStoreId/ddsId"
+	const fromPath = ["", envelope.address, ddsAddress].join("/");
+	outboundPaths.forEach((toPath) => addedOutboundReference(fromPath, toPath));
+}

package/src/gc/garbageCollection.ts

@@ -20,7 +20,9 @@ import {
 	ITelemetryLoggerExt,
 	MonitoringContext,
 	PerformanceEvent,
+	tagCodeArtifacts,
 } from "@fluidframework/telemetry-utils";
+import { BlobManager } from "../blobManager";
 import {
 	InactiveResponseHeaderKey,
 	RuntimeHeaderData,
@@ -261,7 +263,7 @@ export class GarbageCollector implements IGarbageCollector {
 			const currentReferenceTimestampMs = this.runtime.getCurrentReferenceTimestampMs();
 			assert(
 				currentReferenceTimestampMs !== undefined,
-				"Trying to initialize GC state without current timestamp",
+				0x8a4 /* Trying to initialize GC state without current timestamp */,
 			);
 
 			/**
@@ -288,7 +290,7 @@ export class GarbageCollector implements IGarbageCollector {
 							nodeData.unreferencedTimestampMs,
 							this.configs.inactiveTimeoutMs,
 							currentReferenceTimestampMs,
-							this.configs.sweepTimeoutMs,
+							this.configs.tombstoneTimeoutMs,
 							this.configs.sweepGracePeriodMs,
 						),
 					);
@@ -408,6 +410,7 @@ export class GarbageCollector implements IGarbageCollector {
 					{
 						eventName: "GCInitializationOrUpdateFailed",
 						gcConfigs: JSON.stringify(this.configs),
+						clientId,
 					},
 					error,
 				);
@@ -489,8 +492,11 @@ export class GarbageCollector implements IGarbageCollector {
 				const gcStats = await this.runGC(fullGC, currentReferenceTimestampMs, logger);
 				event.end({
 					...gcStats,
-					timestamp: currentReferenceTimestampMs,
-					sweep: this.configs.shouldRunSweep,
+					details: {
+						timestamp: currentReferenceTimestampMs,
+						sweep: this.configs.shouldRunSweep,
+						tombstone: this.configs.throwOnTombstoneLoad,
+					},
 				});
 
 				/** Post-GC steps */
@@ -607,7 +613,7 @@ export class GarbageCollector implements IGarbageCollector {
 						currentReferenceTimestampMs,
 						this.configs.inactiveTimeoutMs,
 						currentReferenceTimestampMs,
-						this.configs.sweepTimeoutMs,
+						this.configs.tombstoneTimeoutMs,
 						this.configs.sweepGracePeriodMs,
 					),
 				);
@@ -833,7 +839,7 @@ export class GarbageCollector implements IGarbageCollector {
 			gcFeatureMatrix: this.configs.persistedGcFeatureMatrix,
 			sessionExpiryTimeoutMs: this.configs.sessionExpiryTimeoutMs,
 			sweepEnabled: false, // DEPRECATED - to be removed
-			sweepTimeoutMs: this.configs.sweepTimeoutMs,
+			tombstoneTimeoutMs: this.configs.tombstoneTimeoutMs,
 		};
 	}
 
@@ -1001,6 +1007,18 @@ export class GarbageCollector implements IGarbageCollector {
 			return;
 		}
 
+		if (!toNodePath.startsWith("/")) {
+			// A long time ago we stored handles with relatives paths. We don't expect to see these cases though
+			// because GC was enabled only after we made the switch to always using absolute paths.
+			this.mc.logger.sendErrorEvent({
+				eventName: "InvalidRelativeOutboundRoute",
+				...tagCodeArtifacts({ fromId: fromNodePath, id: toNodePath }),
+			});
+			return;
+		}
+
+		assert(fromNodePath.startsWith("/"), 0x8a5 /* fromNodePath must be an absolute path */);
+
 		const outboundRoutes = this.newReferencesSinceLastRun.get(fromNodePath) ?? [];
 		outboundRoutes.push(toNodePath);
 		this.newReferencesSinceLastRun.set(fromNodePath, outboundRoutes);
@@ -1116,9 +1134,25 @@ export class GarbageCollector implements IGarbageCollector {
 			deletedAttachmentBlobCount: 0,
 		};
 
+		// The runtime can't reliably identify the type of deleted nodes. So, get the type here. This should
+		// be good enough because the only types that participate in GC today are data stores, DDSes and blobs.
+		const getDeletedNodeType = (nodeId: string): GCNodeType => {
+			const pathParts = nodeId.split("/");
+			if (pathParts[1] === BlobManager.basePath) {
+				return GCNodeType.Blob;
+			}
+			if (pathParts.length === 2) {
+				return GCNodeType.DataStore;
+			}
+			if (pathParts.length === 3) {
+				return GCNodeType.SubDataStore;
+			}
+			return GCNodeType.Other;
+		};
+
 		for (const nodeId of deletedNodes) {
 			sweepPhaseStats.deletedNodeCount++;
-			const nodeType = this.runtime.getNodeType(nodeId);
+			const nodeType = getDeletedNodeType(nodeId);
 			if (nodeType === GCNodeType.DataStore) {
 				sweepPhaseStats.deletedDataStoreCount++;
 			} else if (nodeType === GCNodeType.Blob) {

package/src/gc/gcConfigs.ts

@@ -31,6 +31,7 @@ import {
 	gcDisableThrowOnTombstoneLoadOptionName,
 	defaultSweepGracePeriodMs,
 	gcGenerationOptionName,
+	IGCMetadata_Deprecated,
 } from "./gcDefinitions";
 import { getGCVersion, shouldAllowGcSweep } from "./gcHelpers";
 
@@ -54,7 +55,7 @@ export function generateGCConfigs(
 ): IGarbageCollectorConfigs {
 	let gcEnabled: boolean;
 	let sessionExpiryTimeoutMs: number | undefined;
-	let sweepTimeoutMs: number | undefined;
+	let tombstoneTimeoutMs: number | undefined;
 	let persistedGcFeatureMatrix: GCFeatureMatrix | undefined;
 	let gcVersionInBaseSnapshot: GCVersion | undefined;
 
@@ -63,21 +64,25 @@ export function generateGCConfigs(
 	 * 1. Whether running GC mark phase is allowed or not.
 	 * 2. Whether running GC sweep phase is allowed or not.
 	 * 3. Whether GC session expiry is enabled or not.
-	 * For existing containers, we get this information from the createParams.metadata blob of its summary.
+	 * For existing containers, we get this information from the metadata blob of its summary.
 	 */
 	if (createParams.existing) {
-		gcVersionInBaseSnapshot = getGCVersion(createParams.metadata);
-		// Existing documents which did not have createParams.metadata blob or had GC disabled have version as 0. For all
+		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;
-		sessionExpiryTimeoutMs = createParams.metadata?.sessionExpiryTimeoutMs;
-		sweepTimeoutMs =
-			createParams.metadata?.sweepTimeoutMs ?? computeSweepTimeout(sessionExpiryTimeoutMs); // Backfill old documents that didn't persist this
-		persistedGcFeatureMatrix = createParams.metadata?.gcFeatureMatrix;
+		sessionExpiryTimeoutMs = metadata?.sessionExpiryTimeoutMs;
+		const legacyPersistedSweepTimeoutMs = (metadata as IGCMetadata_Deprecated)?.sweepTimeoutMs;
+		tombstoneTimeoutMs =
+			metadata?.tombstoneTimeoutMs ??
+			legacyPersistedSweepTimeoutMs ?? // Backfill old documents that have sweepTimeoutMs instead of tombstoneTimeoutMs
+			computeTombstoneTimeout(sessionExpiryTimeoutMs); // Backfill old documents that didn't persist either value
+		persistedGcFeatureMatrix = metadata?.gcFeatureMatrix;
 	} else {
 		// This Test Override only applies for new containers
-		const testOverrideSweepTimeoutMs = mc.config.getNumber(
-			"Fluid.GarbageCollection.TestOverride.SweepTimeoutMs",
+		const testOverrideTombstoneTimeoutMs = mc.config.getNumber(
+			"Fluid.GarbageCollection.TestOverride.TombstoneTimeoutMs",
 		);
 
 		// For new documents, GC is enabled by default. It can be explicitly disabled by setting the gcAllowed
@@ -89,7 +94,8 @@ export function generateGCConfigs(
 			sessionExpiryTimeoutMs =
 				createParams.gcOptions.sessionExpiryTimeoutMs ?? defaultSessionExpiryDurationMs;
 		}
-		sweepTimeoutMs = testOverrideSweepTimeoutMs ?? computeSweepTimeout(sessionExpiryTimeoutMs);
+		tombstoneTimeoutMs =
+			testOverrideTombstoneTimeoutMs ?? computeTombstoneTimeout(sessionExpiryTimeoutMs);
 
 		const gcGeneration = createParams.gcOptions[gcGenerationOptionName];
 		if (gcGeneration !== undefined) {
@@ -131,7 +137,7 @@ export function generateGCConfigs(
 	 * Whether sweep should run or not. This refers to whether Tombstones should fail on load and whether
 	 * sweep-ready nodes should be deleted.
 	 *
-	 * Assuming overall GC is enabled and sweepTimeout is provided, the following conditions have to be met to run sweep:
+	 * Assuming overall GC is enabled and Tombstone timeout is present, the following conditions have to be met to run sweep:
 	 *
 	 * 1. Sweep should be enabled for this container.
 	 * 2. Sweep should be enabled for this session.
@@ -139,7 +145,7 @@ export function generateGCConfigs(
 	 * These conditions can be overridden via the RunSweep feature flag.
 	 */
 	const shouldRunSweep =
-		!shouldRunGC || sweepTimeoutMs === undefined
+		!shouldRunGC || tombstoneTimeoutMs === undefined
 			? false
 			: mc.config.getBoolean(runSweepKey) ??
 			  (sweepAllowed && createParams.gcOptions.enableGCSweep === true);
@@ -150,9 +156,9 @@ export function generateGCConfigs(
 		createParams.gcOptions.inactiveTimeoutMs ??
 		defaultInactiveTimeoutMs;
 
-	// Inactive timeout must be greater than sweep timeout since a node goes from active -> inactive -> sweep ready.
-	if (sweepTimeoutMs !== undefined && inactiveTimeoutMs > sweepTimeoutMs) {
-		throw new UsageError("inactive timeout should not be greater than the sweep timeout");
+	// Inactive timeout must be greater than tombstone timeout since a node goes from active -> inactive -> sweep ready.
+	if (tombstoneTimeoutMs !== undefined && inactiveTimeoutMs > tombstoneTimeoutMs) {
+		throw new UsageError("inactive timeout should not be greater than the tombstone timeout");
 	}
 
 	// Whether we are running in test mode. In this mode, unreferenced nodes are immediately deleted.
@@ -190,7 +196,7 @@ export function generateGCConfigs(
 		testMode,
 		tombstoneMode,
 		sessionExpiryTimeoutMs,
-		sweepTimeoutMs,
+		tombstoneTimeoutMs,
 		sweepGracePeriodMs,
 		inactiveTimeoutMs,
 		persistedGcFeatureMatrix,
@@ -203,14 +209,16 @@ export function generateGCConfigs(
 }
 
 /**
- * Sweep timeout is the time after which unreferenced content can be swept.
- * Sweep timeout = session expiry timeout + snapshot cache expiry timeout + one day buffer.
+ * Tombstone timeout is the time after which unreferenced content is guaranteed not to be revived (re-referenced).
+ * Tombstone timeout = session expiry timeout + snapshot cache expiry timeout + one day buffer.
  *
  * The snapshot cache expiry timeout cannot be known precisely but the upper bound is 5 days.
  * The buffer is added to account for any clock skew or other edge cases.
  * We use server timestamps throughout so the skew should be minimal but make it 1 day to be safe.
+ *
+ * If there is no Session Expiry timeout, GC can never guarantee an object won't be revived, so return undefined.
  */
-function computeSweepTimeout(sessionExpiryTimeoutMs: number | undefined): number | undefined {
+function computeTombstoneTimeout(sessionExpiryTimeoutMs: number | undefined): number | undefined {
 	const bufferMs = oneDayMs;
 	return sessionExpiryTimeoutMs && sessionExpiryTimeoutMs + maxSnapshotCacheExpiryMs + bufferMs;
 }

package/src/gc/gcDefinitions.ts

@@ -74,13 +74,15 @@ export const gcVersionUpgradeToV4Key = "Fluid.GarbageCollection.GCVersionUpgrade
 export const disableDatastoreSweepKey = "Fluid.GarbageCollection.DisableDataStoreSweep";
 /** Config key to disable GC sweep for attachment blobs. */
 export const disableAttachmentBlobSweepKey = "Fluid.GarbageCollection.DisableAttachmentBlobSweep";
+/** Config key to revert new paradigm of detecting outbound routes in ContainerRuntime layer (use true) */
+export const detectOutboundRoutesViaDDSKey = "Fluid.GarbageCollection.DetectOutboundRoutesViaDDS";
 
 // One day in milliseconds.
 export const oneDayMs = 1 * 24 * 60 * 60 * 1000;
 
 /**
- * The maximum snapshot cache expiry in the driver. This is used to calculate the sweep timeout.
- * Sweep timeout = session expiry timeout + snapshot cache expiry timeout + a buffer.
+ * The maximum snapshot cache expiry in the driver. This is used to calculate the tombstone timeout.
+ * Tombstone timeout = session expiry timeout + snapshot cache expiry timeout + a buffer.
  * The snapshot cache expiry timeout cannot be known precisely but the upper bound is 5 days, i.e., any snapshot
  * in cache will be invalidated before 5 days.
  */
@@ -114,6 +116,21 @@ export type GCFeatureMatrix =
 	  };
 
 /**
+ * Deprecated properties formerly included in @see IGCMetadata.
+ * These may be found in old snapshots, so we need to support them for backwards compatibility.
+ */
+export interface IGCMetadata_Deprecated {
+	/**
+	 * How long to wait after an object is unreferenced before deleting it via GC Sweep
+	 *
+	 * @deprecated Replaced by @see IGCMetadata.tombstoneTimeoutMs
+	 */
+	readonly sweepTimeoutMs?: number;
+}
+
+/**
+ * GC-specific metadata to be written into the summary.
+ *
  * @alpha
  */
 export interface IGCMetadata {
@@ -148,8 +165,15 @@ export interface IGCMetadata {
 	readonly sweepEnabled?: boolean;
 	/** If this is present, the session for this container will expire after this time and the container will close */
 	readonly sessionExpiryTimeoutMs?: number;
-	/** How long to wait after an object is unreferenced before deleting it via GC Sweep */
-	readonly sweepTimeoutMs?: number;
+	/**
+	 * How long to wait after an object is unreferenced before it becomes a Tombstone.
+	 *
+	 * After this point, there's a grace period before the object is deleted.
+	 * @see IGCRuntimeOptions.sweepGracePeriodMs
+	 *
+	 * So the full sweep timeout in a session is tombstoneTimeoutMs + sweepGracePeriodMs.
+	 */
+	readonly tombstoneTimeoutMs?: number;
 }
 
 /**
@@ -445,8 +469,8 @@ export interface IGarbageCollectorConfigs {
 	readonly runFullGC: boolean | undefined;
 	/** The time in ms to expire a session for a client for gc. */
 	readonly sessionExpiryTimeoutMs: number | undefined;
-	/** The time after which an unreferenced node is ready to be swept. */
-	readonly sweepTimeoutMs: number | undefined;
+	/** The time after which an unreferenced node can be Tombstoned - i.e. GC knows it can't be referenced again (revived). */
+	readonly tombstoneTimeoutMs: number | undefined;
 	/**
 	 * The delay between tombstone and sweep. Not persisted, so concurrent sessions may use different values.
 	 * Sweep is implemented in an eventually-consistent way so this is acceptable.

package/src/gc/gcTelemetry.ts

@@ -66,13 +66,20 @@ interface INodeUsageProps extends ICommonProps {
 }
 
 /**
- * Encapsulates the logic that tracks the various telemetry logged by the Garbage Collector. There are 4 types of
- * telemetry logged:
+ * Encapsulates the logic that tracks the various telemetry logged by the Garbage Collector.
+ *
+ * These events are not logged as errors, just generic events, since there can be false positives:
+ *
  * 1. inactiveObject telemetry - When an inactive node is used - A node that has been unreferenced for inactiveTimeoutMs.
- * 2. sweepReadyObject telemetry - When a sweep ready node is used - A node that has been unreferenced for sweepTimeoutMs.
- * 3. Tombstone telemetry - When a tombstoned node is used - A node that that has been marked as tombstone.
- * 4. Sweep / deleted telemetry - When a node is detected as sweep ready in the sweep phase.
- * 5. Unknown outbound reference telemetry - When a node is referenced but GC is not explicitly notified of it.
+ * 2. tombstoneReadyObject telemetry - When a tombstone-ready node is used - A node that has been unreferenced for tombstoneTimeoutMs.
+ * 3. sweepReadyObject telemetry - When a sweep-ready node is used - A node that has been unreferenced for tombstoneTimeoutMs + sweepGracePeriodMs.
+ *
+ * These events are logged as errors since they are based on the core GC logic:
+ *
+ * 1. Tombstone telemetry - When a tombstoned node is used - A node that has been marked as tombstone.
+ * 2. Unknown outbound reference telemetry - When a node is referenced but GC was not notified of it when the new reference appeared.
+ *
+ * Note: The telemetry for a Deleted node being used is logged elsewhere in this package.
  */
 export class GCTelemetryTracker {
 	// Keeps track of unreferenced events that are logged for a node. This is used to limit the log generation to one
@@ -147,11 +154,11 @@ export class GCTelemetryTracker {
 				case UnreferencedState.Inactive:
 					return this.configs.inactiveTimeoutMs;
 				case UnreferencedState.TombstoneReady:
-					return this.configs.sweepTimeoutMs;
+					return this.configs.tombstoneTimeoutMs;
 				case UnreferencedState.SweepReady:
 					return (
-						this.configs.sweepTimeoutMs &&
-						this.configs.sweepTimeoutMs + this.configs.sweepGracePeriodMs
+						this.configs.tombstoneTimeoutMs &&
+						this.configs.tombstoneTimeoutMs + this.configs.sweepGracePeriodMs
 					);
 				default:
 					return undefined;
@@ -389,6 +396,9 @@ export class GCTelemetryTracker {
 						fromPkg: fromPkg?.join("/"),
 					}),
 				};
+
+				// These are logged as generic events and not errors because there can be false positives. The Tombstone
+				// and Delete errors are separately logged and are reliable.
 				logger.sendTelemetryEvent(event);
 			}
 		}

package/src/gc/index.ts

@@ -21,6 +21,7 @@ export {
 	IGarbageCollectorConfigs,
 	IGarbageCollectorCreateParams,
 	IGCMetadata,
+	IGCMetadata_Deprecated,
 	IGCResult,
 	IGCRuntimeOptions,
 	IMarkPhaseStats,
@@ -33,9 +34,11 @@ export {
 	stableGCVersion,
 	disableAttachmentBlobSweepKey,
 	disableDatastoreSweepKey,
+	detectOutboundRoutesViaDDSKey,
 	UnreferencedState,
 	throwOnTombstoneLoadOverrideKey,
 	GarbageCollectionMessage,
+	ISweepMessage,
 } from "./gcDefinitions";
 export {
 	cloneGCData,

package/src/opLifecycle/definitions.ts

@@ -5,7 +5,7 @@
 
 import { IBatchMessage } from "@fluidframework/container-definitions";
 import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
-import { CompressionAlgorithms } from "..";
+import { CompressionAlgorithms } from "../containerRuntime";
 import { ContainerMessageType } from "../messageTypes";
 
 /**

package/src/opLifecycle/outbox.ts

@@ -20,7 +20,7 @@ import {
 	estimateSocketSize,
 	sequenceNumbersMatch,
 } from "./batchManager";
-import { BatchMessage, IBatch } from "./definitions";
+import { BatchMessage, IBatch, IBatchCheckpoint } from "./definitions";
 import { OpCompressor } from "./opCompressor";
 import { OpGroupingManager } from "./opGroupingManager";
 import { OpSplitter } from "./opSplitter";
@@ -462,8 +462,11 @@ export class Outbox {
 	}
 
 	public checkpoint() {
+		// This variable is declared with a specific type so that we have a standard import of the IBatchCheckpoint type.
+		// When the type is inferred, the generated .d.ts uses a dynamic import which doesn't resolve.
+		const mainBatch: IBatchCheckpoint = this.mainBatch.checkpoint();
 		return {
-			mainBatch: this.mainBatch.checkpoint(),
+			mainBatch,
 			attachFlowBatch: this.attachFlowBatch.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.1.0.0.224419";
+export const pkgVersion = "2.0.0-dev-rc.1.0.0.228517";