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

package/dist/directory.js

@@ -18,8 +18,8 @@ const shared_object_base_1 = require("@fluidframework/shared-object-base");
 const runtime_utils_1 = require("@fluidframework/runtime-utils");
 const path_browserify_1 = __importDefault(require("path-browserify"));
 const merge_tree_1 = require("@fluidframework/merge-tree");
-const localValues_1 = require("./localValues");
-const packageVersion_1 = require("./packageVersion");
+const localValues_js_1 = require("./localValues.js");
+const packageVersion_js_1 = require("./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.
 const posix = path_browserify_1.default.posix;
@@ -71,7 +71,7 @@ DirectoryFactory.Type = "https://graph.microsoft.com/types/directory";
 DirectoryFactory.Attributes = {
     type: DirectoryFactory.Type,
     snapshotFormatVersion: "0.1",
-    packageVersion: packageVersion_1.pkgVersion,
+    packageVersion: packageVersion_js_1.pkgVersion,
 };
 /**
  * The comparator essentially performs the following procedure to determine the order of subdirectory creation:
@@ -97,19 +97,19 @@ const seqDataComparator = (a, b) => {
     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;
+        if (isAcknowledgedOrDetached(b)) {
+            return 1;
         }
         else {
-            return 1;
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            return a.seq === b.seq ? a.clientSeq - b.clientSeq : a.seq - b.seq;
         }
     }
 };
@@ -166,6 +166,9 @@ class DirectoryCreationTracker {
         }, keys);
         return keys;
     }
+    get size() {
+        return this.keyToIndex.size;
+    }
 }
 /**
  * {@inheritDoc ISharedDirectory}
@@ -222,12 +225,12 @@ class SharedDirectory extends shared_object_base_1.SharedObject {
         /**
          * Root of the SharedDirectory, most operations on the SharedDirectory itself act on the root.
          */
-        this.root = new SubDirectory({ seq: 0, clientSeq: 0 }, new Set(), this, this.runtime, this.serializer, posix.sep);
+        this.root = new SubDirectory({ seq: 0, clientSeq: 0 }, new Set(), this, this.runtime, this.serializer, posix.sep, this.logger);
         /**
          * Mapping of op types to message handlers.
          */
         this.messageHandlers = new Map();
-        this.localValueMaker = new localValues_1.LocalValueMaker(this.serializer);
+        this.localValueMaker = new localValues_js_1.LocalValueMaker();
         this.setMessageHandlers();
         // Mirror the containedValueChanged op on the SharedDirectory
         this.root.on("containedValueChanged", (changed, local) => {
@@ -456,10 +459,7 @@ class SharedDirectory extends shared_object_base_1.SharedObject {
                         // 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);
                             }
@@ -468,14 +468,21 @@ class SharedDirectory extends shared_object_base_1.SharedObject {
                             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,
                             };
                         }
-                        newSubDir = new SubDirectory(seqData, createInfo !== undefined
-                            ? new Set(createInfo.ccIds)
-                            : new Set(), this, this.runtime, this.serializer, posix.join(currentSubDir.absolutePath, subdirName));
+                        newSubDir = new SubDirectory(seqData, createInfo === undefined
+                            ? new Set()
+                            : new Set(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
                         currentSubDir.ackedCreationSeqTracker.set(subdirName, {
@@ -487,7 +494,9 @@ class SharedDirectory extends shared_object_base_1.SharedObject {
             }
             if (currentSubDirObject.storage) {
                 for (const [key, serializable] of Object.entries(currentSubDirObject.storage)) {
-                    const localValue = this.makeLocal(key, currentSubDir.absolutePath, serializable);
+                    const localValue = this.makeLocal(key, currentSubDir.absolutePath, 
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                    (0, shared_object_base_1.parseHandles)(serializable, this.serializer));
                     currentSubDir.populateStorage(key, localValue);
                 }
             }
@@ -536,7 +545,7 @@ class SharedDirectory extends shared_object_base_1.SharedObject {
     serializable) {
         (0, core_utils_1.assert)(serializable.type === shared_object_base_1.ValueType[shared_object_base_1.ValueType.Plain] ||
             serializable.type === shared_object_base_1.ValueType[shared_object_base_1.ValueType.Shared], 0x1e4 /* "Unexpected serializable type" */);
-        return this.localValueMaker.fromSerializable(serializable);
+        return this.localValueMaker.fromSerializable(serializable, this.serializer, this.handle);
     }
     /**
      * This checks if there is pending delete op for local delete for a any subdir in the relative path.
@@ -583,12 +592,6 @@ class SharedDirectory extends shared_object_base_1.SharedObject {
                     subdir.resubmitClearMessage(op, localOpMetadata);
                 }
             },
-            applyStashedOp: (op) => {
-                const subdir = this.getWorkingDirectory(op.path);
-                if (subdir) {
-                    return subdir.applyStashedClearMessage(op);
-                }
-            },
         });
         this.messageHandlers.set("delete", {
             process: (msg, op, local, localOpMetadata) => {
@@ -605,12 +608,6 @@ class SharedDirectory extends shared_object_base_1.SharedObject {
                     subdir.resubmitKeyMessage(op, localOpMetadata);
                 }
             },
-            applyStashedOp: (op) => {
-                const subdir = this.getWorkingDirectory(op.path);
-                if (subdir) {
-                    return subdir.applyStashedDeleteMessage(op);
-                }
-            },
         });
         this.messageHandlers.set("set", {
             process: (msg, op, local, localOpMetadata) => {
@@ -628,13 +625,6 @@ class SharedDirectory extends shared_object_base_1.SharedObject {
                     subdir.resubmitKeyMessage(op, localOpMetadata);
                 }
             },
-            applyStashedOp: (op) => {
-                const subdir = this.getWorkingDirectory(op.path);
-                if (subdir) {
-                    const context = this.makeLocal(op.key, op.path, op.value);
-                    return subdir.applyStashedSetMessage(op, context);
-                }
-            },
         });
         this.messageHandlers.set("createSubDirectory", {
             process: (msg, op, local, localOpMetadata) => {
@@ -652,12 +642,6 @@ class SharedDirectory extends shared_object_base_1.SharedObject {
                     parentSubdir.resubmitSubDirectoryMessage(op, localOpMetadata);
                 }
             },
-            applyStashedOp: (op) => {
-                const parentSubdir = this.getWorkingDirectory(op.path);
-                if (parentSubdir) {
-                    return parentSubdir.applyStashedCreateSubDirMessage(op);
-                }
-            },
         });
         this.messageHandlers.set("deleteSubDirectory", {
             process: (msg, op, local, localOpMetadata) => {
@@ -675,23 +659,39 @@ class SharedDirectory extends shared_object_base_1.SharedObject {
                     parentSubdir.resubmitSubDirectoryMessage(op, localOpMetadata);
                 }
             },
-            applyStashedOp: (op) => {
-                const parentSubdir = this.getWorkingDirectory(op.path);
-                if (parentSubdir) {
-                    return parentSubdir.applyStashedDeleteSubDirMessage(op);
-                }
-            },
         });
     }
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
      */
     applyStashedOp(op) {
-        const handler = this.messageHandlers.get(op.type);
-        if (handler === undefined) {
-            throw new Error("no apply stashed op handler");
+        const directoryOp = op;
+        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: {
+                (0, core_utils_1.unreachableCase)(directoryOp);
+            }
         }
-        return handler.applyStashedOp(op);
     }
     serializeDirectory(root, serializer, telemetryContext) {
         const MinValueSizeSeparateSnapshotBlob = 8 * 1024;
@@ -774,9 +774,11 @@ function isDirectoryLocalOpMetadata(metadata) {
         isSubDirLocalOpMetadata(metadata));
 }
 /* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */
+// eslint-disable-next-line @rushstack/no-new-null
 function assertNonNullClientId(clientId) {
     (0, core_utils_1.assert)(clientId !== null, 0x6af /* client id should never be null */);
 }
+let hasLoggedDirectoryInconsistency = false;
 /**
  * Node of the directory tree.
  * @sealed
@@ -791,7 +793,7 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
      * @param serializer - The serializer to serialize / parse handles
      * @param absolutePath - The absolute path of this IDirectory
      */
-    constructor(seqData, clientIds, directory, runtime, serializer, absolutePath) {
+    constructor(seqData, clientIds, directory, runtime, serializer, absolutePath, logger) {
         super();
         this.seqData = seqData;
         this.clientIds = clientIds;
@@ -799,6 +801,7 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
         this.runtime = runtime;
         this.serializer = serializer;
         this.absolutePath = absolutePath;
+        this.logger = logger;
         /**
          * Tells if the sub directory is deleted or not.
          */
@@ -896,7 +899,7 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
         }
         // Create a local value and serialize it.
         const localValue = this.directory.localValueMaker.fromInMemory(value);
-        const serializableValue = (0, localValues_1.makeSerializable)(localValue, this.serializer, this.directory.handle);
+        const serializableValue = (0, localValues_js_1.makeSerializable)(localValue, this.serializer, this.directory.handle);
         // Set the value locally.
         const previousValue = this.setCore(key, localValue, true);
         // If we are not attached, don't submit the op.
@@ -950,13 +953,15 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
         return subDir;
     }
     /**
-     * @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.
      */
     getLocalSeq() {
         return this.directory.isAttached()
@@ -1007,7 +1012,23 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
         const ackedSubdirsInOrder = this.ackedCreationSeqTracker.keys();
         const localSubdirsInOrder = this.localCreationSeqTracker.keys((key) => !this.ackedCreationSeqTracker.has(key));
         const subdirNames = [...ackedSubdirsInOrder, ...localSubdirsInOrder];
-        (0, core_utils_1.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,
@@ -1015,6 +1036,7 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
                 if (this.index < subdirNames.length) {
                     const subdirName = subdirNames[this.index++];
                     const subdir = this.dirs.get(subdirName);
+                    (0, core_utils_1.assert)(subdir !== undefined, 0x8ac /* Could not find expected sub-directory. */);
                     return { value: [subdirName, subdir], done: false };
                 }
                 return { value: undefined, done: true };
@@ -1163,7 +1185,6 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
      * @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
      */
     processClearMessage(msg, op, local, localOpMetadata) {
         this.throwIfDisposed();
@@ -1178,24 +1199,6 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
         }
         this.clearExceptPendingKeys(false);
     }
-    /**
-     * Apply clear operation locally and generate metadata
-     * @param op - Op to apply
-     * @returns metadata generated for stahed op
-     */
-    applyStashedClearMessage(op) {
-        this.throwIfDisposed();
-        const previousValue = new Map(this._storage);
-        this.clearExceptPendingKeys(true);
-        const pendingMsgId = ++this.pendingMessageId;
-        this.pendingClearMessageIds.push(pendingMsgId);
-        const metadata = {
-            type: "clear",
-            pendingMessageId: pendingMsgId,
-            previousStorage: previousValue,
-        };
-        return metadata;
-    }
     /**
      * Process a delete operation.
      * @param msg - The message from the server to apply.
@@ -1203,7 +1206,6 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
      * @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
      */
     processDeleteMessage(msg, op, local, localOpMetadata) {
         this.throwIfDisposed();
@@ -1213,22 +1215,6 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
         }
         this.deleteCore(op.key, local);
     }
-    /**
-     * Apply delete operation locally and generate metadata
-     * @param op - Op to apply
-     * @returns metadata generated for stahed op
-     */
-    applyStashedDeleteMessage(op) {
-        this.throwIfDisposed();
-        const previousValue = this.deleteCore(op.key, true);
-        const pendingMessageId = this.getKeyMessageId(op);
-        const localMetadata = {
-            type: "edit",
-            pendingMessageId,
-            previousValue,
-        };
-        return localMetadata;
-    }
     /**
      * Process a set operation.
      * @param msg - The message from the server to apply.
@@ -1236,7 +1222,6 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
      * @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
      */
     processSetMessage(msg, op, context, local, localOpMetadata) {
         this.throwIfDisposed();
@@ -1249,24 +1234,6 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         this.setCore(op.key, context, local);
     }
-    /**
-     * Apply set operation locally and generate metadata
-     * @param op - Op to apply
-     * @returns metadata generated for stahed op
-     */
-    applyStashedSetMessage(op, context) {
-        this.throwIfDisposed();
-        // Set the value locally.
-        const previousValue = this.setCore(op.key, context, true);
-        // Create metadata
-        const pendingMessageId = this.getKeyMessageId(op);
-        const localMetadata = {
-            type: "edit",
-            pendingMessageId,
-            previousValue,
-        };
-        return localMetadata;
-    }
     /**
      * Process a create subdirectory operation.
      * @param msg - The message from the server to apply.
@@ -1274,7 +1241,6 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
      * @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
      */
     processCreateSubDirectoryMessage(msg, op, local, localOpMetadata) {
         this.throwIfDisposed();
@@ -1285,21 +1251,6 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
         assertNonNullClientId(msg.clientId);
         this.createSubDirectoryCore(op.subdirName, local, { seq: msg.sequenceNumber, clientSeq: msg.clientSequenceNumber }, msg.clientId);
     }
-    /**
-     * Apply createSubDirectory operation locally and generate metadata
-     * @param op - Op to apply
-     * @returns metadata generated for stahed op
-     */
-    applyStashedCreateSubDirMessage(op) {
-        this.throwIfDisposed();
-        // Create the sub directory locally first.
-        this.createSubDirectoryCore(op.subdirName, true, this.getLocalSeq(), this.runtime.clientId ?? "detached");
-        this.updatePendingSubDirMessageCount(op);
-        const localOpMetadata = {
-            type: "createSubDir",
-        };
-        return localOpMetadata;
-    }
     /**
      * Process a delete subdirectory operation.
      * @param msg - The message from the server to apply.
@@ -1307,7 +1258,6 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
      * @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
      */
     processDeleteSubDirectoryMessage(msg, op, local, localOpMetadata) {
         this.throwIfDisposed();
@@ -1317,21 +1267,6 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
         }
         this.deleteSubDirectoryCore(op.subdirName, local);
     }
-    /**
-     * Apply deleteSubDirectory operation locally and generate metadata
-     * @param op - Op to apply
-     * @returns metadata generated for stahed op
-     */
-    applyStashedDeleteSubDirMessage(op) {
-        this.throwIfDisposed();
-        const subDir = this.deleteSubDirectoryCore(op.subdirName, true);
-        this.updatePendingSubDirMessageCount(op);
-        const metadata = {
-            type: "deleteSubDir",
-            subDirectory: subDir,
-        };
-        return metadata;
-    }
     /**
      * Submit a clear operation.
      * @param op - The operation
@@ -1350,7 +1285,6 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
     /**
      * Resubmit a clear operation.
      * @param op - The operation
-     * @internal
      */
     resubmitClearMessage(op, localOpMetadata) {
         (0, core_utils_1.assert)(isClearLocalOpMetadata(localOpMetadata), 0x32b /* Invalid localOpMetadata for clear */);
@@ -1369,11 +1303,11 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
         // 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);
+        if (pendingMessageIds === undefined) {
+            this.pendingKeys.set(op.key, [pendingMessageId]);
         }
         else {
-            this.pendingKeys.set(op.key, [pendingMessageId]);
+            pendingMessageIds.push(pendingMessageId);
         }
         return pendingMessageId;
     }
@@ -1392,7 +1326,6 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
      * 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
      */
     resubmitKeyMessage(op, localOpMetadata) {
         (0, core_utils_1.assert)(isKeyEditLocalOpMetadata(localOpMetadata), 0x32d /* Invalid localOpMetadata in submit */);
@@ -1401,7 +1334,7 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
         // 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;
             }
@@ -1465,7 +1398,6 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
      * Submit a subdirectory operation again
      * @param op - The operation
      * @param localOpMetadata - metadata submitted with the op originally
-     * @internal
      */
     resubmitSubDirectoryMessage(op, localOpMetadata) {
         (0, core_utils_1.assert)(isSubDirLocalOpMetadata(localOpMetadata), 0x32f /* Invalid localOpMetadata for sub directory op */);
@@ -1492,7 +1424,6 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
      * 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
      */
     *getSerializedStorage(serializer) {
         this.throwIfDisposed();
@@ -1506,7 +1437,7 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
         this.throwIfDisposed();
         const createInfo = {
             csn: this.seqData.seq,
-            ccIds: Array.from(this.clientIds),
+            ccIds: [...this.clientIds],
         };
         return createInfo;
     }
@@ -1514,7 +1445,6 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
      * 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
      */
     populateStorage(key, localValue) {
         this.throwIfDisposed();
@@ -1524,7 +1454,6 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
      * 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
      */
     populateSubDirectory(subdirName, newSubDir) {
         this.throwIfDisposed();
@@ -1535,7 +1464,6 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
      * value so op handlers can be retrieved
      * @param key - The key to retrieve from
      * @returns The local value
-     * @internal
      */
     getLocalValue(key) {
         this.throwIfDisposed();
@@ -1578,37 +1506,46 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
             }
         }
         else if ((op.type === "delete" || op.type === "set") && localOpMetadata.type === "edit") {
+            const key = op.key;
+            (0, core_utils_1.assert)(key !== undefined, 0x8ad /* "key" property is missing from edit operation. */);
+            (0, core_utils_1.assert)(typeof key === "string", 0x8ae /* "key" property in edit operation is misconfigured. Expected a string. */);
             if (localOpMetadata.previousValue === undefined) {
-                this.deleteCore(op.key, true);
+                this.deleteCore(key, true);
             }
             else {
-                this.setCore(op.key, localOpMetadata.previousValue, true);
+                this.setCore(key, localOpMetadata.previousValue, true);
             }
-            this.rollbackPendingMessageId(this.pendingKeys, op.key, localOpMetadata.pendingMessageId);
+            this.rollbackPendingMessageId(this.pendingKeys, key, localOpMetadata.pendingMessageId);
         }
         else if (op.type === "createSubDirectory" && localOpMetadata.type === "createSubDir") {
-            this.deleteSubDirectoryCore(op.subdirName, true);
-            this.decrementPendingSubDirCount(this.pendingCreateSubDirectoriesTracker, op.subdirName);
+            const subdirName = op.subdirName;
+            (0, core_utils_1.assert)(subdirName !== undefined, 0x8af /* "subdirName" property is missing from "createSubDirectory" operation. */);
+            (0, core_utils_1.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 = op.subdirName;
+            (0, core_utils_1.assert)(subdirName !== undefined, 0x8b1 /* "subdirName" property is missing from "deleteSubDirectory" operation. */);
+            (0, core_utils_1.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, 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);
+            this.decrementPendingSubDirCount(this.pendingDeleteSubDirectoriesTracker, subdirName);
         }
         else {
             throw new Error("Unsupported op for rollback");
@@ -1852,16 +1789,16 @@ class SubDirectory extends client_utils_1.TypedEventEmitter {
         const subdir = this._subdirectories.get(subdirName);
         if (subdir === undefined) {
             const absolutePath = posix.join(this.absolutePath, subdirName);
-            const subDir = new SubDirectory({ ...seqData }, new Set([clientId]), this.directory, this.runtime, this.serializer, absolutePath);
+            const subDir = new SubDirectory({ ...seqData }, new Set([clientId]), this.directory, 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 });
+            if (isAcknowledgedOrDetached(seqData)) {
+                this.ackedCreationSeqTracker.set(subdirName, { ...seqData });
             }
             else {
-                this.ackedCreationSeqTracker.set(subdirName, { ...seqData });
+                this.localCreationSeqTracker.set(subdirName, { ...seqData });
             }
             this.registerEventsOnSubDirectory(subDir, subdirName);
             this._subdirectories.set(subdirName, subDir);