@fluidframework/container-runtime 2.117.0 → 3.0.0

package/src/opLifecycle/opSerialization.ts

@@ -3,7 +3,10 @@
  * Licensed under the MIT License.
  */
 
-import type { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
+import {
+	MessageType,
+	type ISequencedDocumentMessage,
+} from "@fluidframework/driver-definitions/internal";
 import {
 	encodeHandleForSerialization,
 	isFluidHandle,
@@ -29,6 +32,24 @@ export function ensureContentsDeserialized(mutableMessage: ISequencedDocumentMes
 	}
 }
 
+/**
+ * If `message` is a modern runtime-envelope op (type "op" with a client id), returns a shallow copy
+ * with its contents deserialized ({@link ensureContentsDeserialized}); otherwise `undefined`.
+ *
+ * @remarks Only runtime ops may be deserialized (system ops carry non-JSON payloads), and copying keeps
+ * the caller's op untouched for the unpack pipeline. Shared so callers don't re-derive the invariant.
+ */
+export function tryGetDeserializedRuntimeOpCopy(
+	message: ISequencedDocumentMessage,
+): (ISequencedDocumentMessage & { clientId: string }) | undefined {
+	if (message.type !== MessageType.Operation || typeof message.clientId !== "string") {
+		return undefined;
+	}
+	const messageCopy = { ...message };
+	ensureContentsDeserialized(messageCopy);
+	return messageCopy as ISequencedDocumentMessage & { clientId: string };
+}
+
 /**
  * Before submitting an op to the Outbox, its contents must be serialized using this function.
  * @remarks The deserialization on process happens via the function {@link ensureContentsDeserialized}.

package/src/opLifecycle/opSplitter.ts

@@ -30,6 +30,20 @@ export function isChunkedMessage(message: ISequencedDocumentMessage): boolean {
 	return isChunkedContents(message.contents);
 }
 
+/**
+ * Configures inbound chunk processing.
+ *
+ * @internal
+ */
+export interface OpSplitterOptions {
+	/**
+	 * Allows the first observed chunk stream for each client to begin after chunk 1. The unreconstructable
+	 * remainder of that stream is discarded, after which chunk ordering is strict. Historical readers use
+	 * this because their requested range can begin within a stream; live processing leaves it disabled.
+	 */
+	readonly allowInitialPartialChunkStream?: boolean;
+}
+
 interface IChunkedContents {
 	readonly type: typeof ContainerMessageType.ChunkedOp;
 	readonly contents: IChunkedOp;
@@ -45,6 +59,8 @@ function isChunkedContents(contents: unknown): contents is IChunkedContents {
 export class OpSplitter {
 	// Local copy of incomplete received chunks.
 	private readonly chunkMap: Map<string, string[]>;
+	// No entry = unseen; 1 = aligned; >1 = the next initial partial chunk to discard.
+	private readonly nextInitialChunkIdByClient = new Map<string, number>();
 	private readonly logger: TelemetryLoggerExt;
 
 	constructor(
@@ -55,8 +71,14 @@ export class OpSplitter {
 		public readonly chunkSizeInBytes: number,
 		private readonly maxBatchSizeInBytes: number,
 		logger: ITelemetryBaseLogger,
+		private readonly options: OpSplitterOptions = {},
 	) {
 		this.chunkMap = new Map<string, string[]>(chunks);
+		if (this.options.allowInitialPartialChunkStream === true) {
+			for (const clientId of this.chunkMap.keys()) {
+				this.nextInitialChunkIdByClient.set(clientId, 1);
+			}
+		}
 		this.logger = createChildLogger({ logger, namespace: "OpSplitter" });
 	}
 
@@ -76,6 +98,19 @@ export class OpSplitter {
 		}
 	}
 
+	private throwChunkIdMismatch(
+		originalMessage: ISequencedDocumentMessage,
+		chunkedContent: IChunkedOp,
+		expectedChunkId: number,
+	): never {
+		throw new DataCorruptionError("Chunk Id mismatch", {
+			...extractSafePropertiesFromMessage(originalMessage),
+			chunkMapLength: expectedChunkId - 1,
+			chunkId: chunkedContent.chunkId,
+			totalChunks: chunkedContent.totalChunks,
+		});
+	}
+
 	private addChunk(
 		clientId: string,
 		chunkedContent: IChunkedOp,
@@ -91,12 +126,7 @@ export class OpSplitter {
 			// We are expecting the chunks to be processed sequentially, in the same order as they are sent.
 			// Therefore, the chunkId of the incoming op needs to match the length of the array (1-based indexing)
 			// holding the existing chunks for that particular clientId.
-			throw new DataCorruptionError("Chunk Id mismatch", {
-				...extractSafePropertiesFromMessage(originalMessage),
-				chunkMapLength: map.length,
-				chunkId: chunkedContent.chunkId,
-				totalChunks: chunkedContent.totalChunks,
-			});
+			this.throwChunkIdMismatch(originalMessage, chunkedContent, map.length + 1);
 		}
 
 		map.push(chunkedContent.contents);
@@ -214,6 +244,33 @@ export class OpSplitter {
 
 		const clientId = message.clientId as string;
 		const chunkedContent = contents.contents;
+		if (this.options.allowInitialPartialChunkStream === true) {
+			const nextInitialChunkId = this.nextInitialChunkIdByClient.get(clientId);
+			if (nextInitialChunkId !== 1) {
+				if (
+					nextInitialChunkId !== undefined &&
+					chunkedContent.chunkId !== nextInitialChunkId
+				) {
+					this.throwChunkIdMismatch(message, chunkedContent, nextInitialChunkId);
+				}
+
+				if (
+					nextInitialChunkId === undefined &&
+					(chunkedContent.chunkId <= 1 || chunkedContent.chunkId > chunkedContent.totalChunks)
+				) {
+					this.nextInitialChunkIdByClient.set(clientId, 1);
+				} else {
+					this.nextInitialChunkIdByClient.set(
+						clientId,
+						chunkedContent.chunkId < chunkedContent.totalChunks
+							? chunkedContent.chunkId + 1
+							: 1,
+					);
+					return { isFinalChunk: false };
+				}
+			}
+		}
+
 		this.addChunk(clientId, chunkedContent, message);
 
 		if (chunkedContent.chunkId < chunkedContent.totalChunks) {

package/src/packageVersion.ts

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

package/src/runtimeLayerCompatState.ts

@@ -61,13 +61,14 @@ export const runtimeCompatDetailsForLoader: ILayerCompatDetails = {
 export const loaderSupportRequirementsForRuntime: ILayerCompatSupportRequirements = {
 	/**
 	 * Minimum generation that Loader must be at to be compatible with this Runtime. This is calculated
-	 * based on the LayerCompatibilityPolicyWindowMonths.RuntimeLoader value which defines how many months old can
-	 * the Loader layer be compared to the Runtime layer for them to still be considered compatible.
+	 * based on the LayerCompatibilityPolicyWindowMonths.NewRuntimeOldLoader value which defines how many months
+	 * old can the Loader layer be compared to the Runtime layer for them to still be considered compatible.
 	 * The minimum valid generation value is 0.
 	 */
 	minSupportedGeneration: Math.max(
 		0,
-		runtimeCoreCompatDetails.generation - LayerCompatibilityPolicyWindowMonths.RuntimeLoader,
+		runtimeCoreCompatDetails.generation -
+			LayerCompatibilityPolicyWindowMonths.NewRuntimeOldLoader,
 	),
 	/**
 	 * The features that the Loader must support to be compatible with Runtime.
@@ -94,14 +95,14 @@ export const runtimeCompatDetailsForDataStore: ILayerCompatDetails = {
 export const dataStoreSupportRequirementsForRuntime: ILayerCompatSupportRequirements = {
 	/**
 	 * Minimum generation that DataStore must be at to be compatible with this Runtime. This is calculated
-	 * based on the LayerCompatibilityPolicyWindowMonths.RuntimeDataStore value which defines how many months old can
-	 * the DataStore layer be compared to the Runtime layer for them to still be considered compatible.
+	 * based on the LayerCompatibilityPolicyWindowMonths.NewRuntimeOldDataStore value which defines how many months
+	 * old can the DataStore layer be compared to the Runtime layer for them to still be considered compatible.
 	 * The minimum valid generation value is 0.
 	 */
 	minSupportedGeneration: Math.max(
 		0,
 		runtimeCoreCompatDetails.generation -
-			LayerCompatibilityPolicyWindowMonths.RuntimeDataStore,
+			LayerCompatibilityPolicyWindowMonths.NewRuntimeOldDataStore,
 	),
 	/**
 	 * The features that the DataStore must support to be compatible with Runtime.
@@ -127,14 +128,17 @@ export function validateLoaderCompatibility(
 	);
 
 	validateLayerCompatibility(
-		"runtime",
-		"loader",
-		runtimeCompatDetailsForLoader,
-		loaderSupportRequirementsForRuntime,
-		maybeLoaderCompatDetailsForRuntime,
-		disposeFn,
-		mc,
-		disableStrictLoaderLayerCompatibilityCheck !== true /* strictCompatibilityCheck */,
+		/* validatingLayer */ {
+			layer: "runtime",
+			packageInfo: runtimeCoreCompatDetails,
+			compatSupportRequirements: loaderSupportRequirementsForRuntime,
+		},
+		/* targetLayer */ {
+			layer: "loader",
+			compatDetails: maybeLoaderCompatDetailsForRuntime,
+			strictCompatibilityCheck: disableStrictLoaderLayerCompatibilityCheck !== true,
+		},
+		{ disposeFn, mc },
 	);
 }
 
@@ -148,12 +152,15 @@ export function validateDatastoreCompatibility(
 	mc: MonitoringContext,
 ): void {
 	validateLayerCompatibility(
-		"runtime",
-		"dataStore",
-		runtimeCompatDetailsForDataStore,
-		dataStoreSupportRequirementsForRuntime,
-		maybeDataStoreCompatDetailsForRuntime,
-		disposeFn,
-		mc,
+		/* validatingLayer */ {
+			layer: "runtime",
+			packageInfo: runtimeCoreCompatDetails,
+			compatSupportRequirements: dataStoreSupportRequirementsForRuntime,
+		},
+		/* targetLayer */ {
+			layer: "dataStore",
+			compatDetails: maybeDataStoreCompatDetailsForRuntime,
+		},
+		{ disposeFn, mc },
 	);
 }

package/src/summary/documentSchema.ts

@@ -436,9 +436,11 @@ function and(
 	}
 
 	// We keep the persisted minVersionForCollab if present, even if the provided minVersionForCollab
-	// is higher.
+	// is higher, after migrating historical 2.x prerelease values to their stable versions.
 	const minVersionForCollab =
-		persistedSchema.info?.minVersionForCollab ?? providedSchema.info.minVersionForCollab;
+		persistedSchema.info === undefined
+			? providedSchema.info.minVersionForCollab
+			: normalizePersistedMinVersionForCollab(persistedSchema.info.minVersionForCollab);
 
 	return {
 		version: currentDocumentVersionSchema,
@@ -463,12 +465,16 @@ function or(
 		);
 	}
 
-	// We take the greater of the persisted/provided minVersionForCollab
-	const minVersionForCollab =
+	// We take the greater of the normalized persisted/provided minVersionForCollab.
+	const persistedMinVersionForCollab =
 		persistedSchema.info === undefined
+			? undefined
+			: normalizePersistedMinVersionForCollab(persistedSchema.info.minVersionForCollab);
+	const minVersionForCollab =
+		persistedMinVersionForCollab === undefined
 			? providedSchema.info.minVersionForCollab
-			: gt(persistedSchema.info.minVersionForCollab, providedSchema.info.minVersionForCollab)
-				? persistedSchema.info.minVersionForCollab
+			: gt(persistedMinVersionForCollab, providedSchema.info.minVersionForCollab)
+				? persistedMinVersionForCollab
 				: providedSchema.info.minVersionForCollab;
 
 	return {
@@ -479,6 +485,25 @@ function or(
 	};
 }
 
+/**
+ * Migrates 2.x prerelease values accepted by older clients to the corresponding stable version.
+ *
+ * @remarks
+ * This is monotonic under SemVer and can cross a compatibility checkpoint when the prerelease
+ * shares that checkpoint's major, minor, and patch. Client 3.0 no longer supports active
+ * prerelease collaborators, so the persisted requirement advances before format selection.
+ */
+function normalizePersistedMinVersionForCollab(
+	minVersionForCollab: SemanticVersion,
+): SemanticVersion {
+	const parsed = parse(minVersionForCollab);
+	if (parsed?.major === 2 && parsed.prerelease.length > 0) {
+		// `parse` validates each numeric component before this template is constructed.
+		return `${parsed.major}.${parsed.minor}.${parsed.patch}` as SemanticVersion;
+	}
+	return minVersionForCollab;
+}
+
 /**
  * Determines if two schemas are the "same".
  * Schemas are considered **not** the same if a schema change op is required to make