@fluidframework/container-runtime 2.41.0-338401 → 2.42.0

package/src/dataStore.ts

@@ -11,6 +11,8 @@ import {
 	AliasResult,
 	IDataStore,
 	IFluidDataStoreChannel,
+	// eslint-disable-next-line import/no-deprecated
+	type IContainerRuntimeBaseExperimental,
 } from "@fluidframework/runtime-definitions/internal";
 import {
 	ITelemetryLoggerExt,
@@ -78,6 +80,11 @@ class DataStore implements IDataStore {
 		if (alias.includes("/")) {
 			throw new UsageError(`The alias cannot contain slashes: '${alias}'`);
 		}
+		// eslint-disable-next-line import/no-deprecated
+		const runtime = this.parentContext.containerRuntime as IContainerRuntimeBaseExperimental;
+		if (runtime.inStagingMode === true) {
+			throw new UsageError("Cannot set aliases while in staging mode");
+		}
 
 		switch (this.aliasState) {
 			// If we're already aliasing, check if it's for the same value and return

package/src/gc/garbageCollection.ts

@@ -1045,6 +1045,8 @@ export class GarbageCollector implements IGarbageCollector {
 
 		// Any time we log a Tombstone Loaded error (via Telemetry Tracker),
 		// we want to also trigger autorecovery to avoid the object being deleted
+		// i.e. this will be preceded by one of these telemetry events;
+		// GC_Tombstone_DataStore_Requested, GC_Tombstone_SubDataStore_Requested, GC_Tombstone_Blob_Requested
 		// Note: We don't need to trigger on "Changed" because any change will cause the object
 		// to be loaded by the Summarizer, and auto-recovery will be triggered then.
 		if (isTombstoned && reason === "Loaded") {

package/src/gc/gcDefinitions.ts

@@ -448,7 +448,7 @@ export interface IGarbageCollector {
 	 * Returns true if this node has been deleted by GC during sweep phase.
 	 */
 	isNodeDeleted(nodePath: string): boolean;
-	setConnectionState(connected: boolean, clientId?: string): void;
+	setConnectionState(canSendOps: boolean, clientId?: string): void;
 	dispose(): void;
 }
 

package/src/index.ts

@@ -95,7 +95,8 @@ export {
 	IDocumentSchemaCurrent,
 	currentDocumentVersionSchema,
 	DocumentsSchemaController,
-	IDocumentSchemaChangeMessage,
+	IDocumentSchemaChangeMessageIncoming,
+	IDocumentSchemaChangeMessageOutgoing,
 	IDocumentSchemaFeatures,
 	ReadFluidDataStoreAttributes,
 	IFluidDataStoreAttributes0,

package/src/messageTypes.ts

@@ -14,7 +14,10 @@ import {
 import { IDataStoreAliasMessage } from "./dataStore.js";
 import { GarbageCollectionMessage } from "./gc/index.js";
 import { IChunkedOp } from "./opLifecycle/index.js";
-import { IDocumentSchemaChangeMessage } from "./summary/index.js";
+import {
+	type IDocumentSchemaChangeMessageIncoming,
+	type IDocumentSchemaChangeMessageOutgoing,
+} from "./summary/index.js";
 
 /**
  * @legacy
@@ -112,9 +115,13 @@ export type ContainerRuntimeGCMessage = TypedContainerRuntimeMessage<
 	ContainerMessageType.GC,
 	GarbageCollectionMessage
 >;
-export type ContainerRuntimeDocumentSchemaMessage = TypedContainerRuntimeMessage<
+export type InboundContainerRuntimeDocumentSchemaMessage = TypedContainerRuntimeMessage<
+	ContainerMessageType.DocumentSchemaChange,
+	IDocumentSchemaChangeMessageIncoming
+>;
+export type OutboundContainerRuntimeDocumentSchemaMessage = TypedContainerRuntimeMessage<
 	ContainerMessageType.DocumentSchemaChange,
-	IDocumentSchemaChangeMessage
+	IDocumentSchemaChangeMessageOutgoing
 >;
 
 /**
@@ -147,7 +154,7 @@ export type InboundContainerRuntimeMessage =
 	| ContainerRuntimeAliasMessage
 	| ContainerRuntimeIdAllocationMessage
 	| ContainerRuntimeGCMessage
-	| ContainerRuntimeDocumentSchemaMessage
+	| InboundContainerRuntimeDocumentSchemaMessage
 	// Inbound messages may include unknown types from other clients, so we include that as a special case here
 	| UnknownContainerRuntimeMessage;
 
@@ -163,7 +170,7 @@ export type LocalContainerRuntimeMessage =
 	| ContainerRuntimeAliasMessage
 	| ContainerRuntimeIdAllocationMessage
 	| ContainerRuntimeGCMessage
-	| ContainerRuntimeDocumentSchemaMessage
+	| OutboundContainerRuntimeDocumentSchemaMessage
 	// In rare cases (e.g. related to stashed ops) we could have a local message of an unknown type
 	| UnknownContainerRuntimeMessage;
 

package/src/metadata.ts

@@ -26,7 +26,7 @@ export function asEmptyBatchLocalOpMetadata(
  */
 export interface IEmptyBatchMetadata {
 	// Set to true on localOpMetadata for empty batches
-	emptyBatch?: boolean;
+	emptyBatch?: true;
 }
 /**
  * Properties put on the op metadata object for batch tracking

package/src/opLifecycle/batchManager.ts

@@ -11,6 +11,7 @@ import {
 } from "@fluidframework/telemetry-utils/internal";
 
 import { ICompressionRuntimeOptions } from "../compressionDefinitions.js";
+import { isContainerMessageDirtyable } from "../containerRuntime.js";
 import { asBatchMetadata, type IBatchMetadata } from "../metadata.js";
 import type { IPendingMessage } from "../pendingStateManager.js";
 
@@ -168,6 +169,13 @@ export class BatchManager {
 			},
 		};
 	}
+
+	/**
+	 * Does this batch current contain user changes ("dirtyable" ops)?
+	 */
+	public containsUserChanges(): boolean {
+		return this.pendingBatch.some((message) => isContainerMessageDirtyable(message.runtimeOp));
+	}
 }
 
 const addBatchMetadata = (batch: LocalBatch, batchId?: BatchId): LocalBatch => {

package/src/opLifecycle/definitions.ts

@@ -7,6 +7,9 @@ import type { IBatchMessage } from "@fluidframework/container-definitions/intern
 
 import { CompressionAlgorithms } from "../compressionDefinitions.js";
 import type { LocalContainerRuntimeMessage } from "../messageTypes.js";
+import type { IEmptyBatchMetadata } from "../metadata.js";
+
+import type { EmptyGroupedBatch } from "./opGroupingManager.js";
 
 /**
  * Local Batch message, before it is virtualized and sent to the ordering service
@@ -34,7 +37,7 @@ export interface LocalBatchMessage {
 	staged?: boolean;
 
 	/**
-	 * @deprecated Use serializedOp
+	 * @deprecated Use runtimeOp
 	 */
 	contents?: never; // To ensure we don't leave this one when converting from OutboundBatchMessage
 }
@@ -44,8 +47,9 @@ export interface LocalBatchMessage {
  */
 export interface LocalEmptyBatchPlaceholder {
 	metadata?: Record<string, unknown>;
-	localOpMetadata: { emptyBatch: true };
+	localOpMetadata: Required<IEmptyBatchMetadata>;
 	referenceSequenceNumber: number;
+	runtimeOp: EmptyGroupedBatch;
 }
 
 /**
@@ -59,7 +63,7 @@ export type OutboundBatchMessage = IBatchMessage & {
 	/**
 	 * @deprecated Use contents
 	 */
-	serializedOp?: never; // To ensure we don't leave this one when converting from LocalBatchMessage
+	runtimeOp?: never; // To ensure we don't leave this one when converting from LocalBatchMessage
 };
 
 /**

package/src/opLifecycle/index.ts

@@ -43,6 +43,7 @@ export {
 	unpackRuntimeMessage,
 } from "./remoteMessageProcessor.js";
 export {
+	EmptyGroupedBatch,
 	OpGroupingManager,
 	OpGroupingManagerConfig,
 	isGroupedBatch,

package/src/opLifecycle/opGroupingManager.ts

@@ -46,6 +46,16 @@ export interface OpGroupingManagerConfig {
 	readonly groupedBatchingEnabled: boolean;
 }
 
+/**
+ * This is the type of an empty grouped batch we send over the wire
+ * We also put this in the placeholder for an empty batch in the PendingStateManager.
+ * But most places throughout the ContainerRuntime, this will not be used (just as Grouped Batches in general don't appear outside opLifecycle dir)
+ */
+export interface EmptyGroupedBatch {
+	type: typeof OpGroupingManager.groupedBatchOp;
+	contents: readonly unknown[];
+}
+
 export class OpGroupingManager {
 	static readonly groupedBatchOp = "groupedBatch";
 	private readonly logger: ITelemetryLoggerExt;
@@ -75,19 +85,22 @@ export class OpGroupingManager {
 			this.config.groupedBatchingEnabled,
 			0xa00 /* cannot create empty grouped batch when grouped batching is disabled */,
 		);
-		const serializedOp = JSON.stringify({
-			type: OpGroupingManager.groupedBatchOp,
+
+		const emptyGroupedBatch: EmptyGroupedBatch = {
+			type: "groupedBatch",
 			contents: [],
-		});
+		};
+		const serializedOp = JSON.stringify(emptyGroupedBatch);
 
 		const placeholderMessage: LocalEmptyBatchPlaceholder = {
 			metadata: { batchId: resubmittingBatchId },
 			localOpMetadata: { emptyBatch: true },
 			referenceSequenceNumber,
+			runtimeOp: emptyGroupedBatch,
 		};
 		const outboundBatch: OutboundSingletonBatch = {
 			contentSizeInBytes: 0,
-			messages: [{ ...placeholderMessage, contents: serializedOp }],
+			messages: [{ ...placeholderMessage, runtimeOp: undefined, contents: serializedOp }],
 			referenceSequenceNumber,
 		};
 		return { outboundBatch, placeholderMessage };

package/src/opLifecycle/opSerialization.ts

@@ -12,6 +12,8 @@ import {
 
 import type { LocalContainerRuntimeMessage } from "../messageTypes.js";
 
+import type { EmptyGroupedBatch } from "./opGroupingManager.js";
+
 /**
  * Takes an incoming runtime message (outer type "op"), JSON.parses the message's contents in place,
  * if needed (old Loader does this for us).
@@ -34,7 +36,10 @@ export function ensureContentsDeserialized(mutableMessage: ISequencedDocumentMes
  * @param toSerialize - op message to serialize. Also supports an array of ops.
  */
 export function serializeOp(
-	toSerialize: LocalContainerRuntimeMessage | LocalContainerRuntimeMessage[],
+	toSerialize:
+		| EmptyGroupedBatch
+		| LocalContainerRuntimeMessage
+		| LocalContainerRuntimeMessage[],
 ): string {
 	return JSON.stringify(
 		toSerialize,

package/src/opLifecycle/outbox.ts

@@ -236,6 +236,13 @@ export class Outbox {
 		return this.messageCount === 0;
 	}
 
+	public containsUserChanges(): boolean {
+		return (
+			this.mainBatch.containsUserChanges() || this.blobAttachBatch.containsUserChanges()
+			// ID Allocation ops are not user changes
+		);
+	}
+
 	/**
 	 * Detect whether batching has been interrupted by an incoming message being processed. In this case,
 	 * we will flush the accumulated messages to account for that (if allowed) and create a new batch with the new
@@ -440,7 +447,7 @@ export class Outbox {
 		const staged = rawBatch.staged === true;
 		assert(
 			resubmitInfo === undefined || resubmitInfo.staged === staged,
-			"Mismatch in staged state tracking",
+			0xba3 /* Mismatch in staged state tracking */,
 		);
 
 		const groupingEnabled =

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.41.0-338401";
+export const pkgVersion = "2.42.0";

package/src/pendingStateManager.ts

@@ -15,6 +15,7 @@ import {
 import Deque from "double-ended-queue";
 import { v4 as uuid } from "uuid";
 
+import { isContainerMessageDirtyable } from "./containerRuntime.js";
 import {
 	type InboundContainerRuntimeMessage,
 	type InboundSequencedContainerRuntimeMessage,
@@ -22,6 +23,7 @@ import {
 } from "./messageTypes.js";
 import { asBatchMetadata, asEmptyBatchLocalOpMetadata } from "./metadata.js";
 import {
+	EmptyGroupedBatch,
 	LocalBatchMessage,
 	getEffectiveBatchId,
 	BatchStartInfo,
@@ -48,9 +50,20 @@ export interface IPendingMessage {
 	 * The original runtime op that was submitted to the ContainerRuntime
 	 * Unless this pending message came from stashed content, in which case this was roundtripped through string
 	 */
-	runtimeOp?: LocalContainerRuntimeMessage | undefined; // Undefined for empty batches and initial messages before parsing
+	runtimeOp?: LocalContainerRuntimeMessage | EmptyGroupedBatch | undefined; // Undefined for initial messages before parsing
+	/**
+	 * Local Op Metadata that was passed to the ContainerRuntime when the op was submitted.
+	 * This contains state needed when processing the ack, or to resubmit or rollback the op.
+	 */
 	localOpMetadata: unknown;
+	/**
+	 * Metadata that was passed to the ContainerRuntime when the op was submitted.
+	 * This is rarely used, and may be inspected by the service (as opposed to op contents which is opaque)
+	 */
 	opMetadata: Record<string, unknown> | undefined;
+	/**
+	 * Populated upon processing the op's ack, before moving the pending message to savedOps.
+	 */
 	sequenceNumber?: number;
 	/**
 	 * Info about the batch this pending message belongs to, for validation and for computing the batchId on reconnect
@@ -134,9 +147,7 @@ export interface IRuntimeStateHandler {
 }
 
 function isEmptyBatchPendingMessage(message: IPendingMessageFromStash): boolean {
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-	const content = JSON.parse(message.content);
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+	const content = JSON.parse(message.content) as Partial<EmptyGroupedBatch>;
 	return content.type === "groupedBatch" && content.contents?.length === 0;
 }
 
@@ -282,6 +293,25 @@ export class PendingStateManager implements IDisposable {
 		return this.pendingMessages.length + this.initialMessages.length;
 	}
 
+	/**
+	 * Checks the pending messages to see if any of them represent user changes (aka "dirtyable" messages)
+	 */
+	public hasPendingUserChanges(): boolean {
+		for (let i = 0; i < this.pendingMessages.length; i++) {
+			const element = this.pendingMessages.get(i);
+			if (
+				element?.runtimeOp !== undefined &&
+				isNotEmptyGroupedBatch(element) &&
+				isContainerMessageDirtyable(element.runtimeOp)
+			) {
+				return true;
+			}
+		}
+		// Consider any initial messages to be user changes
+		// (it's an approximation since we would have to parse them to know for sure)
+		return this.initialMessages.length > 0;
+	}
+
 	/**
 	 * The minimumPendingMessageSequenceNumber is the minimum of the first pending message and the first initial message.
 	 *
@@ -357,12 +387,7 @@ export class PendingStateManager implements IDisposable {
 		clientSequenceNumber: number | undefined,
 		staged: boolean,
 	): void {
-		// We have to cast because runtimeOp doesn't apply for empty batches and is missing on LocalEmptyBatchPlaceholder
-		this.onFlushBatch(
-			[placeholder satisfies Omit<LocalBatchMessage, "runtimeOp"> as LocalBatchMessage],
-			clientSequenceNumber,
-			staged,
-		);
+		this.onFlushBatch([placeholder], clientSequenceNumber, staged);
 	}
 
 	/**
@@ -375,7 +400,7 @@ export class PendingStateManager implements IDisposable {
 	 * @param ignoreBatchId - Whether to ignore the batchId in the batchStartInfo
 	 */
 	public onFlushBatch(
-		batch: LocalBatchMessage[],
+		batch: LocalBatchMessage[] | [LocalEmptyBatchPlaceholder],
 		clientSequenceNumber: number | undefined,
 		staged: boolean,
 		ignoreBatchId?: boolean,
@@ -441,7 +466,9 @@ export class PendingStateManager implements IDisposable {
 			// We still need to track it for resubmission.
 			try {
 				if (isEmptyBatchPendingMessage(nextMessage)) {
-					nextMessage.localOpMetadata = { emptyBatch: true }; // equivalent to applyStashedOp for empty batch
+					nextMessage.localOpMetadata = {
+						emptyBatch: true,
+					} satisfies LocalEmptyBatchPlaceholder["localOpMetadata"]; // equivalent to applyStashedOp for empty batch
 					patchbatchInfo(nextMessage); // Back compat
 					this.pendingMessages.push(nextMessage);
 					continue;
@@ -659,7 +686,10 @@ export class PendingStateManager implements IDisposable {
 			pendingMessage !== undefined,
 			0xa21 /* No pending message found as we start processing this remote batch */,
 		);
-		assert(!pendingMessage.batchInfo.staged, 0xb85 /* Can't get an ack from a staged batch */);
+		assert(
+			!pendingMessage.batchInfo.staged,
+			0xb85 /* Pending state mismatch, ack came in but next pending message is staged */,
+		);
 
 		// If this batch became empty on resubmit, batch.messages will be empty (but keyMessage is always set)
 		// and the next pending message should be an empty batch marker.
@@ -764,7 +794,9 @@ export class PendingStateManager implements IDisposable {
 			assert(batchMetadataFlag !== false, 0x41b /* We cannot process batches in chunks */);
 
 			// The next message starts a batch (possibly single-message), and we'll need its batchId.
-			const batchId = getEffectiveBatchId(pendingMessage);
+			const batchId = pendingMessage.batchInfo.ignoreBatchId
+				? undefined
+				: getEffectiveBatchId(pendingMessage);
 
 			const staged = pendingMessage.batchInfo.staged;
 
@@ -775,7 +807,7 @@ export class PendingStateManager implements IDisposable {
 			}
 
 			assert(
-				pendingMessage.runtimeOp !== undefined,
+				pendingMessage.runtimeOp !== undefined && isNotEmptyGroupedBatch(pendingMessage),
 				0xb87 /* viableOp is only undefined for empty batches */,
 			);
 
@@ -811,7 +843,7 @@ export class PendingStateManager implements IDisposable {
 			// check is >= because batch end may be last pending message
 			while (remainingPendingMessagesCount >= 0) {
 				assert(
-					pendingMessage.runtimeOp !== undefined,
+					pendingMessage.runtimeOp !== undefined && isNotEmptyGroupedBatch(pendingMessage),
 					0xb88 /* viableOp is only undefined for empty batches */,
 				);
 				batch.push({
@@ -854,14 +886,20 @@ export class PendingStateManager implements IDisposable {
 	}
 
 	/**
-	 * Pops all staged batches, invoking the callback on each one in order (LIFO)
+	 * Pops all staged batches, invoking the callback on each constituent op in order (LIFO)
 	 */
-	public popStagedBatches(callback: (stagedMessage: IPendingMessage) => void): void {
+	public popStagedBatches(
+		callback: (
+			stagedMessage: IPendingMessage & { runtimeOp?: LocalContainerRuntimeMessage }, // exclude empty grouped batches
+		) => void,
+	): void {
 		while (!this.pendingMessages.isEmpty()) {
 			const stagedMessage = this.pendingMessages.peekBack();
 			if (stagedMessage?.batchInfo.staged === true) {
-				callback(stagedMessage);
-				this.pendingMessages.pop();
+				if (isNotEmptyGroupedBatch(stagedMessage)) {
+					callback(stagedMessage);
+					this.pendingMessages.pop();
+				}
 			} else {
 				break; // no more staged messages
 			}
@@ -885,3 +923,9 @@ function patchbatchInfo(
 		message.batchInfo = { clientId: uuid(), batchStartCsn: -1, length: -1, staged: false };
 	}
 }
+
+function isNotEmptyGroupedBatch(
+	message: IPendingMessage,
+): message is IPendingMessage & { runtimeOp: LocalContainerRuntimeMessage } {
+	return message.runtimeOp !== undefined && message.runtimeOp.type !== "groupedBatch";
+}

package/src/runCounter.ts

@@ -45,7 +45,10 @@ export class BatchRunCounter extends RunCounter {
 	}
 
 	public run<T>(act: () => T, resubmitInfo?: BatchResubmitInfo): T {
-		assert(this.#resubmitInfo === undefined, "Reentrancy not allowed in BatchRunCounter");
+		assert(
+			this.#resubmitInfo === undefined,
+			0xba2 /* Reentrancy not allowed in BatchRunCounter */,
+		);
 		this.#resubmitInfo = resubmitInfo;
 		try {
 			return super.run(act);