@fluidframework/container-runtime 2.12.0 → 2.20.0

package/src/opLifecycle/duplicateBatchDetector.ts

@@ -13,13 +13,19 @@ import { type BatchStartInfo } from "./remoteMessageProcessor.js";
  * This class tracks recent batchIds we've seen, and checks incoming batches for duplicates.
  */
 export class DuplicateBatchDetector {
-	/** All batchIds we've seen recently enough (based on MSN) that we need to watch for duplicates */
+	/**
+	 * All batchIds we've seen recently enough (based on MSN) that we need to watch for duplicates
+	 */
 	private readonly batchIdsAll = new Set<string>();
 
-	/** We map from sequenceNumber to batchId to find which ones we can stop tracking as MSN advances */
+	/**
+	 * We map from sequenceNumber to batchId to find which ones we can stop tracking as MSN advances
+	 */
 	private readonly batchIdsBySeqNum = new Map<number, string>();
 
-	/** Initialize from snapshot data if provided - otherwise initialize empty */
+	/**
+	 * Initialize from snapshot data if provided - otherwise initialize empty
+	 */
 	constructor(batchIdsFromSnapshot: [number, string][] | undefined) {
 		if (batchIdsFromSnapshot) {
 			this.batchIdsBySeqNum = new Map(batchIdsFromSnapshot);
@@ -78,7 +84,7 @@ export class DuplicateBatchDetector {
 	 * Batches that started before the MSN are not at risk for a sequenced duplicate to arrive,
 	 * since the batch start has been processed by all clients, and local batches are deduped and the forked client would close.
 	 */
-	private clearOldBatchIds(msn: number) {
+	private clearOldBatchIds(msn: number): void {
 		this.batchIdsBySeqNum.forEach((batchId, sequenceNumber) => {
 			if (sequenceNumber < msn) {
 				this.batchIdsBySeqNum.delete(sequenceNumber);

package/src/opLifecycle/opCompressor.ts

@@ -6,7 +6,11 @@
 import { IsoBuffer } from "@fluid-internal/client-utils";
 import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
-import { UsageError, createChildLogger } from "@fluidframework/telemetry-utils/internal";
+import {
+	UsageError,
+	createChildLogger,
+	type ITelemetryLoggerExt,
+} from "@fluidframework/telemetry-utils/internal";
 import { compress } from "lz4js";
 
 import { CompressionAlgorithms } from "../containerRuntime.js";
@@ -20,7 +24,7 @@ import { BatchMessage, IBatch } from "./definitions.js";
  * op to reserve sequence numbers.
  */
 export class OpCompressor {
-	private readonly logger;
+	private readonly logger: ITelemetryLoggerExt;
 
 	constructor(logger: ITelemetryBaseLogger) {
 		this.logger = createChildLogger({ logger, namespace: "OpCompressor" });
@@ -89,8 +93,8 @@ export class OpCompressor {
 		try {
 			// Yields a valid JSON array, since each message.contents is already serialized to JSON
 			return `[${batch.messages.map(({ contents }) => contents).join(",")}]`;
-		} catch (e: any) {
-			if (e.message === "Invalid string length") {
+		} catch (e: unknown) {
+			if ((e as Partial<Error>).message === "Invalid string length") {
 				// This is how JSON.stringify signals that
 				// the content size exceeds its capacity
 				const error = new UsageError("Payload too large");

package/src/opLifecycle/opDecompressor.ts

@@ -7,7 +7,10 @@ import { IsoBuffer, Uint8ArrayToString } from "@fluid-internal/client-utils";
 import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
 import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
-import { createChildLogger } from "@fluidframework/telemetry-utils/internal";
+import {
+	createChildLogger,
+	type ITelemetryLoggerExt,
+} from "@fluidframework/telemetry-utils/internal";
 import { decompress } from "lz4js";
 
 import { CompressionAlgorithms } from "../containerRuntime.js";
@@ -30,9 +33,11 @@ interface IPackedContentsContents {
  */
 export class OpDecompressor {
 	private activeBatch = false;
+	// TODO: better typing
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	private rootMessageContents: any | undefined;
 	private processedCount = 0;
-	private readonly logger;
+	private readonly logger: ITelemetryLoggerExt;
 
 	constructor(logger: ITelemetryBaseLogger) {
 		this.logger = createChildLogger({ logger, namespace: "OpDecompressor" });
@@ -81,11 +86,13 @@ export class OpDecompressor {
 		return false;
 	}
 
-	public get currentlyUnrolling() {
+	public get currentlyUnrolling(): boolean {
 		return this.activeBatch;
 	}
 
-	/** Is the decompressed and stored batch only comprised of a single message */
+	/**
+	 * Is the decompressed and stored batch only comprised of a single message
+	 */
 	private isSingleMessageBatch = false;
 
 	/**
@@ -118,8 +125,8 @@ export class OpDecompressor {
 		);
 		const decompressedMessage = decompress(contents);
 		const intoString = Uint8ArrayToString(decompressedMessage);
-		const asObj = JSON.parse(intoString);
-		this.rootMessageContents = asObj;
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+		this.rootMessageContents = JSON.parse(intoString);
 	}
 
 	/**
@@ -130,6 +137,7 @@ export class OpDecompressor {
 		assert(this.currentlyUnrolling, 0x942 /* not currently unrolling */);
 		assert(this.rootMessageContents !== undefined, 0x943 /* missing rootMessageContents */);
 		assert(
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 			this.rootMessageContents.length > this.processedCount,
 			0x944 /* no more content to unroll */,
 		);
@@ -138,6 +146,7 @@ export class OpDecompressor {
 
 		if (batchMetadata === false || this.isSingleMessageBatch) {
 			// End of compressed batch
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 			const returnMessage = newMessage(message, this.rootMessageContents[this.processedCount]);
 
 			this.activeBatch = false;
@@ -148,6 +157,7 @@ export class OpDecompressor {
 			return returnMessage;
 		} else if (batchMetadata === true) {
 			// Start of compressed batch
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 			return newMessage(message, this.rootMessageContents[this.processedCount++]);
 		}
 
@@ -155,6 +165,7 @@ export class OpDecompressor {
 		assert(message.contents === undefined, 0x512 /* Expecting empty message */);
 
 		// Continuation of compressed batch
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 		return newMessage(message, this.rootMessageContents[this.processedCount++]);
 	}
 }
@@ -162,15 +173,13 @@ export class OpDecompressor {
 // We should not be mutating the input message nor its metadata
 const newMessage = (
 	originalMessage: ISequencedDocumentMessage,
-	contents: any,
+	contents: unknown,
 ): ISequencedDocumentMessage => ({
 	...originalMessage,
 	contents,
 	compression: undefined,
 	// TODO: It should already be the case that we're not modifying any metadata, not clear if/why this shallow clone should be required.
-	// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+
 	metadata:
-		originalMessage.metadata === undefined
-			? undefined
-			: { ...(originalMessage.metadata as any) },
+		originalMessage.metadata === undefined ? undefined : { ...originalMessage.metadata },
 });

package/src/opLifecycle/opGroupingManager.ts

@@ -6,7 +6,10 @@
 import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
 import { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
-import { createChildLogger } from "@fluidframework/telemetry-utils/internal";
+import {
+	createChildLogger,
+	type ITelemetryLoggerExt,
+} from "@fluidframework/telemetry-utils/internal";
 
 import { IBatch, type BatchMessage } from "./definitions.js";
 
@@ -24,8 +27,11 @@ interface IGroupedMessage {
 	compression?: string;
 }
 
-function isGroupContents(opContents: any): opContents is IGroupedBatchMessageContents {
-	return opContents?.type === OpGroupingManager.groupedBatchOp;
+function isGroupContents(opContents: unknown): opContents is IGroupedBatchMessageContents {
+	return (
+		(opContents as Partial<IGroupedBatchMessageContents>)?.type ===
+		OpGroupingManager.groupedBatchOp
+	);
 }
 
 export function isGroupedBatch(op: ISequencedDocumentMessage): boolean {
@@ -35,12 +41,11 @@ export function isGroupedBatch(op: ISequencedDocumentMessage): boolean {
 export interface OpGroupingManagerConfig {
 	readonly groupedBatchingEnabled: boolean;
 	readonly opCountThreshold: number;
-	readonly reentrantBatchGroupingEnabled: boolean;
 }
 
 export class OpGroupingManager {
 	static readonly groupedBatchOp = "groupedBatch";
-	private readonly logger;
+	private readonly logger: ITelemetryLoggerExt;
 
 	constructor(
 		private readonly config: OpGroupingManagerConfig,
@@ -156,9 +161,8 @@ export class OpGroupingManager {
 			this.config.groupedBatchingEnabled &&
 			// The number of ops in the batch must surpass the configured threshold
 			// or be empty (to allow for empty batches to be grouped)
-			(batch.messages.length === 0 || batch.messages.length >= this.config.opCountThreshold) &&
-			// Support for reentrant batches must be explicitly enabled
-			(this.config.reentrantBatchGroupingEnabled || batch.hasReentrantOps !== true)
+			(batch.messages.length === 0 || batch.messages.length >= this.config.opCountThreshold)
+			// Support for reentrant batches will be on by default
 		);
 	}
 }

package/src/opLifecycle/opSplitter.ts

@@ -11,6 +11,7 @@ import {
 	DataCorruptionError,
 	createChildLogger,
 	extractSafePropertiesFromMessage,
+	type ITelemetryLoggerExt,
 } from "@fluidframework/telemetry-utils/internal";
 
 import { ContainerMessageType, ContainerRuntimeChunkedOpMessage } from "../messageTypes.js";
@@ -23,12 +24,12 @@ export function isChunkedMessage(message: ISequencedDocumentMessage): boolean {
 }
 
 interface IChunkedContents {
-	type: typeof ContainerMessageType.ChunkedOp;
-	contents: IChunkedOp;
+	readonly type: typeof ContainerMessageType.ChunkedOp;
+	readonly contents: IChunkedOp;
 }
 
-function isChunkedContents(contents: any): contents is IChunkedContents {
-	return contents?.type === ContainerMessageType.ChunkedOp;
+function isChunkedContents(contents: unknown): contents is IChunkedContents {
+	return (contents as Partial<IChunkedContents>)?.type === ContainerMessageType.ChunkedOp;
 }
 
 /**
@@ -37,7 +38,7 @@ function isChunkedContents(contents: any): contents is IChunkedContents {
 export class OpSplitter {
 	// Local copy of incomplete received chunks.
 	private readonly chunkMap: Map<string, string[]>;
-	private readonly logger;
+	private readonly logger: ITelemetryLoggerExt;
 
 	constructor(
 		chunks: [string, string[]][],
@@ -62,7 +63,7 @@ export class OpSplitter {
 		return this.chunkMap;
 	}
 
-	public clearPartialChunks(clientId: string) {
+	public clearPartialChunks(clientId: string): void {
 		if (this.chunkMap.has(clientId)) {
 			this.chunkMap.delete(clientId);
 		}
@@ -72,7 +73,7 @@ export class OpSplitter {
 		clientId: string,
 		chunkedContent: IChunkedOp,
 		originalMessage: ISequencedDocumentMessage,
-	) {
+	): void {
 		let map = this.chunkMap.get(clientId);
 		if (map === undefined) {
 			map = [];
@@ -190,7 +191,7 @@ export class OpSplitter {
 		const contents: IChunkedContents = message.contents;
 
 		// TODO: Verify whether this should be able to handle server-generated ops (with null clientId)
-		// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+
 		const clientId = message.clientId as string;
 		const chunkedContent = contents.contents;
 		this.addChunk(clientId, chunkedContent, message);
@@ -215,6 +216,7 @@ export class OpSplitter {
 		// back-compat with 1.x builds
 		// This is only required / present for non-compressed, chunked ops
 		// For compressed ops, we have op grouping enabled, and type of each op is preserved within compressed content.
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment
 		completeMessage.type = (chunkedContent as any).originalType;
 		completeMessage.metadata = chunkedContent.originalMetadata;
 		completeMessage.compression = chunkedContent.originalCompression;
@@ -298,6 +300,7 @@ export const splitOp = (
 			// This is really bad, as we will crash on later ops and it's very hard to debug these cases.
 			// If we put some known type here, then we will crash on it (as 1.x does not understand compression, and thus will not
 			// find info on the op like address of the channel to deliver the op)
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
 			(chunk as any).originalType = "component";
 		}
 

package/src/opLifecycle/outbox.ts

@@ -77,6 +77,8 @@ export function serializeOpContents(contents: OutboundContainerRuntimeMessage):
  * @returns the result of the action provided
  */
 export function getLongStack<T>(action: () => T, length: number = 50): T {
+	// TODO: better typing here
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
 	const errorObj = Error as any;
 	if (
 		/* eslint-disable @typescript-eslint/prefer-nullish-coalescing */
@@ -90,11 +92,14 @@ export function getLongStack<T>(action: () => T, length: number = 50): T {
 		return action();
 	}
 
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment
 	const originalStackTraceLimit = errorObj.stackTraceLimit;
 	try {
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 		errorObj.stackTraceLimit = length;
 		return action();
 	} finally {
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment
 		errorObj.stackTraceLimit = originalStackTraceLimit;
 	}
 }
@@ -171,7 +176,7 @@ export class Outbox {
 	 * last message processed by the ContainerRuntime. In the absence of op reentrancy, this
 	 * pair will remain stable during a single JS turn during which the batch is being built up.
 	 */
-	private maybeFlushPartialBatch() {
+	private maybeFlushPartialBatch(): void {
 		const mainBatchSeqNums = this.mainBatch.sequenceNumbers;
 		const blobAttachSeqNums = this.blobAttachBatch.sequenceNumbers;
 		const idAllocSeqNums = this.idAllocationBatch.sequenceNumbers;
@@ -214,13 +219,13 @@ export class Outbox {
 		}
 	}
 
-	public submit(message: BatchMessage) {
+	public submit(message: BatchMessage): void {
 		this.maybeFlushPartialBatch();
 
 		this.addMessageToBatchManager(this.mainBatch, message);
 	}
 
-	public submitBlobAttach(message: BatchMessage) {
+	public submitBlobAttach(message: BatchMessage): void {
 		this.maybeFlushPartialBatch();
 
 		this.addMessageToBatchManager(this.blobAttachBatch, message);
@@ -238,13 +243,13 @@ export class Outbox {
 		}
 	}
 
-	public submitIdAllocation(message: BatchMessage) {
+	public submitIdAllocation(message: BatchMessage): void {
 		this.maybeFlushPartialBatch();
 
 		this.addMessageToBatchManager(this.idAllocationBatch, message);
 	}
 
-	private addMessageToBatchManager(batchManager: BatchManager, message: BatchMessage) {
+	private addMessageToBatchManager(batchManager: BatchManager, message: BatchMessage): void {
 		if (
 			!batchManager.push(
 				message,
@@ -267,7 +272,7 @@ export class Outbox {
 	 * @param resubmittingBatchId - If defined, indicates this is a resubmission of a batch
 	 * with the given Batch ID, which must be preserved
 	 */
-	public flush(resubmittingBatchId?: BatchId) {
+	public flush(resubmittingBatchId?: BatchId): void {
 		if (this.isContextReentrant()) {
 			const error = new UsageError("Flushing is not supported inside DDS event handlers");
 			this.params.closeContainer(error);
@@ -277,7 +282,7 @@ export class Outbox {
 		this.flushAll(resubmittingBatchId);
 	}
 
-	private flushAll(resubmittingBatchId?: BatchId) {
+	private flushAll(resubmittingBatchId?: BatchId): void {
 		// If we're resubmitting and all batches are empty, we need to flush an empty batch.
 		// Note that we currently resubmit one batch at a time, so on resubmit, 2 of the 3 batches will *always* be empty.
 		// It's theoretically possible that we don't *need* to resubmit this empty batch, and in those cases, it'll safely be ignored
@@ -304,7 +309,7 @@ export class Outbox {
 		);
 	}
 
-	private flushEmptyBatch(resubmittingBatchId: BatchId) {
+	private flushEmptyBatch(resubmittingBatchId: BatchId): void {
 		const referenceSequenceNumber =
 			this.params.getCurrentSequenceNumbers().referenceSequenceNumber;
 		assert(
@@ -330,7 +335,7 @@ export class Outbox {
 		batchManager: BatchManager,
 		disableGroupedBatching: boolean = false,
 		resubmittingBatchId?: BatchId,
-	) {
+	): void {
 		if (batchManager.empty) {
 			return;
 		}
@@ -375,7 +380,7 @@ export class Outbox {
 	 *
 	 * @param rawBatch - the batch to be rebased
 	 */
-	private rebase(rawBatch: IBatch, batchManager: BatchManager) {
+	private rebase(rawBatch: IBatch, batchManager: BatchManager): void {
 		assert(!this.rebasing, 0x6fb /* Reentrancy */);
 		assert(batchManager.options.canRebase, 0x9a7 /* BatchManager does not support rebase */);
 
@@ -459,7 +464,7 @@ export class Outbox {
 	 * @param batch - batch to be sent
 	 * @returns the clientSequenceNumber of the start of the batch, or undefined if nothing was sent
 	 */
-	private sendBatch(batch: IBatch) {
+	private sendBatch(batch: IBatch): number | undefined {
 		const length = batch.messages.length;
 		if (length === 0) {
 			return undefined; // Nothing submitted
@@ -505,9 +510,13 @@ export class Outbox {
 	}
 
 	/**
-	 * @returns A checkpoint object per batch that facilitates iterating over the batch messages when rolling back.
+	 * Gets a checkpoint object per batch that facilitates iterating over the batch messages when rolling back.
 	 */
-	public getBatchCheckpoints() {
+	public getBatchCheckpoints(): {
+		mainBatch: IBatchCheckpoint;
+		idAllocationBatch: IBatchCheckpoint;
+		blobAttachBatch: IBatchCheckpoint;
+	} {
 		// 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();

package/src/opLifecycle/remoteMessageProcessor.ts

@@ -22,11 +22,17 @@ import { OpSplitter, isChunkedMessage } from "./opSplitter.js";
 // eslint-disable-next-line unused-imports/no-unused-imports -- Used by "@link" comment annotation below
 import { serializeOpContents } from "./outbox.js";
 
-/** Info about the batch we learn when we process the first message */
+/**
+ * Info about the batch we learn when we process the first message
+ */
 export interface BatchStartInfo {
-	/** Batch ID, if present */
+	/**
+	 * Batch ID, if present
+	 */
 	readonly batchId: string | undefined;
-	/** clientId that sent this batch. Used to compute Batch ID if needed */
+	/**
+	 * clientId that sent this batch. Used to compute Batch ID if needed
+	 */
 	readonly clientId: string;
 	/**
 	 * Client Sequence Number of the Grouped Batch message, or the first message in the ungrouped batch.
@@ -101,7 +107,7 @@ export class RemoteMessageProcessor {
 		return this.opSplitter.chunks;
 	}
 
-	public clearPartialMessagesFor(clientId: string) {
+	public clearPartialMessagesFor(clientId: string): void {
 		this.opSplitter.clearPartialChunks(clientId);
 	}
 

package/src/packageVersion.ts

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

package/src/pendingStateManager.ts

@@ -56,16 +56,22 @@ export interface IPendingMessage {
 		 * Or, -1 if it was never submitted (and clientId will be a random uuid)
 		 */
 		batchStartCsn: number;
-		/** length of the batch (how many runtime messages here) */
+		/**
+		 * length of the batch (how many runtime messages here)
+		 */
 		length: number;
-		/** If true, don't compare batchID of incoming batches to this. e.g. ID Allocation Batch IDs should be ignored */
+		/**
+		 * If true, don't compare batchID of incoming batches to this. e.g. ID Allocation Batch IDs should be ignored
+		 */
 		ignoreBatchId?: boolean;
 	};
 }
 
 type Patch<T, U> = U & Omit<T, keyof U>;
 
-/** First version of the type (pre-dates batchInfo) */
+/**
+ * First version of the type (pre-dates batchInfo)
+ */
 type IPendingMessageV0 = Patch<IPendingMessage, { batchInfo?: undefined }>;
 
 /**
@@ -82,7 +88,9 @@ export interface IPendingLocalState {
 	pendingStates: IPendingMessage[];
 }
 
-/** Info needed to replay/resubmit a pending message */
+/**
+ * Info needed to replay/resubmit a pending message
+ */
 export type PendingMessageResubmitData = Pick<
 	IPendingMessage,
 	"content" | "localOpMetadata" | "opMetadata"
@@ -98,7 +106,9 @@ 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
 	return content.type === "groupedBatch" && content.contents?.length === 0;
 }
 
@@ -131,6 +141,28 @@ function scrubAndStringify(
 	return JSON.stringify(scrubbed);
 }
 
+/**
+ * Finds and returns the index where the strings diverge, and the character at that index in each string (or undefined if not applicable)
+ */
+export function findFirstCharacterMismatched(
+	a: string,
+	b: string,
+): [index: number, charA?: string, charB?: string] {
+	const minLength = Math.min(a.length, b.length);
+	for (let i = 0; i < minLength; i++) {
+		if (a[i] !== b[i]) {
+			return [i, a[i], b[i]];
+		}
+	}
+
+	// Since we didn't return in the loop, the shorter string must be a prefix of the other.
+	// If they're the same length, return -1 to indicate they're identical.
+	// Otherwise, the next character of the longer one is where they differ. No need to return that next character.
+	return a.length === b.length
+		? [-1, undefined, undefined]
+		: [minLength, a[minLength], b[minLength]];
+}
+
 function withoutLocalOpMetadata(message: IPendingMessage): IPendingMessage {
 	return {
 		...message,
@@ -148,9 +180,13 @@ function withoutLocalOpMetadata(message: IPendingMessage): IPendingMessage {
  * It verifies that all the ops are acked, are received in the right order and batch information is correct.
  */
 export class PendingStateManager implements IDisposable {
-	/** Messages that will need to be resubmitted if not ack'd before the next reconnection */
+	/**
+	 * Messages that will need to be resubmitted if not ack'd before the next reconnection
+	 */
 	private readonly pendingMessages = new Deque<IPendingMessage>();
-	/** Messages stashed from a previous container, now being rehydrated. Need to be resubmitted. */
+	/**
+	 * Messages stashed from a previous container, now being rehydrated. Need to be resubmitted.
+	 */
 	private readonly initialMessages = new Deque<IPendingMessageFromStash>();
 
 	/**
@@ -163,7 +199,9 @@ export class PendingStateManager implements IDisposable {
 		this.pendingMessages.clear();
 	});
 
-	/** Used to ensure we don't replay ops on the same connection twice */
+	/**
+	 * Used to ensure we don't replay ops on the same connection twice
+	 */
 	private clientIdFromLastReplay: string | undefined;
 
 	/**
@@ -232,10 +270,10 @@ export class PendingStateManager implements IDisposable {
 		}
 	}
 
-	public get disposed() {
+	public get disposed(): boolean {
 		return this.disposeOnce.evaluated;
 	}
-	public readonly dispose = () => this.disposeOnce.value;
+	public readonly dispose = (): void => this.disposeOnce.value;
 
 	/**
 	 * The given batch has been flushed, and needs to be tracked locally until the corresponding
@@ -249,7 +287,7 @@ export class PendingStateManager implements IDisposable {
 		batch: BatchMessage[],
 		clientSequenceNumber: number | undefined,
 		ignoreBatchId?: boolean,
-	) {
+	): void {
 		// clientId and batchStartCsn are used for generating the batchId so we can detect container forks
 		// where this batch was submitted by two different clients rehydrating from the same local state.
 		// In the typical case where the batch was actually sent, use the clientId and clientSequenceNumber.
@@ -288,7 +326,7 @@ export class PendingStateManager implements IDisposable {
 	 * Applies stashed ops at their reference sequence number so they are ready to be ACKed or resubmitted
 	 * @param seqNum - Sequence number at which to apply ops. Will apply all ops if seqNum is undefined.
 	 */
-	public async applyStashedOpsAt(seqNum?: number) {
+	public async applyStashedOpsAt(seqNum?: number): Promise<void> {
 		// apply stashed ops at sequence number
 		while (!this.initialMessages.isEmpty()) {
 			if (seqNum !== undefined) {
@@ -459,7 +497,17 @@ export class PendingStateManager implements IDisposable {
 			const messageContent = buildPendingMessageContent(message);
 
 			// Stringified content should match
+			// If it doesn't, collect as much info about the difference as possible (privacy-wise) and log it
 			if (pendingMessage.content !== messageContent) {
+				const [pendingLength, incomingLength] = [
+					pendingMessage.content.length,
+					messageContent.length,
+				];
+				const [mismatchStartIndex, pendingChar, incomingChar] = findFirstCharacterMismatched(
+					pendingMessage.content,
+					messageContent,
+				);
+
 				const pendingContentObj = JSON.parse(
 					pendingMessage.content,
 				) as LocalContainerRuntimeMessage;
@@ -467,6 +515,7 @@ export class PendingStateManager implements IDisposable {
 					messageContent,
 				) as InboundContainerRuntimeMessage;
 
+				// Compare inner contents object, since that both should be { type, contents }
 				const contentsMatch =
 					pendingContentObj.contents === incomingContentObj.contents ||
 					(pendingContentObj.contents !== undefined &&
@@ -480,6 +529,11 @@ export class PendingStateManager implements IDisposable {
 						pendingContentScrubbed: scrubAndStringify(pendingContentObj),
 						incomingContentScrubbed: scrubAndStringify(incomingContentObj),
 						contentsMatch,
+						pendingLength,
+						incomingLength,
+						mismatchStartIndex,
+						pendingChar,
+						incomingChar,
 					},
 				});
 
@@ -497,7 +551,7 @@ export class PendingStateManager implements IDisposable {
 	/**
 	 * Check if the incoming batch matches the batch info for the next pending message.
 	 */
-	private onLocalBatchBegin(batchStart: BatchStartInfo, batchLength?: number) {
+	private onLocalBatchBegin(batchStart: BatchStartInfo, batchLength?: number): void {
 		// Get the next message from the pending queue. Verify a message exists.
 		const pendingMessage = this.pendingMessages.peekFront();
 		assert(
@@ -556,7 +610,7 @@ export class PendingStateManager implements IDisposable {
 	 * states in its queue. This includes triggering resubmission of unacked ops.
 	 * ! Note: successfully resubmitting an op that has been successfully sequenced is not possible due to checks in the ConnectionStateHandler (Loader layer)
 	 */
-	public replayPendingStates() {
+	public replayPendingStates(): void {
 		assert(
 			this.stateHandler.connected(),
 			0x172 /* "The connection state is not consistent with the runtime" */,
@@ -600,7 +654,7 @@ export class PendingStateManager implements IDisposable {
 			/**
 			 * We must preserve the distinct batches on resubmit.
 			 * Note: It is not possible for the PendingStateManager to receive a partially acked batch. It will
-			 * either receive the whole batch ack or nothing at all.  @see ScheduleManager for how this works.
+			 * either receive the whole batch ack or nothing at all. See {@link InboundBatchAggregator} for how this works.
 			 */
 			if (batchMetadataFlag === undefined) {
 				// Single-message batch
@@ -667,7 +721,9 @@ export class PendingStateManager implements IDisposable {
 	}
 }
 
-/** For back-compat if trying to apply stashed ops that pre-date batchInfo */
+/**
+ * For back-compat if trying to apply stashed ops that pre-date batchInfo
+ */
 function patchbatchInfo(
 	message: IPendingMessageFromStash,
 ): asserts message is IPendingMessage {