@fluidframework/container-runtime 2.43.0 → 2.50.0

package/src/dataStoreContext.ts

@@ -62,7 +62,7 @@ import {
 	type IPendingMessagesState,
 	type IRuntimeMessageCollection,
 	type IFluidDataStoreFactory,
-	type IFluidParentContext,
+	type PackagePath,
 } from "@fluidframework/runtime-definitions/internal";
 import {
 	addBlobToSummary,
@@ -149,7 +149,13 @@ export interface IFluidDataStoreContextProps {
 	readonly storage: IDocumentStorageService;
 	readonly scope: FluidObject;
 	readonly createSummarizerNodeFn: CreateChildSummarizerNodeFn;
-	readonly pkg?: Readonly<string[]>;
+	/**
+	 * See {@link FluidDataStoreContext.pkg}.
+	 */
+	readonly pkg?: PackagePath;
+	/**
+	 * See {@link FluidDataStoreContext.loadingGroupId}.
+	 */
 	readonly loadingGroupId?: string;
 }
 
@@ -179,8 +185,6 @@ export interface IRemoteFluidDataStoreContextProps extends IFluidDataStoreContex
 
 // back-compat: To be removed in the future.
 // Added in "2.0.0-rc.2.0.0" timeframe (to support older builds).
-/**
- */
 export interface IFluidDataStoreContextEvents extends IEvent {
 	(event: "attaching" | "attached", listener: () => void);
 }
@@ -235,13 +239,13 @@ class ContextDeltaManagerProxy extends BaseDeltaManagerProxy {
 }
 
 /**
- * Represents the context for the store. This context is passed to the store runtime.
+ * {@link IFluidDataStoreContext} for the implementations of {@link IFluidDataStoreChannel} which powers the {@link IDataStore}s.
  */
 export abstract class FluidDataStoreContext
 	extends TypedEventEmitter<IFluidDataStoreContextEvents>
-	implements IFluidDataStoreContextInternal, IFluidParentContext, IDisposable
+	implements IFluidDataStoreContextInternal, IFluidDataStoreContext, IDisposable
 {
-	public get packagePath(): readonly string[] {
+	public get packagePath(): PackagePath {
 		assert(this.pkg !== undefined, 0x139 /* "Undefined package path" */);
 		return this.pkg;
 	}
@@ -413,14 +417,32 @@ export abstract class FluidDataStoreContext
 
 	public readonly id: string;
 	private readonly _containerRuntime: IContainerRuntimeBase;
+	/**
+	 * Information for this data store from its parent.
+	 *
+	 * @remarks
+	 * The parent which provided this information currently can be the container runtime or a datastore (if the datastore this context is for is nested under another one).
+	 */
 	private readonly parentContext: IFluidParentContextPrivate;
 	public readonly storage: IDocumentStorageService;
 	public readonly scope: FluidObject;
-	// Represents the group to which the data store belongs too.
+	/**
+	 * The loading group to which the data store belongs to.
+	 */
 	public readonly loadingGroupId: string | undefined;
-	protected pkg?: readonly string[];
+	/**
+	 * {@link PackagePath} of this data store.
+	 *
+	 * This can be undefined when a data store is delay loaded, i.e., the attributes of this data store in the snapshot are not fetched until this data store is actually used.
+	 * At that time, the attributes blob is fetched and the pkg is updated from it.
+	 *
+	 * @see {@link PackagePath}.
+	 * @see {@link IFluidDataStoreContext.packagePath}.
+	 * @see {@link factoryFromPackagePath}.
+	 */
+	protected pkg?: PackagePath;
 
-	constructor(
+	public constructor(
 		props: IFluidDataStoreContextProps,
 		private readonly existing: boolean,
 		public readonly isLocalDataStore: boolean,
@@ -522,10 +544,13 @@ export abstract class FluidDataStoreContext
 		attachState: AttachState.Attaching | AttachState.Attached,
 	): void;
 
-	private rejectDeferredRealize(
+	/**
+	 * Throw a {@link LoggingError} indicating that {@link factoryFromPackagePath} failed.
+	 */
+	private factoryFromPackagePathError(
 		reason: string,
 		failedPkgPath?: string,
-		fullPackageName?: readonly string[],
+		fullPackageName?: PackagePath,
 	): never {
 		throw new LoggingError(
 			reason,
@@ -560,34 +585,45 @@ export abstract class FluidDataStoreContext
 		return this.channelP;
 	}
 
+	/**
+	 * Gets the factory that would be used to instantiate this data store by calling `instantiateDataStore` based on {@link pkg}.
+	 * @remarks
+	 * Also populates {@link registry}.
+	 *
+	 * Must be called after {@link pkg} is set, and only called once.
+	 *
+	 * @see {@link @fluidframework/container-runtime-definitions#IContainerRuntimeBase.createDataStore}.
+	 * @see {@link FluidDataStoreContext.pkg}.
+	 */
 	protected async factoryFromPackagePath(): Promise<IFluidDataStoreFactory> {
-		const packages = this.pkg;
-		if (packages === undefined) {
-			this.rejectDeferredRealize("packages is undefined");
+		const path = this.pkg;
+		if (path === undefined) {
+			this.factoryFromPackagePathError("packages is undefined");
 		}
 
 		let entry: FluidDataStoreRegistryEntry | undefined;
 		let registry: IFluidDataStoreRegistry | undefined =
 			this.parentContext.IFluidDataStoreRegistry;
-		let lastPkg: string | undefined;
-		for (const pkg of packages) {
+		let lastIdentifier: string | undefined;
+		// Follow the path, looking up each identifier in the registry along the way:
+		for (const identifier of path) {
 			if (!registry) {
-				this.rejectDeferredRealize("No registry for package", lastPkg, packages);
+				this.factoryFromPackagePathError("No registry for package", lastIdentifier, path);
 			}
-			lastPkg = pkg;
-			entry = registry.getSync?.(pkg) ?? (await registry.get(pkg));
+			lastIdentifier = identifier;
+			entry = registry.getSync?.(identifier) ?? (await registry.get(identifier));
 			if (!entry) {
-				this.rejectDeferredRealize(
+				this.factoryFromPackagePathError(
 					"Registry does not contain entry for the package",
-					pkg,
-					packages,
+					identifier,
+					path,
 				);
 			}
 			registry = entry.IFluidDataStoreRegistry;
 		}
 		const factory = entry?.IFluidDataStoreFactory;
 		if (factory === undefined) {
-			this.rejectDeferredRealize("Can't find factory for package", lastPkg, packages);
+			this.factoryFromPackagePathError("Can't find factory for package", lastIdentifier, path);
 		}
 
 		assert(this.registry === undefined, 0x157 /* "datastore registry already attached" */);
@@ -596,7 +632,7 @@ export abstract class FluidDataStoreContext
 		return factory;
 	}
 
-	createChildDataStore<T extends IFluidDataStoreFactory>(
+	public createChildDataStore<T extends IFluidDataStoreFactory>(
 		childFactory: T,
 	): ReturnType<Exclude<T["createDataStore"], undefined>> {
 		const maybe = this.registry?.getSync?.(childFactory.type);

package/src/gc/gcTelemetry.ts

@@ -77,7 +77,9 @@ interface INodeUsageProps extends ICommonProps {
 	 */
 	currentReferenceTimestampMs: number;
 	/**
-	 * The package path of the node. This may not be available if the node hasn't been loaded yet
+	 * The package path of the node. This may not be available if the node hasn't been loaded yet.
+	 *
+	 * @see {@link @fluidframework/runtime-definitions#IFluidDataStoreContext.packagePath} for more details.
 	 */
 	packagePath: readonly string[] | undefined;
 	/**

package/src/index.ts

@@ -112,3 +112,10 @@ export {
 	DefaultSummaryConfiguration,
 } from "./summary/index.js";
 export { IChunkedOp, unpackRuntimeMessage } from "./opLifecycle/index.js";
+export {
+	runtimeCoreCompatDetails,
+	runtimeCompatDetailsForLoader,
+	runtimeCompatDetailsForDataStore,
+	loaderSupportRequirementsForRuntime,
+	dataStoreSupportRequirementsForRuntime,
+} from "./runtimeLayerCompatState.js";

package/src/opLifecycle/outbox.ts

@@ -455,10 +455,7 @@ export class Outbox {
 		if (
 			batchManager.options.canRebase &&
 			rawBatch.hasReentrantOps === true &&
-			// NOTE: This is too restrictive. We should rebase for any reentrant op, not just if it's going to be a grouped batch
-			// However there is some test that is depending on this behavior so we haven't removed these conditions yet. See AB#33427
-			groupingEnabled &&
-			rawBatch.messages.length > 1
+			groupingEnabled
 		) {
 			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)

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.43.0";
+export const pkgVersion = "2.50.0";

package/src/runtimeLayerCompatState.ts

@@ -48,7 +48,7 @@ export const runtimeCompatDetailsForLoader: ILayerCompatDetails = {
  * The requirements that the Loader layer must meet to be compatible with this Runtime.
  * @internal
  */
-export const loaderSupportRequirements: ILayerCompatSupportRequirements = {
+export const loaderSupportRequirementsForRuntime: ILayerCompatSupportRequirements = {
 	/**
 	 * Minimum generation that Loader must be at to be compatible with Runtime. Note that 0 is used here so
 	 * that Loader layers before the introduction of the layer compatibility enforcement are compatible.
@@ -76,7 +76,7 @@ export const runtimeCompatDetailsForDataStore: ILayerCompatDetails = {
  * The requirements that the DataStore layer must meet to be compatible with this Runtime.
  * @internal
  */
-export const dataStoreSupportRequirements: ILayerCompatSupportRequirements = {
+export const dataStoreSupportRequirementsForRuntime: ILayerCompatSupportRequirements = {
 	/**
 	 * Minimum generation that DataStore must be at to be compatible with Runtime. Note that 0 is used here so
 	 * that DataStore layers before the introduction of the layer compatibility enforcement are compatible.
@@ -93,21 +93,21 @@ export const dataStoreSupportRequirements: ILayerCompatSupportRequirements = {
  * @internal
  */
 export function validateLoaderCompatibility(
-	maybeloaderCompatDetailsForRuntime: ILayerCompatDetails | undefined,
+	maybeLoaderCompatDetailsForRuntime: ILayerCompatDetails | undefined,
 	disposeFn: (error?: ICriticalContainerError) => void,
 ): void {
 	const layerCheckResult = checkLayerCompatibility(
-		loaderSupportRequirements,
-		maybeloaderCompatDetailsForRuntime,
+		loaderSupportRequirementsForRuntime,
+		maybeLoaderCompatDetailsForRuntime,
 	);
 	if (!layerCheckResult.isCompatible) {
 		const error = new UsageError("Runtime is not compatible with Loader", {
 			errorDetails: JSON.stringify({
 				runtimeVersion: runtimeCoreCompatDetails.pkgVersion,
-				loaderVersion: maybeloaderCompatDetailsForRuntime?.pkgVersion,
+				loaderVersion: maybeLoaderCompatDetailsForRuntime?.pkgVersion,
 				runtimeGeneration: runtimeCoreCompatDetails.generation,
-				loaderGeneration: maybeloaderCompatDetailsForRuntime?.generation,
-				minSupportedGeneration: loaderSupportRequirements.minSupportedGeneration,
+				loaderGeneration: maybeLoaderCompatDetailsForRuntime?.generation,
+				minSupportedGeneration: loaderSupportRequirementsForRuntime.minSupportedGeneration,
 				isGenerationCompatible: layerCheckResult.isGenerationCompatible,
 				unsupportedFeatures: layerCheckResult.unsupportedFeatures,
 			}),
@@ -126,7 +126,7 @@ export function validateDatastoreCompatibility(
 	disposeFn: () => void,
 ): void {
 	const layerCheckResult = checkLayerCompatibility(
-		dataStoreSupportRequirements,
+		dataStoreSupportRequirementsForRuntime,
 		maybeDataStoreCompatDetails,
 	);
 	if (!layerCheckResult.isCompatible) {
@@ -136,7 +136,7 @@ export function validateDatastoreCompatibility(
 				dataStoreVersion: maybeDataStoreCompatDetails?.pkgVersion,
 				runtimeGeneration: runtimeCoreCompatDetails.generation,
 				dataStoreGeneration: maybeDataStoreCompatDetails?.generation,
-				minSupportedGeneration: dataStoreSupportRequirements.minSupportedGeneration,
+				minSupportedGeneration: dataStoreSupportRequirementsForRuntime.minSupportedGeneration,
 				isGenerationCompatible: layerCheckResult.isGenerationCompatible,
 				unsupportedFeatures: layerCheckResult.unsupportedFeatures,
 			}),