@fluidframework/map 2.0.0-dev-rc.1.0.0.228517 → 2.0.0-dev-rc.2.0.0.245554

package/src/directory.ts

@@ -3,9 +3,9 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils";
+import { assert, unreachableCase } from "@fluidframework/core-utils";
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
-import { UsageError } from "@fluidframework/telemetry-utils";
+import { ITelemetryLoggerExt, UsageError } from "@fluidframework/telemetry-utils";
 import { readAndParse } from "@fluidframework/driver-utils";
 import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
 import {
@@ -16,7 +16,12 @@ import {
 	IChannelFactory,
 } from "@fluidframework/datastore-definitions";
 import { ISummaryTreeWithStats, ITelemetryContext } from "@fluidframework/runtime-definitions";
-import { IFluidSerializer, SharedObject, ValueType } from "@fluidframework/shared-object-base";
+import {
+	IFluidSerializer,
+	SharedObject,
+	ValueType,
+	parseHandles,
+} from "@fluidframework/shared-object-base";
 import { SummaryTreeBuilder } from "@fluidframework/runtime-utils";
 import path from "path-browserify";
 import { RedBlackTree } from "@fluidframework/merge-tree";
@@ -30,9 +35,9 @@ import {
 	ISharedDirectory,
 	ISharedDirectoryEvents,
 	IValueChanged,
-} from "./interfaces";
-import { ILocalValue, LocalValueMaker, makeSerializable } from "./localValues";
-import { pkgVersion } from "./packageVersion";
+} from "./interfaces.js";
+import { ILocalValue, LocalValueMaker, makeSerializable } from "./localValues.js";
+import { pkgVersion } from "./packageVersion.js";
 
 // We use path-browserify since this code can run safely on the server or the browser.
 // We standardize on using posix slashes everywhere.
@@ -65,8 +70,6 @@ interface IDirectoryMessageHandler {
 	 * @param localOpMetadata - The metadata to be submitted with the message.
 	 */
 	submit(op: IDirectoryOperation, localOpMetadata: unknown): void;
-
-	applyStashedOp(op: IDirectoryOperation): unknown;
 }
 
 /**
@@ -271,7 +274,7 @@ export interface IDirectoryNewStorageFormat {
  * @sealed
  * @alpha
  */
-export class DirectoryFactory implements IChannelFactory {
+export class DirectoryFactory implements IChannelFactory<ISharedDirectory> {
 	/**
 	 * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory."type"}
 	 */
@@ -346,25 +349,25 @@ export class DirectoryFactory implements IChannelFactory {
  * 4. A 'seq' value of zero indicates that the subdirectory was created in detached state, and it is considered acknowledged for the
  * purpose of ordering.
  */
-const seqDataComparator = (a: SequenceData, b: SequenceData) => {
+const seqDataComparator = (a: SequenceData, b: SequenceData): number => {
 	if (isAcknowledgedOrDetached(a)) {
 		if (isAcknowledgedOrDetached(b)) {
 			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			return a.seq !== b.seq ? a.seq - b.seq : a.clientSeq! - b.clientSeq!;
+			return a.seq === b.seq ? a.clientSeq! - b.clientSeq! : a.seq - b.seq;
 		} else {
 			return -1;
 		}
 	} else {
-		if (!isAcknowledgedOrDetached(b)) {
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			return a.seq !== b.seq ? a.seq - b.seq : a.clientSeq! - b.clientSeq!;
-		} else {
+		if (isAcknowledgedOrDetached(b)) {
 			return 1;
+		} else {
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			return a.seq === b.seq ? a.clientSeq! - b.clientSeq! : a.seq - b.seq;
 		}
 	}
 };
 
-function isAcknowledgedOrDetached(seqData: SequenceData) {
+function isAcknowledgedOrDetached(seqData: SequenceData): boolean {
 	return seqData.seq >= 0;
 }
 
@@ -433,6 +436,10 @@ class DirectoryCreationTracker {
 		}, keys);
 		return keys;
 	}
+
+	public get size(): number {
+		return this.keyToIndex.size;
+	}
 }
 
 /**
@@ -460,8 +467,8 @@ export class SharedDirectory
 	 * @param id - Optional name of the shared directory
 	 * @returns Newly create shared directory (but not attached yet)
 	 */
-	public static create(runtime: IFluidDataStoreRuntime, id?: string): SharedDirectory {
-		return runtime.createChannel(id, DirectoryFactory.Type) as SharedDirectory;
+	public static create(runtime: IFluidDataStoreRuntime, id?: string): ISharedDirectory {
+		return runtime.createChannel(id, DirectoryFactory.Type) as ISharedDirectory;
 	}
 
 	/**
@@ -469,7 +476,7 @@ export class SharedDirectory
 	 *
 	 * @returns A factory that creates and load SharedDirectory
 	 */
-	public static getFactory(): IChannelFactory {
+	public static getFactory(): IChannelFactory<ISharedDirectory> {
 		return new DirectoryFactory();
 	}
 
@@ -498,6 +505,7 @@ export class SharedDirectory
 		this.runtime,
 		this.serializer,
 		posix.sep,
+		this.logger,
 	);
 
 	/**
@@ -518,7 +526,7 @@ export class SharedDirectory
 		attributes: IChannelAttributes,
 	) {
 		super(id, runtime, attributes, "fluid_directory_");
-		this.localValueMaker = new LocalValueMaker(this.serializer);
+		this.localValueMaker = new LocalValueMaker();
 		this.setMessageHandlers();
 		// Mirror the containedValueChanged op on the SharedDirectory
 		this.root.on("containedValueChanged", (changed: IValueChanged, local: boolean) => {
@@ -781,10 +789,7 @@ export class SharedDirectory
 						// guaranteed during the serialization process. As a result, it is only essential to utilize the
 						// "fake" client sequence number to signify the loading order, and there is no need to retain
 						// the actual client sequence number at this point.
-						if (createInfo !== undefined && createInfo.csn > -1) {
-							// If csn is -1, then initialize it with 0, otherwise we will never process ops for this
-							// sub directory. This could be done at serialization time too, but we need to maintain
-							// back compat too and also we will actually know the state when it was serialized.
+						if (createInfo !== undefined && createInfo.csn > 0) {
 							if (!tempSeqNums.has(createInfo.csn)) {
 								tempSeqNums.set(createInfo.csn, 0);
 							}
@@ -792,6 +797,13 @@ export class SharedDirectory
 							seqData = { seq: createInfo.csn, clientSeq: fakeClientSeq };
 							tempSeqNums.set(createInfo.csn, ++fakeClientSeq);
 						} else {
+							/**
+							 * 1. If csn is -1, then initialize it with 0, otherwise we will never process ops for this
+							 * sub directory. This could be done at serialization time too, but we need to maintain
+							 * back compat too and also we will actually know the state when it was serialized.
+							 * 2. We need to make the csn = -1 and csn = 0 share the same counter, there are cases
+							 * where both -1 and 0 coexist within a single document.
+							 */
 							seqData = {
 								seq: 0,
 								clientSeq: ++currentSubDir.localCreationSeq,
@@ -799,13 +811,14 @@ export class SharedDirectory
 						}
 						newSubDir = new SubDirectory(
 							seqData,
-							createInfo !== undefined
-								? new Set<string>(createInfo.ccIds)
-								: new Set(),
+							createInfo === undefined
+								? new Set()
+								: new Set<string>(createInfo.ccIds),
 							this,
 							this.runtime,
 							this.serializer,
 							posix.join(currentSubDir.absolutePath, subdirName),
+							this.logger,
 						);
 						currentSubDir.populateSubDirectory(subdirName, newSubDir);
 						// Record the newly inserted subdirectory to the creation tracker
@@ -822,7 +835,8 @@ export class SharedDirectory
 					const localValue = this.makeLocal(
 						key,
 						currentSubDir.absolutePath,
-						serializable,
+						// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+						parseHandles(serializable, this.serializer),
 					);
 					currentSubDir.populateStorage(key, localValue);
 				}
@@ -886,7 +900,7 @@ export class SharedDirectory
 				serializable.type === ValueType[ValueType.Shared],
 			0x1e4 /* "Unexpected serializable type" */,
 		);
-		return this.localValueMaker.fromSerializable(serializable);
+		return this.localValueMaker.fromSerializable(serializable, this.serializer, this.handle);
 	}
 
 	/**
@@ -940,12 +954,6 @@ export class SharedDirectory
 					subdir.resubmitClearMessage(op, localOpMetadata);
 				}
 			},
-			applyStashedOp: (op: IDirectoryClearOperation): IClearLocalOpMetadata | undefined => {
-				const subdir = this.getWorkingDirectory(op.path) as SubDirectory | undefined;
-				if (subdir) {
-					return subdir.applyStashedClearMessage(op);
-				}
-			},
 		});
 		this.messageHandlers.set("delete", {
 			process: (
@@ -967,14 +975,6 @@ export class SharedDirectory
 					subdir.resubmitKeyMessage(op, localOpMetadata);
 				}
 			},
-			applyStashedOp: (
-				op: IDirectoryDeleteOperation,
-			): IKeyEditLocalOpMetadata | undefined => {
-				const subdir = this.getWorkingDirectory(op.path) as SubDirectory | undefined;
-				if (subdir) {
-					return subdir.applyStashedDeleteMessage(op);
-				}
-			},
 		});
 		this.messageHandlers.set("set", {
 			process: (
@@ -997,13 +997,6 @@ export class SharedDirectory
 					subdir.resubmitKeyMessage(op, localOpMetadata);
 				}
 			},
-			applyStashedOp: (op: IDirectorySetOperation): IKeyEditLocalOpMetadata | undefined => {
-				const subdir = this.getWorkingDirectory(op.path) as SubDirectory | undefined;
-				if (subdir) {
-					const context = this.makeLocal(op.key, op.path, op.value);
-					return subdir.applyStashedSetMessage(op, context);
-				}
-			},
 		});
 
 		this.messageHandlers.set("createSubDirectory", {
@@ -1027,14 +1020,6 @@ export class SharedDirectory
 					parentSubdir.resubmitSubDirectoryMessage(op, localOpMetadata);
 				}
 			},
-			applyStashedOp: (
-				op: IDirectoryCreateSubDirectoryOperation,
-			): ICreateSubDirLocalOpMetadata | undefined => {
-				const parentSubdir = this.getWorkingDirectory(op.path) as SubDirectory | undefined;
-				if (parentSubdir) {
-					return parentSubdir.applyStashedCreateSubDirMessage(op);
-				}
-			},
 		});
 
 		this.messageHandlers.set("deleteSubDirectory", {
@@ -1058,26 +1043,47 @@ export class SharedDirectory
 					parentSubdir.resubmitSubDirectoryMessage(op, localOpMetadata);
 				}
 			},
-			applyStashedOp: (
-				op: IDirectoryDeleteSubDirectoryOperation,
-			): IDeleteSubDirLocalOpMetadata | undefined => {
-				const parentSubdir = this.getWorkingDirectory(op.path) as SubDirectory | undefined;
-				if (parentSubdir) {
-					return parentSubdir.applyStashedDeleteSubDirMessage(op);
-				}
-			},
 		});
 	}
 
 	/**
 	 * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
 	 */
-	protected applyStashedOp(op: unknown): unknown {
-		const handler = this.messageHandlers.get((op as IDirectoryOperation).type);
-		if (handler === undefined) {
-			throw new Error("no apply stashed op handler");
+	protected applyStashedOp(op: unknown): void {
+		const directoryOp = op as IDirectoryOperation;
+		const dir = this.getWorkingDirectory(directoryOp.path);
+		switch (directoryOp.type) {
+			case "clear": {
+				dir?.clear();
+				break;
+			}
+			case "createSubDirectory": {
+				dir?.createSubDirectory(directoryOp.subdirName);
+				break;
+			}
+			case "delete": {
+				dir?.delete(directoryOp.key);
+				break;
+			}
+			case "deleteSubDirectory": {
+				dir?.deleteSubDirectory(directoryOp.subdirName);
+				break;
+			}
+			case "set": {
+				dir?.set(
+					directoryOp.key,
+					this.localValueMaker.fromSerializable(
+						directoryOp.value,
+						this.serializer,
+						this.handle,
+					).value,
+				);
+				break;
+			}
+			default: {
+				unreachableCase(directoryOp);
+			}
 		}
-		return handler.applyStashedOp(op as IDirectoryOperation);
 	}
 
 	private serializeDirectory(
@@ -1211,10 +1217,13 @@ function isDirectoryLocalOpMetadata(metadata: any): metadata is DirectoryLocalOp
 
 /* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */
 
+// eslint-disable-next-line @rushstack/no-new-null
 function assertNonNullClientId(clientId: string | null): asserts clientId is string {
 	assert(clientId !== null, 0x6af /* client id should never be null */);
 }
 
+let hasLoggedDirectoryInconsistency = false;
+
 /**
  * Node of the directory tree.
  * @sealed
@@ -1305,6 +1314,7 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 		private readonly runtime: IFluidDataStoreRuntime,
 		private readonly serializer: IFluidSerializer,
 		public readonly absolutePath: string,
+		private readonly logger: ITelemetryLoggerExt,
 	) {
 		super();
 		this.localCreationSeqTracker = new DirectoryCreationTracker();
@@ -1438,13 +1448,15 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 	}
 
 	/**
-	 * @returns The Sequence Data which should be used for local changes.
+	 * Gets the Sequence Data which should be used for local changes.
+	 *
 	 * @remarks While detached, 0 is used rather than -1 to represent a change which should be universally known (as opposed to known
 	 * only by the local client). This ensures that if the directory is later attached, none of its data needs to be updated (the values
 	 * last set while detached will now be known to any new client, until they are changed).
 	 *
 	 * The client sequence number is incremented by 1 for maintaining the internal order of locally created subdirectories
-	 * TODO: Convert these conventions to named constants. The semantics used here match those for merge-tree.
+	 *
+	 * @privateRemarks TODO: Convert these conventions to named constants. The semantics used here match those for merge-tree.
 	 */
 	private getLocalSeq(): SequenceData {
 		return this.directory.isAttached()
@@ -1506,23 +1518,41 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 
 		const subdirNames = [...ackedSubdirsInOrder, ...localSubdirsInOrder];
 
-		assert(
-			subdirNames.length === this._subdirectories.size,
-			0x85c /* The count of keys for iteration should be consistent with the size of actual data */,
-		);
+		if (subdirNames.length !== this._subdirectories.size) {
+			// TODO: AB#7022: Hitting this block indicates that the eventual consistency scheme for ordering subdirectories
+			// has failed. Fall back to previous directory behavior, which didn't guarantee ordering.
+			// It's not currently clear how to reach this state, so log some diagnostics to help understand the issue.
+			// This whole block should eventually be replaced by an assert that the two sizes align.
+			if (!hasLoggedDirectoryInconsistency) {
+				this.logger.sendTelemetryEvent({
+					eventName: "inconsistentSubdirectoryOrdering",
+					localKeyCount: this.localCreationSeqTracker.size,
+					ackedKeyCount: this.ackedCreationSeqTracker.size,
+					subdirNamesLength: subdirNames.length,
+					subdirectoriesSize: this._subdirectories.size,
+				});
+				hasLoggedDirectoryInconsistency = true;
+			}
+
+			return this._subdirectories.entries();
+		}
 
 		const entriesIterator = {
 			index: 0,
 			dirs: this._subdirectories,
-			next(): IteratorResult<[string, any]> {
+			next(): IteratorResult<[string, IDirectory]> {
 				if (this.index < subdirNames.length) {
 					const subdirName = subdirNames[this.index++];
 					const subdir = this.dirs.get(subdirName);
+					assert(
+						subdir !== undefined,
+						0x8ac /* Could not find expected sub-directory. */,
+					);
 					return { value: [subdirName, subdir], done: false };
 				}
 				return { value: undefined, done: true };
 			},
-			[Symbol.iterator](): IterableIterator<[string, any]> {
+			[Symbol.iterator](): IterableIterator<[string, IDirectory]> {
 				return this;
 			},
 		};
@@ -1685,7 +1715,6 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 	 * @param local - Whether the message originated from the local client
 	 * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
 	 * For messages from a remote client, this will be undefined.
-	 * @internal
 	 */
 	public processClearMessage(
 		msg: ISequencedDocumentMessage,
@@ -1712,25 +1741,6 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 		this.clearExceptPendingKeys(false);
 	}
 
-	/**
-	 * Apply clear operation locally and generate metadata
-	 * @param op - Op to apply
-	 * @returns metadata generated for stahed op
-	 */
-	public applyStashedClearMessage(op: IDirectoryClearOperation): IClearLocalOpMetadata {
-		this.throwIfDisposed();
-		const previousValue = new Map<string, ILocalValue>(this._storage);
-		this.clearExceptPendingKeys(true);
-		const pendingMsgId = ++this.pendingMessageId;
-		this.pendingClearMessageIds.push(pendingMsgId);
-		const metadata: IClearLocalOpMetadata = {
-			type: "clear",
-			pendingMessageId: pendingMsgId,
-			previousStorage: previousValue,
-		};
-		return metadata;
-	}
-
 	/**
 	 * Process a delete operation.
 	 * @param msg - The message from the server to apply.
@@ -1738,7 +1748,6 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 	 * @param local - Whether the message originated from the local client
 	 * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
 	 * For messages from a remote client, this will be undefined.
-	 * @internal
 	 */
 	public processDeleteMessage(
 		msg: ISequencedDocumentMessage,
@@ -1758,23 +1767,6 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 		this.deleteCore(op.key, local);
 	}
 
-	/**
-	 * Apply delete operation locally and generate metadata
-	 * @param op - Op to apply
-	 * @returns metadata generated for stahed op
-	 */
-	public applyStashedDeleteMessage(op: IDirectoryDeleteOperation): IKeyEditLocalOpMetadata {
-		this.throwIfDisposed();
-		const previousValue = this.deleteCore(op.key, true);
-		const pendingMessageId = this.getKeyMessageId(op);
-		const localMetadata: IKeyEditLocalOpMetadata = {
-			type: "edit",
-			pendingMessageId,
-			previousValue,
-		};
-		return localMetadata;
-	}
-
 	/**
 	 * Process a set operation.
 	 * @param msg - The message from the server to apply.
@@ -1782,7 +1774,6 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 	 * @param local - Whether the message originated from the local client
 	 * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
 	 * For messages from a remote client, this will be undefined.
-	 * @internal
 	 */
 	public processSetMessage(
 		msg: ISequencedDocumentMessage,
@@ -1807,28 +1798,6 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 		this.setCore(op.key, context!, local);
 	}
 
-	/**
-	 * Apply set operation locally and generate metadata
-	 * @param op - Op to apply
-	 * @returns metadata generated for stahed op
-	 */
-	public applyStashedSetMessage(
-		op: IDirectorySetOperation,
-		context: ILocalValue,
-	): IKeyEditLocalOpMetadata {
-		this.throwIfDisposed();
-		// Set the value locally.
-		const previousValue = this.setCore(op.key, context, true);
-
-		// Create metadata
-		const pendingMessageId = this.getKeyMessageId(op);
-		const localMetadata: IKeyEditLocalOpMetadata = {
-			type: "edit",
-			pendingMessageId,
-			previousValue,
-		};
-		return localMetadata;
-	}
 	/**
 	 * Process a create subdirectory operation.
 	 * @param msg - The message from the server to apply.
@@ -1836,7 +1805,6 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 	 * @param local - Whether the message originated from the local client
 	 * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
 	 * For messages from a remote client, this will be undefined.
-	 * @internal
 	 */
 	public processCreateSubDirectoryMessage(
 		msg: ISequencedDocumentMessage,
@@ -1862,30 +1830,6 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 		);
 	}
 
-	/**
-	 * Apply createSubDirectory operation locally and generate metadata
-	 * @param op - Op to apply
-	 * @returns metadata generated for stahed op
-	 */
-	public applyStashedCreateSubDirMessage(
-		op: IDirectoryCreateSubDirectoryOperation,
-	): ICreateSubDirLocalOpMetadata {
-		this.throwIfDisposed();
-		// Create the sub directory locally first.
-		this.createSubDirectoryCore(
-			op.subdirName,
-			true,
-			this.getLocalSeq(),
-			this.runtime.clientId ?? "detached",
-		);
-		this.updatePendingSubDirMessageCount(op);
-
-		const localOpMetadata: ICreateSubDirLocalOpMetadata = {
-			type: "createSubDir",
-		};
-		return localOpMetadata;
-	}
-
 	/**
 	 * Process a delete subdirectory operation.
 	 * @param msg - The message from the server to apply.
@@ -1893,7 +1837,6 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 	 * @param local - Whether the message originated from the local client
 	 * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
 	 * For messages from a remote client, this will be undefined.
-	 * @internal
 	 */
 	public processDeleteSubDirectoryMessage(
 		msg: ISequencedDocumentMessage,
@@ -1913,24 +1856,6 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 		this.deleteSubDirectoryCore(op.subdirName, local);
 	}
 
-	/**
-	 * Apply deleteSubDirectory operation locally and generate metadata
-	 * @param op - Op to apply
-	 * @returns metadata generated for stahed op
-	 */
-	public applyStashedDeleteSubDirMessage(
-		op: IDirectoryDeleteSubDirectoryOperation,
-	): IDeleteSubDirLocalOpMetadata {
-		this.throwIfDisposed();
-		const subDir = this.deleteSubDirectoryCore(op.subdirName, true);
-		this.updatePendingSubDirMessageCount(op);
-		const metadata: IDeleteSubDirLocalOpMetadata = {
-			type: "deleteSubDir",
-			subDirectory: subDir,
-		};
-		return metadata;
-	}
-
 	/**
 	 * Submit a clear operation.
 	 * @param op - The operation
@@ -1953,7 +1878,6 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 	/**
 	 * Resubmit a clear operation.
 	 * @param op - The operation
-	 * @internal
 	 */
 	public resubmitClearMessage(op: IDirectoryClearOperation, localOpMetadata: unknown): void {
 		assert(
@@ -1976,10 +1900,10 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 		// We don't reuse the metadata pendingMessageId but send a new one on each submit.
 		const pendingMessageId = ++this.pendingMessageId;
 		const pendingMessageIds = this.pendingKeys.get(op.key);
-		if (pendingMessageIds !== undefined) {
-			pendingMessageIds.push(pendingMessageId);
-		} else {
+		if (pendingMessageIds === undefined) {
 			this.pendingKeys.set(op.key, [pendingMessageId]);
+		} else {
+			pendingMessageIds.push(pendingMessageId);
 		}
 		return pendingMessageId;
 	}
@@ -2000,7 +1924,6 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 	 * Submit a key message to remote clients based on a previous submit.
 	 * @param op - The map key message
 	 * @param localOpMetadata - Metadata from the previous submit
-	 * @internal
 	 */
 	public resubmitKeyMessage(op: IDirectoryKeyOperation, localOpMetadata: unknown): void {
 		assert(
@@ -2013,9 +1936,7 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 		// Only submit the op, if we have record for it, otherwise it is possible that the older instance
 		// is already deleted, in which case we don't need to submit the op.
 		if (pendingMessageIds !== undefined) {
-			const index = pendingMessageIds.findIndex(
-				(id) => id === localOpMetadata.pendingMessageId,
-			);
+			const index = pendingMessageIds.indexOf(localOpMetadata.pendingMessageId);
 			if (index === -1) {
 				return;
 			}
@@ -2027,12 +1948,12 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 		}
 	}
 
-	private incrementPendingSubDirCount(map: Map<string, number>, subDirName: string) {
+	private incrementPendingSubDirCount(map: Map<string, number>, subDirName: string): void {
 		const count = map.get(subDirName) ?? 0;
 		map.set(subDirName, count + 1);
 	}
 
-	private decrementPendingSubDirCount(map: Map<string, number>, subDirName: string) {
+	private decrementPendingSubDirCount(map: Map<string, number>, subDirName: string): void {
 		const count = map.get(subDirName) ?? 0;
 		map.set(subDirName, count - 1);
 		if (count <= 1) {
@@ -2044,7 +1965,7 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 	 * Update the count for pending create/delete of the sub directory so that it can be validated on receiving op
 	 * or while resubmitting the op.
 	 */
-	private updatePendingSubDirMessageCount(op: IDirectorySubDirectoryOperation) {
+	private updatePendingSubDirMessageCount(op: IDirectorySubDirectoryOperation): void {
 		if (op.type === "deleteSubDirectory") {
 			this.incrementPendingSubDirCount(
 				this.pendingDeleteSubDirectoriesTracker,
@@ -2095,7 +2016,6 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 	 * Submit a subdirectory operation again
 	 * @param op - The operation
 	 * @param localOpMetadata - metadata submitted with the op originally
-	 * @internal
 	 */
 	public resubmitSubDirectoryMessage(
 		op: IDirectorySubDirectoryOperation,
@@ -2139,7 +2059,6 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 	 * Get the storage of this subdirectory in a serializable format, to be used in snapshotting.
 	 * @param serializer - The serializer to use to serialize handles in its values.
 	 * @returns The JSONable string representing the storage of this subdirectory
-	 * @internal
 	 */
 	public *getSerializedStorage(
 		serializer: IFluidSerializer,
@@ -2152,11 +2071,11 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 		}
 	}
 
-	public getSerializableCreateInfo() {
+	public getSerializableCreateInfo(): ICreateInfo {
 		this.throwIfDisposed();
 		const createInfo: ICreateInfo = {
 			csn: this.seqData.seq,
-			ccIds: Array.from(this.clientIds),
+			ccIds: [...this.clientIds],
 		};
 		return createInfo;
 	}
@@ -2165,7 +2084,6 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 	 * Populate a key value in this subdirectory's storage, to be used when loading from snapshot.
 	 * @param key - The key to populate
 	 * @param localValue - The local value to populate into it
-	 * @internal
 	 */
 	public populateStorage(key: string, localValue: ILocalValue): void {
 		this.throwIfDisposed();
@@ -2176,7 +2094,6 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 	 * Populate a subdirectory into this subdirectory, to be used when loading from snapshot.
 	 * @param subdirName - The name of the subdirectory to add
 	 * @param newSubDir - The new subdirectory to add
-	 * @internal
 	 */
 	public populateSubDirectory(subdirName: string, newSubDir: SubDirectory): void {
 		this.throwIfDisposed();
@@ -2188,7 +2105,6 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 	 * value so op handlers can be retrieved
 	 * @param key - The key to retrieve from
 	 * @returns The local value
-	 * @internal
 	 */
 	public getLocalValue<T extends ILocalValue = ILocalValue>(key: string): T {
 		this.throwIfDisposed();
@@ -2241,46 +2157,62 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 				throw new Error("Rollback op does match last clear");
 			}
 		} else if ((op.type === "delete" || op.type === "set") && localOpMetadata.type === "edit") {
+			const key: unknown = op.key;
+			assert(key !== undefined, 0x8ad /* "key" property is missing from edit operation. */);
+			assert(
+				typeof key === "string",
+				0x8ae /* "key" property in edit operation is misconfigured. Expected a string. */,
+			);
+
 			if (localOpMetadata.previousValue === undefined) {
-				this.deleteCore(op.key as string, true);
+				this.deleteCore(key, true);
 			} else {
-				this.setCore(op.key as string, localOpMetadata.previousValue, true);
+				this.setCore(key, localOpMetadata.previousValue, true);
 			}
 
-			this.rollbackPendingMessageId(
-				this.pendingKeys,
-				op.key as string,
-				localOpMetadata.pendingMessageId,
-			);
+			this.rollbackPendingMessageId(this.pendingKeys, key, localOpMetadata.pendingMessageId);
 		} else if (op.type === "createSubDirectory" && localOpMetadata.type === "createSubDir") {
-			this.deleteSubDirectoryCore(op.subdirName as string, true);
-
-			this.decrementPendingSubDirCount(
-				this.pendingCreateSubDirectoriesTracker,
-				op.subdirName as string,
+			const subdirName: unknown = op.subdirName;
+			assert(
+				subdirName !== undefined,
+				0x8af /* "subdirName" property is missing from "createSubDirectory" operation. */,
+			);
+			assert(
+				typeof subdirName === "string",
+				0x8b0 /* "subdirName" property in "createSubDirectory" operation is misconfigured. Expected a string. */,
 			);
+
+			this.deleteSubDirectoryCore(subdirName, true);
+			this.decrementPendingSubDirCount(this.pendingCreateSubDirectoriesTracker, subdirName);
 		} else if (op.type === "deleteSubDirectory" && localOpMetadata.type === "deleteSubDir") {
+			const subdirName: unknown = op.subdirName;
+			assert(
+				subdirName !== undefined,
+				0x8b1 /* "subdirName" property is missing from "deleteSubDirectory" operation. */,
+			);
+			assert(
+				typeof subdirName === "string",
+				0x8b2 /* "subdirName" property in "deleteSubDirectory" operation is misconfigured. Expected a string. */,
+			);
+
 			if (localOpMetadata.subDirectory !== undefined) {
 				this.undeleteSubDirectoryTree(localOpMetadata.subDirectory);
 				// don't need to register events because deleting never unregistered
-				this._subdirectories.set(op.subdirName as string, localOpMetadata.subDirectory);
+				this._subdirectories.set(subdirName, localOpMetadata.subDirectory);
 				// Restore the record in creation tracker
 				if (isAcknowledgedOrDetached(localOpMetadata.subDirectory.seqData)) {
-					this.ackedCreationSeqTracker.set(op.subdirName, {
+					this.ackedCreationSeqTracker.set(subdirName, {
 						...localOpMetadata.subDirectory.seqData,
 					});
 				} else {
-					this.localCreationSeqTracker.set(op.subdirName, {
+					this.localCreationSeqTracker.set(subdirName, {
 						...localOpMetadata.subDirectory.seqData,
 					});
 				}
-				this.emit("subDirectoryCreated", op.subdirName, true, this);
+				this.emit("subDirectoryCreated", subdirName, true, this);
 			}
 
-			this.decrementPendingSubDirCount(
-				this.pendingDeleteSubDirectoriesTracker,
-				op.subDirName as string,
-			);
+			this.decrementPendingSubDirCount(this.pendingDeleteSubDirectoriesTracker, subdirName);
 		} else {
 			throw new Error("Unsupported op for rollback");
 		}
@@ -2370,7 +2302,7 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 	 * can be deleted and created again, then this finds if the message is for current instance of directory or not.
 	 * @param msg - message for the directory
 	 */
-	private isMessageForCurrentInstanceOfSubDirectory(msg: ISequencedDocumentMessage) {
+	private isMessageForCurrentInstanceOfSubDirectory(msg: ISequencedDocumentMessage): boolean {
 		// If the message is either from the creator of directory or this directory was created when
 		// container was detached or in case this directory is already live(known to other clients)
 		// and the op was created after the directory was created then apply this op.
@@ -2592,15 +2524,16 @@ class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirec
 				this.runtime,
 				this.serializer,
 				absolutePath,
+				this.logger,
 			);
 			/**
 			 * Store the sequnce numbers of newly created subdirectory to the proper creation tracker, based
 			 * on whether the creation behavior has been ack'd or not
 			 */
-			if (!isAcknowledgedOrDetached(seqData)) {
-				this.localCreationSeqTracker.set(subdirName, { ...seqData });
-			} else {
+			if (isAcknowledgedOrDetached(seqData)) {
 				this.ackedCreationSeqTracker.set(subdirName, { ...seqData });
+			} else {
+				this.localCreationSeqTracker.set(subdirName, { ...seqData });
 			}
 
 			this.registerEventsOnSubDirectory(subDir, subdirName);