@fluidframework/map 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/lib/{directory.js → directory.mjs}

@@ -3,22 +3,26 @@
  * Licensed under the MIT License.
  */
 var _a, _b;
-import { assert, TypedEventEmitter } from "@fluidframework/common-utils";
-import { UsageError } from "@fluidframework/container-utils";
+import { assert } from "@fluidframework/core-utils";
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
+import { UsageError } from "@fluidframework/telemetry-utils";
 import { readAndParse } from "@fluidframework/driver-utils";
-import { MessageType, } from "@fluidframework/protocol-definitions";
+import { MessageType } from "@fluidframework/protocol-definitions";
 import { SharedObject, ValueType } from "@fluidframework/shared-object-base";
 import { SummaryTreeBuilder } from "@fluidframework/runtime-utils";
-import * as path from "path-browserify";
-import { LocalValueMaker, makeSerializable, } from "./localValues";
-import { pkgVersion } from "./packageVersion";
+import path from "path-browserify";
+import { RedBlackTree } from "@fluidframework/merge-tree";
+import { LocalValueMaker, makeSerializable } from "./localValues.mjs";
+import { pkgVersion } from "./packageVersion.mjs";
 // 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.posix;
 const snapshotFileName = "header";
 /**
- * The factory that defines the directory.
+ * {@link @fluidframework/datastore-definitions#IChannelFactory} for {@link SharedDirectory}.
+ *
  * @sealed
+ * @alpha
  */
 export class DirectoryFactory {
     /**
@@ -63,11 +67,104 @@ DirectoryFactory.Attributes = {
     packageVersion: pkgVersion,
 };
 /**
- * SharedDirectory provides a hierarchical organization of map-like data structures as SubDirectories.
- * The values stored within can be accessed like a map, and the hierarchy can be navigated using path syntax.
- * SubDirectories can be retrieved for use as working directories.
+ * The comparator essentially performs the following procedure to determine the order of subdirectory creation:
+ * 1. If subdirectory A has a non-negative 'seq' and subdirectory B has a negative 'seq', subdirectory A is always placed first due to
+ * the policy that acknowledged subdirectories precede locally created ones that have not been committed yet.
+ *
+ * 2. When both subdirectories A and B have a non-negative 'seq', they are compared as follows:
+ * - If A and B have different 'seq', they are ordered based on 'seq', and the one with the lower 'seq' will be positioned ahead. Notably this rule
+ * should not be applied in the directory ordering, since the lowest 'seq' is -1, when the directory is created locally but not acknowledged yet.
+ * - In the case where A and B have equal 'seq', the one with the lower 'clientSeq' will be positioned ahead. This scenario occurs when grouped
+ * batching is enabled, and a lower 'clientSeq' indicates that it was processed earlier after the batch was ungrouped.
+ *
+ * 3. When both subdirectories A and B have a negative 'seq', they are compared as follows:
+ * - If A and B have different 'seq', the one with lower 'seq' will be positioned ahead, which indicates the corresponding creation message was
+ * acknowledged by the server earlier.
+ * - If A and B have equal 'seq', the one with lower 'clientSeq' will be placed at the front. This scenario suggests that both subdirectories A
+ * and B were created locally and not acknowledged yet, with the one possessing the lower 'clientSeq' being created earlier.
+ *
+ * 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, 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;
+        }
+        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 {
+            return 1;
+        }
+    }
+};
+function isAcknowledgedOrDetached(seqData) {
+    return seqData.seq >= 0;
+}
+/**
+ * A utility class for tracking associations between keys and their creation indices.
+ * This is relevant to support map iteration in insertion order, see
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Iterator/%40%40iterator
+ *
+ * TODO: It can be combined with the creation tracker utilized in SharedMap
+ */
+class DirectoryCreationTracker {
+    constructor() {
+        this.indexToKey = new RedBlackTree(seqDataComparator);
+        this.keyToIndex = new Map();
+    }
+    set(key, seqData) {
+        this.indexToKey.put(seqData, key);
+        this.keyToIndex.set(key, seqData);
+    }
+    has(keyOrSeqData) {
+        return typeof keyOrSeqData === "string"
+            ? this.keyToIndex.has(keyOrSeqData)
+            : this.indexToKey.get(keyOrSeqData) !== undefined;
+    }
+    delete(keyOrSeqData) {
+        if (this.has(keyOrSeqData)) {
+            if (typeof keyOrSeqData === "string") {
+                const seqData = this.keyToIndex.get(keyOrSeqData);
+                this.keyToIndex.delete(keyOrSeqData);
+                this.indexToKey.remove(seqData);
+            }
+            else {
+                const key = this.indexToKey.get(keyOrSeqData)?.data;
+                this.indexToKey.remove(keyOrSeqData);
+                this.keyToIndex.delete(key);
+            }
+        }
+    }
+    /**
+     * Retrieves all subdirectories with creation order that satisfy an optional constraint function.
+     * @param constraint - An optional constraint function that filters keys.
+     * @returns An array of keys that satisfy the constraint (or all keys if no constraint is provided).
+     */
+    keys(constraint) {
+        const keys = [];
+        this.indexToKey.mapRange((node) => {
+            if (!constraint || constraint(node.data)) {
+                keys.push(node.data);
+            }
+            return true;
+        }, keys);
+        return keys;
+    }
+}
+/**
+ * {@inheritDoc ISharedDirectory}
  *
  * @example
+ *
  * ```typescript
  * mySharedDirectory.createSubDirectory("a").createSubDirectory("b").createSubDirectory("c").set("foo", val1);
  * const mySubDir = mySharedDirectory.getWorkingDirectory("/a/b/c");
@@ -75,8 +172,33 @@ DirectoryFactory.Attributes = {
  * ```
  *
  * @sealed
+ * @alpha
  */
 export class SharedDirectory extends SharedObject {
+    /**
+     * Create a new shared directory
+     *
+     * @param runtime - Data store runtime the new shared directory belongs to
+     * @param id - Optional name of the shared directory
+     * @returns Newly create shared directory (but not attached yet)
+     */
+    static create(runtime, id) {
+        return runtime.createChannel(id, DirectoryFactory.Type);
+    }
+    /**
+     * Get a factory for SharedDirectory to register with the data store.
+     *
+     * @returns A factory that creates and load SharedDirectory
+     */
+    static getFactory() {
+        return new DirectoryFactory();
+    }
+    /**
+     * {@inheritDoc IDirectory.absolutePath}
+     */
+    get absolutePath() {
+        return this.root.absolutePath;
+    }
     /**
      * Constructs a new shared directory. If the object is non-local an id and service interfaces will
      * be provided.
@@ -93,7 +215,7 @@ export class SharedDirectory extends SharedObject {
         /**
          * Root of the SharedDirectory, most operations on the SharedDirectory itself act on the root.
          */
-        this.root = new SubDirectory(this, this.runtime, this.serializer, posix.sep);
+        this.root = new SubDirectory({ seq: 0, clientSeq: 0 }, new Set(), this, this.runtime, this.serializer, posix.sep);
         /**
          * Mapping of op types to message handlers.
          */
@@ -111,33 +233,11 @@ export class SharedDirectory extends SharedObject {
             this.emit("subDirectoryDeleted", relativePath, local, this);
         });
     }
-    /**
-     * Create a new shared directory
-     *
-     * @param runtime - Data store runtime the new shared directory belongs to
-     * @param id - Optional name of the shared directory
-     * @returns Newly create shared directory (but not attached yet)
-     */
-    static create(runtime, id) {
-        return runtime.createChannel(id, DirectoryFactory.Type);
-    }
-    /**
-     * Get a factory for SharedDirectory to register with the data store.
-     *
-     * @returns A factory that creates and load SharedDirectory
-     */
-    static getFactory() {
-        return new DirectoryFactory();
-    }
-    /**
-     * {@inheritDoc IDirectory.absolutePath}
-     */
-    get absolutePath() {
-        return this.root.absolutePath;
-    }
     /**
      * {@inheritDoc IDirectory.get}
      */
+    // TODO: Use `unknown` instead (breaking change).
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     get(key) {
         return this.root.get(key);
     }
@@ -186,13 +286,18 @@ export class SharedDirectory extends SharedObject {
      * Issue a callback on each entry under this IDirectory.
      * @param callback - Callback to issue
      */
+    // TODO: Use `unknown` instead (breaking change).
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     forEach(callback) {
+        // eslint-disable-next-line unicorn/no-array-for-each, unicorn/no-array-callback-reference
         this.root.forEach(callback);
     }
     /**
      * Get an iterator over the entries under this IDirectory.
      * @returns The iterator
      */
+    // TODO: Use `unknown` instead (breaking change).
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     [(_a = Symbol.toStringTag, Symbol.iterator)]() {
         return this.root[Symbol.iterator]();
     }
@@ -200,6 +305,8 @@ export class SharedDirectory extends SharedObject {
      * Get an iterator over the entries under this IDirectory.
      * @returns The iterator
      */
+    // TODO: Use `unknown` instead (breaking change).
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     entries() {
         return this.root.entries();
     }
@@ -220,6 +327,8 @@ export class SharedDirectory extends SharedObject {
      * Get an iterator over the values under this IDirectory.
      * @returns The iterator
      */
+    // TODO: Use `unknown` instead (breaking change).
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     values() {
         return this.root.values();
     }
@@ -262,7 +371,7 @@ export class SharedDirectory extends SharedObject {
             return this.root;
         }
         let currentSubDir = this.root;
-        const subdirs = absolutePath.substr(1).split(posix.sep);
+        const subdirs = absolutePath.slice(1).split(posix.sep);
         for (const subdir of subdirs) {
             currentSubDir = currentSubDir.getSubDirectory(subdir);
             if (!currentSubDir) {
@@ -273,7 +382,6 @@ export class SharedDirectory extends SharedObject {
     }
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.summarizeCore}
-     * @internal
      */
     summarizeCore(serializer, telemetryContext) {
         return this.serializeDirectory(this.root, serializer);
@@ -283,19 +391,16 @@ export class SharedDirectory extends SharedObject {
      * @param op - Op to submit
      * @param localOpMetadata - The local metadata associated with the op. We send a unique id that is used to track
      * this op while it has not been ack'd. This will be sent when we receive this op back from the server.
-     * @internal
      */
     submitDirectoryMessage(op, localOpMetadata) {
         this.submitLocalMessage(op, localOpMetadata);
     }
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.onDisconnect}
-     * @internal
      */
     onDisconnect() { }
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.reSubmitCore}
-     * @internal
      */
     reSubmitCore(content, localOpMetadata) {
         const message = content;
@@ -305,7 +410,6 @@ export class SharedDirectory extends SharedObject {
     }
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
-     * @internal
      */
     async loadCore(storage) {
         const data = await readAndParse(storage, snapshotFileName);
@@ -326,7 +430,6 @@ export class SharedDirectory extends SharedObject {
     /**
      * Populate the directory with the given directory data.
      * @param data - A JSON string containing serialized directory data
-     * @internal
      */
     populate(data) {
         const stack = [];
@@ -335,11 +438,42 @@ export class SharedDirectory extends SharedObject {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const [currentSubDir, currentSubDirObject] = stack.pop();
             if (currentSubDirObject.subdirectories) {
+                // Utilize a map to store the seq -> clientSeq for the newly created subdirectory
+                const tempSeqNums = new Map();
                 for (const [subdirName, subdirObject] of Object.entries(currentSubDirObject.subdirectories)) {
                     let newSubDir = currentSubDir.getSubDirectory(subdirName);
+                    let seqData;
                     if (!newSubDir) {
-                        newSubDir = new SubDirectory(this, this.runtime, this.serializer, posix.join(currentSubDir.absolutePath, subdirName));
+                        const createInfo = subdirObject.ci;
+                        // We do not store the client sequence number in the storage because the order has already been
+                        // 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 (!tempSeqNums.has(createInfo.csn)) {
+                                tempSeqNums.set(createInfo.csn, 0);
+                            }
+                            let fakeClientSeq = tempSeqNums.get(createInfo.csn);
+                            seqData = { seq: createInfo.csn, clientSeq: fakeClientSeq };
+                            tempSeqNums.set(createInfo.csn, ++fakeClientSeq);
+                        }
+                        else {
+                            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));
                         currentSubDir.populateSubDirectory(subdirName, newSubDir);
+                        // Record the newly inserted subdirectory to the creation tracker
+                        currentSubDir.ackedCreationSeqTracker.set(subdirName, {
+                            ...seqData,
+                        });
                     }
                     stack.push([newSubDir, subdirObject]);
                 }
@@ -354,20 +488,18 @@ export class SharedDirectory extends SharedObject {
     }
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.processCore}
-     * @internal
      */
     processCore(message, local, localOpMetadata) {
         if (message.type === MessageType.Operation) {
             const op = message.contents;
             const handler = this.messageHandlers.get(op.type);
             assert(handler !== undefined, 0x00e /* Missing message handler for message type */);
-            handler.process(op, local, localOpMetadata);
+            handler.process(message, op, local, localOpMetadata);
         }
     }
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.rollback}
-     * @internal
-    */
+     */
     rollback(content, localOpMetadata) {
         const op = content;
         const subdir = this.getWorkingDirectory(op.path);
@@ -392,19 +524,50 @@ export class SharedDirectory extends SharedObject {
      * @param serializable - The remote information that we can convert into a real object
      * @returns The local value that was produced
      */
-    makeLocal(key, absolutePath, serializable) {
-        assert(serializable.type === ValueType[ValueType.Plain] || serializable.type === ValueType[ValueType.Shared], 0x1e4 /* "Unexpected serializable type" */);
+    makeLocal(key, absolutePath, 
+    // eslint-disable-next-line import/no-deprecated
+    serializable) {
+        assert(serializable.type === ValueType[ValueType.Plain] ||
+            serializable.type === ValueType[ValueType.Shared], 0x1e4 /* "Unexpected serializable type" */);
         return this.localValueMaker.fromSerializable(serializable);
     }
+    /**
+     * This checks if there is pending delete op for local delete for a any subdir in the relative path.
+     * @param relativePath - path of sub directory.
+     * @returns `true` if there is pending delete, `false` otherwise.
+     */
+    isSubDirectoryDeletePending(relativePath) {
+        const absolutePath = this.makeAbsolute(relativePath);
+        if (absolutePath === posix.sep) {
+            return false;
+        }
+        let currentParent = this.root;
+        const nodeList = absolutePath.split(posix.sep);
+        let start = 1;
+        while (start < nodeList.length) {
+            const subDirName = nodeList[start];
+            if (currentParent.isSubDirectoryDeletePending(subDirName)) {
+                return true;
+            }
+            currentParent = currentParent.getSubDirectory(subDirName);
+            if (currentParent === undefined) {
+                return true;
+            }
+            start += 1;
+        }
+        return false;
+    }
     /**
      * Set the message handlers for the directory.
      */
     setMessageHandlers() {
         this.messageHandlers.set("clear", {
-            process: (op, local, localOpMetadata) => {
+            process: (msg, op, local, localOpMetadata) => {
                 const subdir = this.getWorkingDirectory(op.path);
-                if (subdir) {
-                    subdir.processClearMessage(op, local, localOpMetadata);
+                // If there is pending delete op for any subDirectory in the op.path, then don't apply the this op
+                // as we are going to delete this subDirectory.
+                if (subdir && !this.isSubDirectoryDeletePending(op.path)) {
+                    subdir.processClearMessage(msg, op, local, localOpMetadata);
                 }
             },
             submit: (op, localOpMetadata) => {
@@ -413,12 +576,20 @@ export class SharedDirectory extends SharedObject {
                     subdir.resubmitClearMessage(op, localOpMetadata);
                 }
             },
+            applyStashedOp: (op) => {
+                const subdir = this.getWorkingDirectory(op.path);
+                if (subdir) {
+                    return subdir.applyStashedClearMessage(op);
+                }
+            },
         });
         this.messageHandlers.set("delete", {
-            process: (op, local, localOpMetadata) => {
+            process: (msg, op, local, localOpMetadata) => {
                 const subdir = this.getWorkingDirectory(op.path);
-                if (subdir) {
-                    subdir.processDeleteMessage(op, local, localOpMetadata);
+                // If there is pending delete op for any subDirectory in the op.path, then don't apply the this op
+                // as we are going to delete this subDirectory.
+                if (subdir && !this.isSubDirectoryDeletePending(op.path)) {
+                    subdir.processDeleteMessage(msg, op, local, localOpMetadata);
                 }
             },
             submit: (op, localOpMetadata) => {
@@ -427,13 +598,21 @@ export class SharedDirectory extends SharedObject {
                     subdir.resubmitKeyMessage(op, localOpMetadata);
                 }
             },
+            applyStashedOp: (op) => {
+                const subdir = this.getWorkingDirectory(op.path);
+                if (subdir) {
+                    return subdir.applyStashedDeleteMessage(op);
+                }
+            },
         });
         this.messageHandlers.set("set", {
-            process: (op, local, localOpMetadata) => {
+            process: (msg, op, local, localOpMetadata) => {
                 const subdir = this.getWorkingDirectory(op.path);
-                if (subdir) {
+                // If there is pending delete op for any subDirectory in the op.path, then don't apply the this op
+                // as we are going to delete this subDirectory.
+                if (subdir && !this.isSubDirectoryDeletePending(op.path)) {
                     const context = local ? undefined : this.makeLocal(op.key, op.path, op.value);
-                    subdir.processSetMessage(op, context, local, localOpMetadata);
+                    subdir.processSetMessage(msg, op, context, local, localOpMetadata);
                 }
             },
             submit: (op, localOpMetadata) => {
@@ -442,12 +621,21 @@ export class SharedDirectory extends 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: (op, local, localOpMetadata) => {
+            process: (msg, op, local, localOpMetadata) => {
                 const parentSubdir = this.getWorkingDirectory(op.path);
-                if (parentSubdir) {
-                    parentSubdir.processCreateSubDirectoryMessage(op, local, localOpMetadata);
+                // If there is pending delete op for any subDirectory in the op.path, then don't apply the this op
+                // as we are going to delete this subDirectory.
+                if (parentSubdir && !this.isSubDirectoryDeletePending(op.path)) {
+                    parentSubdir.processCreateSubDirectoryMessage(msg, op, local, localOpMetadata);
                 }
             },
             submit: (op, localOpMetadata) => {
@@ -457,12 +645,20 @@ export class SharedDirectory extends SharedObject {
                     parentSubdir.resubmitSubDirectoryMessage(op, localOpMetadata);
                 }
             },
+            applyStashedOp: (op) => {
+                const parentSubdir = this.getWorkingDirectory(op.path);
+                if (parentSubdir) {
+                    return parentSubdir.applyStashedCreateSubDirMessage(op);
+                }
+            },
         });
         this.messageHandlers.set("deleteSubDirectory", {
-            process: (op, local, localOpMetadata) => {
+            process: (msg, op, local, localOpMetadata) => {
                 const parentSubdir = this.getWorkingDirectory(op.path);
-                if (parentSubdir) {
-                    parentSubdir.processDeleteSubDirectoryMessage(op, local, localOpMetadata);
+                // If there is pending delete op for any subDirectory in the op.path, then don't apply the this op
+                // as we are going to delete this subDirectory.
+                if (parentSubdir && !this.isSubDirectoryDeletePending(op.path)) {
+                    parentSubdir.processDeleteSubDirectoryMessage(msg, op, local, localOpMetadata);
                 }
             },
             submit: (op, localOpMetadata) => {
@@ -472,13 +668,23 @@ export class SharedDirectory extends SharedObject {
                     parentSubdir.resubmitSubDirectoryMessage(op, localOpMetadata);
                 }
             },
+            applyStashedOp: (op) => {
+                const parentSubdir = this.getWorkingDirectory(op.path);
+                if (parentSubdir) {
+                    return parentSubdir.applyStashedDeleteSubDirMessage(op);
+                }
+            },
         });
     }
     /**
-     * @internal
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
      */
-    applyStashedOp() {
-        throw new Error("not implemented");
+    applyStashedOp(op) {
+        const handler = this.messageHandlers.get(op.type);
+        if (handler === undefined) {
+            throw new Error("no apply stashed op handler");
+        }
+        return handler.applyStashedOp(op);
     }
     serializeDirectory(root, serializer, telemetryContext) {
         const MinValueSizeSeparateSnapshotBlob = 8 * 1024;
@@ -491,20 +697,21 @@ export class SharedDirectory extends SharedObject {
         while (stack.length > 0) {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const [currentSubDir, currentSubDirObject] = stack.pop();
+            currentSubDirObject.ci = currentSubDir.getSerializableCreateInfo();
             for (const [key, value] of currentSubDir.getSerializedStorage(serializer)) {
                 if (!currentSubDirObject.storage) {
                     currentSubDirObject.storage = {};
                 }
+                // eslint-disable-next-line import/no-deprecated
                 const result = {
                     type: value.type,
-                    // eslint-disable-next-line @typescript-eslint/ban-types
                     value: value.value && JSON.parse(value.value),
                 };
                 if (value.value && value.value.length >= MinValueSizeSeparateSnapshotBlob) {
                     const extraContent = {};
                     let largeContent = extraContent;
                     if (currentSubDir.absolutePath !== posix.sep) {
-                        for (const dir of currentSubDir.absolutePath.substr(1).split(posix.sep)) {
+                        for (const dir of currentSubDir.absolutePath.slice(1).split(posix.sep)) {
                             const subDataObject = {};
                             largeContent.subdirectories = { [dir]: subDataObject };
                             largeContent = subDataObject;
@@ -537,23 +744,30 @@ export class SharedDirectory extends SharedObject {
         return builder.getSummaryTree();
     }
 }
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */
 function isKeyEditLocalOpMetadata(metadata) {
-    return metadata !== undefined && typeof metadata.pendingMessageId === "number" && metadata.type === "edit";
+    return (metadata !== undefined &&
+        typeof metadata.pendingMessageId === "number" &&
+        metadata.type === "edit");
 }
 function isClearLocalOpMetadata(metadata) {
-    return metadata !== undefined && metadata.type === "clear" && typeof metadata.pendingMessageId === "number" &&
-        typeof metadata.previousStorage === "object";
+    return (metadata !== undefined &&
+        metadata.type === "clear" &&
+        typeof metadata.pendingMessageId === "number" &&
+        typeof metadata.previousStorage === "object");
 }
 function isSubDirLocalOpMetadata(metadata) {
-    return metadata !== undefined && typeof metadata.pendingMessageId === "number" &&
-        ((metadata.type === "createSubDir" && typeof metadata.previouslyExisted === "boolean") ||
-            metadata.type === "deleteSubDir");
+    return (metadata !== undefined &&
+        (metadata.type === "createSubDir" || metadata.type === "deleteSubDir"));
 }
 function isDirectoryLocalOpMetadata(metadata) {
-    return metadata !== undefined && typeof metadata.pendingMessageId === "number" &&
-        (metadata.type === "edit" || metadata.type === "deleteSubDir" ||
-            (metadata.type === "clear" && typeof metadata.previousStorage === "object") ||
-            (metadata.type === "createSubDir" && typeof metadata.previouslyExisted === "boolean"));
+    return (isKeyEditLocalOpMetadata(metadata) ||
+        isClearLocalOpMetadata(metadata) ||
+        isSubDirLocalOpMetadata(metadata));
+}
+/* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */
+function assertNonNullClientId(clientId) {
+    assert(clientId !== null, 0x6af /* client id should never be null */);
 }
 /**
  * Node of the directory tree.
@@ -562,13 +776,17 @@ function isDirectoryLocalOpMetadata(metadata) {
 class SubDirectory extends TypedEventEmitter {
     /**
      * Constructor.
+     * @param sequenceNumber - Message seq number at which this was created.
+     * @param clientIds - Ids of client which created this directory.
      * @param directory - Reference back to the SharedDirectory to perform operations
      * @param runtime - The data store runtime this directory is associated with
      * @param serializer - The serializer to serialize / parse handles
      * @param absolutePath - The absolute path of this IDirectory
      */
-    constructor(directory, runtime, serializer, absolutePath) {
+    constructor(seqData, clientIds, directory, runtime, serializer, absolutePath) {
         super();
+        this.seqData = seqData;
+        this.clientIds = clientIds;
         this.directory = directory;
         this.runtime = runtime;
         this.serializer = serializer;
@@ -590,13 +808,24 @@ class SubDirectory extends TypedEventEmitter {
          */
         this._subdirectories = new Map();
         /**
-         * Keys that have been modified locally but not yet ack'd from the server.
+         * Keys that have been modified locally but not yet ack'd from the server. This is for operations on keys like
+         * set/delete operations on keys. The value of this map is list of pendingMessageIds at which that key
+         * was modified. We don't store the type of ops, and behaviour of key ops are different from behaviour of sub
+         * directory ops, so we have separate map from subDirectories tracker.
          */
         this.pendingKeys = new Map();
         /**
-         * Subdirectories that have been modified locally but not yet ack'd from the server.
+         * Subdirectories that have been deleted locally but not yet ack'd from the server. This maintains the record
+         * of delete op that are pending or yet to be acked from server. This is maintained just to track the locally
+         * deleted sub directory.
+         */
+        this.pendingDeleteSubDirectoriesTracker = new Map();
+        /**
+         * Subdirectories that have been created locally but not yet ack'd from the server. This maintains the record
+         * of create op that are pending or yet to be acked from server. This is maintained just to track the locally
+         * created sub directory.
          */
-        this.pendingSubDirectories = new Map();
+        this.pendingCreateSubDirectoriesTracker = new Map();
         /**
          * This is used to assign a unique id to every outgoing operation and helps in tracking unack'd ops.
          */
@@ -605,16 +834,24 @@ class SubDirectory extends TypedEventEmitter {
          * The pending ids of any clears that have been performed locally but not yet ack'd from the server
          */
         this.pendingClearMessageIds = [];
+        /**
+         * Assigns a unique ID to each subdirectory created locally but pending for acknowledgement, facilitating the tracking
+         * of the creation order.
+         */
+        this.localCreationSeq = 0;
+        this.localCreationSeqTracker = new DirectoryCreationTracker();
+        this.ackedCreationSeqTracker = new DirectoryCreationTracker();
     }
     dispose(error) {
         this._deleted = true;
         this.emit("disposed", this);
     }
     /**
-     * Unmark the deleted property when rolling back delete.
+     * Unmark the deleted property only when rolling back delete.
      */
     undispose() {
         this._deleted = false;
+        this.emit("undisposed", this);
     }
     get disposed() {
         return this._deleted;
@@ -637,9 +874,8 @@ class SubDirectory extends TypedEventEmitter {
      * {@inheritDoc IDirectory.get}
      */
     get(key) {
-        var _c;
         this.throwIfDisposed();
-        return (_c = this._storage.get(key)) === null || _c === void 0 ? void 0 : _c.value;
+        return this._storage.get(key)?.value;
     }
     /**
      * {@inheritDoc IDirectory.set}
@@ -687,21 +923,38 @@ class SubDirectory extends TypedEventEmitter {
             throw new Error(`SubDirectory name may not contain ${posix.sep}`);
         }
         // Create the sub directory locally first.
-        const isNew = this.createSubDirectoryCore(subdirName, true);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const isNew = this.createSubDirectoryCore(subdirName, true, this.getLocalSeq(), this.runtime.clientId ?? "detached");
         const subDir = this._subdirectories.get(subdirName);
+        assert(subDir !== undefined, 0x5aa /* subdirectory should exist after creation */);
         // If we are not attached, don't submit the op.
         if (!this.directory.isAttached()) {
             return subDir;
         }
-        const op = {
-            path: this.absolutePath,
-            subdirName,
-            type: "createSubDirectory",
-        };
-        this.submitCreateSubDirectoryMessage(op, !isNew);
+        // Only submit the op, if it is newly created.
+        if (isNew) {
+            const op = {
+                path: this.absolutePath,
+                subdirName,
+                type: "createSubDirectory",
+            };
+            this.submitCreateSubDirectoryMessage(op);
+        }
         return subDir;
     }
+    /**
+     * @returns 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.
+     */
+    getLocalSeq() {
+        return this.directory.isAttached()
+            ? { seq: -1, clientSeq: ++this.localCreationSeq }
+            : { seq: 0, clientSeq: ++this.localCreationSeq };
+    }
     /**
      * {@inheritDoc IDirectory.getSubDirectory}
      */
@@ -727,12 +980,15 @@ class SubDirectory extends TypedEventEmitter {
         if (!this.directory.isAttached()) {
             return subDir !== undefined;
         }
-        const op = {
-            path: this.absolutePath,
-            subdirName,
-            type: "deleteSubDirectory",
-        };
-        this.submitDeleteSubDirectoryMessage(op, subDir);
+        // Only submit the op, if the directory existed and we deleted it.
+        if (subDir !== undefined) {
+            const op = {
+                path: this.absolutePath,
+                subdirName,
+                type: "deleteSubDirectory",
+            };
+            this.submitDeleteSubDirectoryMessage(op, subDir);
+        }
         return subDir !== undefined;
     }
     /**
@@ -740,7 +996,26 @@ class SubDirectory extends TypedEventEmitter {
      */
     subdirectories() {
         this.throwIfDisposed();
-        return this._subdirectories.entries();
+        const ackedSubdirsInOrder = this.ackedCreationSeqTracker.keys();
+        const localSubdirsInOrder = this.localCreationSeqTracker.keys((key) => !this.ackedCreationSeqTracker.has(key));
+        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 */);
+        const entriesIterator = {
+            index: 0,
+            dirs: this._subdirectories,
+            next() {
+                if (this.index < subdirNames.length) {
+                    const subdirName = subdirNames[this.index++];
+                    const subdir = this.dirs.get(subdirName);
+                    return { value: [subdirName, subdir], done: false };
+                }
+                return { value: undefined, done: true };
+            },
+            [Symbol.iterator]() {
+                return this;
+            },
+        };
+        return entriesIterator;
     }
     /**
      * {@inheritDoc IDirectory.getWorkingDirectory}
@@ -749,6 +1024,17 @@ class SubDirectory extends TypedEventEmitter {
         this.throwIfDisposed();
         return this.directory.getWorkingDirectory(this.makeAbsolute(relativePath));
     }
+    /**
+     * This checks if there is pending delete op for local delete for a given child subdirectory.
+     * @param subDirName - directory name.
+     * @returns true if there is pending delete.
+     */
+    isSubDirectoryDeletePending(subDirName) {
+        if (this.pendingDeleteSubDirectoriesTracker.has(subDirName)) {
+            return true;
+        }
+        return false;
+    }
     /**
      * Deletes the given key from within this IDirectory.
      * @param key - The key to delete
@@ -794,6 +1080,7 @@ class SubDirectory extends TypedEventEmitter {
      */
     forEach(callback) {
         this.throwIfDisposed();
+        // eslint-disable-next-line unicorn/no-array-for-each
         this._storage.forEach((localValue, key, map) => {
             callback(localValue.value, key, map);
         });
@@ -815,13 +1102,9 @@ class SubDirectory extends TypedEventEmitter {
         const iterator = {
             next() {
                 const nextVal = localEntriesIterator.next();
-                if (nextVal.done) {
-                    return { value: undefined, done: true };
-                }
-                else {
-                    // Unpack the stored value
-                    return { value: [nextVal.value[0], nextVal.value[1].value], done: false };
-                }
+                return nextVal.done
+                    ? { value: undefined, done: true }
+                    : { value: [nextVal.value[0], nextVal.value[1].value], done: false };
             },
             [Symbol.iterator]() {
                 return this;
@@ -847,13 +1130,9 @@ class SubDirectory extends TypedEventEmitter {
         const iterator = {
             next() {
                 const nextVal = localValuesIterator.next();
-                if (nextVal.done) {
-                    return { value: undefined, done: true };
-                }
-                else {
-                    // Unpack the stored value
-                    return { value: nextVal.value.value, done: false };
-                }
+                return nextVal.done
+                    ? { value: undefined, done: true }
+                    : { value: nextVal.value.value, done: false };
             },
             [Symbol.iterator]() {
                 return this;
@@ -871,48 +1150,90 @@ class SubDirectory extends TypedEventEmitter {
     }
     /**
      * Process a clear operation.
+     * @param msg - The message from the server to apply.
      * @param op - The op to process
      * @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(op, local, localOpMetadata) {
+    processClearMessage(msg, op, local, localOpMetadata) {
         this.throwIfDisposed();
+        if (!this.isMessageForCurrentInstanceOfSubDirectory(msg)) {
+            return;
+        }
         if (local) {
             assert(isClearLocalOpMetadata(localOpMetadata), 0x00f /* pendingMessageId is missing from the local client's operation */);
             const pendingClearMessageId = this.pendingClearMessageIds.shift();
             assert(pendingClearMessageId === localOpMetadata.pendingMessageId, 0x32a /* pendingMessageId does not match */);
             return;
         }
-        this.clearExceptPendingKeys();
+        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.
      * @param op - The op to process
      * @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(op, local, localOpMetadata) {
+    processDeleteMessage(msg, op, local, localOpMetadata) {
         this.throwIfDisposed();
-        if (!this.needProcessStorageOperation(op, local, localOpMetadata)) {
+        if (!(this.isMessageForCurrentInstanceOfSubDirectory(msg) &&
+            this.needProcessStorageOperation(op, local, localOpMetadata))) {
             return;
         }
         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.
      * @param op - The op to process
      * @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(op, context, local, localOpMetadata) {
+    processSetMessage(msg, op, context, local, localOpMetadata) {
         this.throwIfDisposed();
-        if (!this.needProcessStorageOperation(op, local, localOpMetadata)) {
+        if (!(this.isMessageForCurrentInstanceOfSubDirectory(msg) &&
+            this.needProcessStorageOperation(op, local, localOpMetadata))) {
             return;
         }
         // needProcessStorageOperation should have returned false if local is true
@@ -920,36 +1241,89 @@ class SubDirectory extends 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.
      * @param op - The op to process
      * @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(op, local, localOpMetadata) {
+    processCreateSubDirectoryMessage(msg, op, local, localOpMetadata) {
         this.throwIfDisposed();
-        if (!this.needProcessSubDirectoryOperation(op, local, localOpMetadata)) {
+        if (!(this.isMessageForCurrentInstanceOfSubDirectory(msg) &&
+            this.needProcessSubDirectoryOperation(msg, op, local, localOpMetadata))) {
             return;
         }
-        this.createSubDirectoryCore(op.subdirName, local);
+        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.
      * @param op - The op to process
      * @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(op, local, localOpMetadata) {
+    processDeleteSubDirectoryMessage(msg, op, local, localOpMetadata) {
         this.throwIfDisposed();
-        if (!this.needProcessSubDirectoryOperation(op, local, localOpMetadata)) {
+        if (!(this.isMessageForCurrentInstanceOfSubDirectory(msg) &&
+            this.needProcessSubDirectoryOperation(msg, op, local, localOpMetadata))) {
             return;
         }
         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
@@ -974,8 +1348,11 @@ class SubDirectory extends TypedEventEmitter {
         assert(isClearLocalOpMetadata(localOpMetadata), 0x32b /* Invalid localOpMetadata for clear */);
         // We don't reuse the metadata pendingMessageId but send a new one on each submit.
         const pendingClearMessageId = this.pendingClearMessageIds.shift();
-        assert(pendingClearMessageId === localOpMetadata.pendingMessageId, 0x32c /* pendingMessageId does not match */);
-        this.submitClearMessage(op, localOpMetadata.previousStorage);
+        // 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 (pendingClearMessageId === localOpMetadata.pendingMessageId) {
+            this.submitClearMessage(op, localOpMetadata.previousStorage);
+        }
     }
     /**
      * Get a new pending message id for the op and cache it to track the pending op
@@ -1013,40 +1390,52 @@ class SubDirectory extends TypedEventEmitter {
         assert(isKeyEditLocalOpMetadata(localOpMetadata), 0x32d /* Invalid localOpMetadata in submit */);
         // clear the old pending message id
         const pendingMessageIds = this.pendingKeys.get(op.key);
-        assert(pendingMessageIds !== undefined && pendingMessageIds[0] === localOpMetadata.pendingMessageId, 0x32e /* Unexpected pending message received */);
-        pendingMessageIds.shift();
-        if (pendingMessageIds.length === 0) {
-            this.pendingKeys.delete(op.key);
+        // 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);
+            if (index === -1) {
+                return;
+            }
+            pendingMessageIds.splice(index, 1);
+            if (pendingMessageIds.length === 0) {
+                this.pendingKeys.delete(op.key);
+            }
+            this.submitKeyMessage(op, localOpMetadata.previousValue);
+        }
+    }
+    incrementPendingSubDirCount(map, subDirName) {
+        const count = map.get(subDirName) ?? 0;
+        map.set(subDirName, count + 1);
+    }
+    decrementPendingSubDirCount(map, subDirName) {
+        const count = map.get(subDirName) ?? 0;
+        map.set(subDirName, count - 1);
+        if (count <= 1) {
+            map.delete(subDirName);
         }
-        this.submitKeyMessage(op, localOpMetadata.previousValue);
     }
     /**
-     * Get a new pending message id for the op and cache it to track the pending op
+     * 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.
      */
-    getSubDirMessageId(op) {
-        // We don't reuse the metadata pendingMessageId but send a new one on each submit.
-        const newMessageId = ++this.pendingMessageId;
-        const pendingMessageIds = this.pendingSubDirectories.get(op.subdirName);
-        if (pendingMessageIds !== undefined) {
-            pendingMessageIds.push(newMessageId);
+    updatePendingSubDirMessageCount(op) {
+        if (op.type === "deleteSubDirectory") {
+            this.incrementPendingSubDirCount(this.pendingDeleteSubDirectoriesTracker, op.subdirName);
         }
-        else {
-            this.pendingSubDirectories.set(op.subdirName, [newMessageId]);
+        else if (op.type === "createSubDirectory") {
+            this.incrementPendingSubDirCount(this.pendingCreateSubDirectoriesTracker, op.subdirName);
         }
-        return newMessageId;
     }
     /**
      * Submit a create subdirectory operation.
      * @param op - The operation
-     * @param prevExisted - Whether the subdirectory existed before the op
      */
-    submitCreateSubDirectoryMessage(op, prevExisted) {
+    submitCreateSubDirectoryMessage(op) {
         this.throwIfDisposed();
-        const newMessageId = this.getSubDirMessageId(op);
+        this.updatePendingSubDirMessageCount(op);
         const localOpMetadata = {
             type: "createSubDir",
-            pendingMessageId: newMessageId,
-            previouslyExisted: prevExisted,
         };
         this.directory.submitDirectoryMessage(op, localOpMetadata);
     }
@@ -1057,10 +1446,9 @@ class SubDirectory extends TypedEventEmitter {
      */
     submitDeleteSubDirectoryMessage(op, subDir) {
         this.throwIfDisposed();
-        const newMessageId = this.getSubDirMessageId(op);
+        this.updatePendingSubDirMessageCount(op);
         const localOpMetadata = {
             type: "deleteSubDir",
-            pendingMessageId: newMessageId,
             subDirectory: subDir,
         };
         this.directory.submitDirectoryMessage(op, localOpMetadata);
@@ -1073,17 +1461,22 @@ class SubDirectory extends TypedEventEmitter {
      */
     resubmitSubDirectoryMessage(op, localOpMetadata) {
         assert(isSubDirLocalOpMetadata(localOpMetadata), 0x32f /* Invalid localOpMetadata for sub directory op */);
-        // clear the old pending message id
-        const pendingMessageIds = this.pendingSubDirectories.get(op.subdirName);
-        assert(pendingMessageIds !== undefined && pendingMessageIds[0] === localOpMetadata.pendingMessageId, 0x330 /* Unexpected pending message received */);
-        pendingMessageIds.shift();
-        if (pendingMessageIds.length === 0) {
-            this.pendingSubDirectories.delete(op.subdirName);
+        // 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 (localOpMetadata.type === "createSubDir" &&
+            !this.pendingCreateSubDirectoriesTracker.has(op.subdirName)) {
+            return;
+        }
+        else if (localOpMetadata.type === "deleteSubDir" &&
+            !this.pendingDeleteSubDirectoriesTracker.has(op.subdirName)) {
+            return;
         }
         if (localOpMetadata.type === "createSubDir") {
-            this.submitCreateSubDirectoryMessage(op, localOpMetadata.previouslyExisted);
+            this.decrementPendingSubDirCount(this.pendingCreateSubDirectoriesTracker, op.subdirName);
+            this.submitCreateSubDirectoryMessage(op);
         }
         else {
+            this.decrementPendingSubDirCount(this.pendingDeleteSubDirectoriesTracker, op.subdirName);
             this.submitDeleteSubDirectoryMessage(op, localOpMetadata.subDirectory);
         }
     }
@@ -1101,6 +1494,14 @@ class SubDirectory extends TypedEventEmitter {
             yield res;
         }
     }
+    getSerializableCreateInfo() {
+        this.throwIfDisposed();
+        const createInfo = {
+            csn: this.seqData.seq,
+            ccIds: Array.from(this.clientIds),
+        };
+        return createInfo;
+    }
     /**
      * Populate a key value in this subdirectory's storage, to be used when loading from snapshot.
      * @param key - The key to populate
@@ -1139,7 +1540,7 @@ class SubDirectory extends TypedEventEmitter {
      */
     rollbackPendingMessageId(map, key, pendingMessageId) {
         const pendingMessageIds = map.get(key);
-        const lastPendingMessageId = pendingMessageIds === null || pendingMessageIds === void 0 ? void 0 : pendingMessageIds.pop();
+        const lastPendingMessageId = pendingMessageIds?.pop();
         if (!pendingMessageIds || lastPendingMessageId !== pendingMessageId) {
             throw new Error("Rollback op does not match last pending");
         }
@@ -1147,21 +1548,24 @@ class SubDirectory extends TypedEventEmitter {
             map.delete(key);
         }
     }
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
     /**
      * Rollback a local op
      * @param op - The operation to rollback
      * @param localOpMetadata - The local metadata associated with the op.
      */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     rollback(op, localOpMetadata) {
         if (!isDirectoryLocalOpMetadata(localOpMetadata)) {
             throw new Error("Invalid localOpMetadata");
         }
         if (op.type === "clear" && localOpMetadata.type === "clear") {
-            localOpMetadata.previousStorage.forEach((localValue, key) => {
+            for (const [key, localValue] of localOpMetadata.previousStorage.entries()) {
                 this.setCore(key, localValue, true);
-            });
+            }
             const lastPendingClearId = this.pendingClearMessageIds.pop();
-            if (lastPendingClearId === undefined || lastPendingClearId !== localOpMetadata.pendingMessageId) {
+            if (lastPendingClearId === undefined ||
+                lastPendingClearId !== localOpMetadata.pendingMessageId) {
                 throw new Error("Rollback op does match last clear");
             }
         }
@@ -1175,24 +1579,34 @@ class SubDirectory extends TypedEventEmitter {
             this.rollbackPendingMessageId(this.pendingKeys, op.key, localOpMetadata.pendingMessageId);
         }
         else if (op.type === "createSubDirectory" && localOpMetadata.type === "createSubDir") {
-            if (!localOpMetadata.previouslyExisted) {
-                this.deleteSubDirectoryCore(op.subdirName, true);
-            }
-            this.rollbackPendingMessageId(this.pendingSubDirectories, op.subdirName, localOpMetadata.pendingMessageId);
+            this.deleteSubDirectoryCore(op.subdirName, true);
+            this.decrementPendingSubDirCount(this.pendingCreateSubDirectoriesTracker, op.subdirName);
         }
         else if (op.type === "deleteSubDirectory" && localOpMetadata.type === "deleteSubDir") {
             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);
+                // Restore the record in creation tracker
+                if (isAcknowledgedOrDetached(localOpMetadata.subDirectory.seqData)) {
+                    this.ackedCreationSeqTracker.set(op.subdirName, {
+                        ...localOpMetadata.subDirectory.seqData,
+                    });
+                }
+                else {
+                    this.localCreationSeqTracker.set(op.subdirName, {
+                        ...localOpMetadata.subDirectory.seqData,
+                    });
+                }
                 this.emit("subDirectoryCreated", op.subdirName, true, this);
             }
-            this.rollbackPendingMessageId(this.pendingSubDirectories, op.subdirName, localOpMetadata.pendingMessageId);
+            this.decrementPendingSubDirCount(this.pendingDeleteSubDirectoriesTracker, op.subDirName);
         }
         else {
             throw new Error("Unsupported op for rollback");
         }
     }
+    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
     /**
      * Converts the given relative path into an absolute path.
      * @param path - Relative path to convert
@@ -1213,22 +1627,38 @@ class SubDirectory extends TypedEventEmitter {
     needProcessStorageOperation(op, local, localOpMetadata) {
         if (this.pendingClearMessageIds.length > 0) {
             if (local) {
-                assert(localOpMetadata !== undefined && isKeyEditLocalOpMetadata(localOpMetadata) &&
+                assert(localOpMetadata !== undefined &&
+                    isKeyEditLocalOpMetadata(localOpMetadata) &&
                     localOpMetadata.pendingMessageId < this.pendingClearMessageIds[0], 0x010 /* "Received out of order storage op when there is an unackd clear message" */);
+                // Remove all pendingMessageIds lower than first pendingClearMessageId.
+                const lowestPendingClearMessageId = this.pendingClearMessageIds[0];
+                const pendingKeyMessageIdArray = this.pendingKeys.get(op.key);
+                if (pendingKeyMessageIdArray !== undefined) {
+                    let index = 0;
+                    while (pendingKeyMessageIdArray[index] < lowestPendingClearMessageId) {
+                        index += 1;
+                    }
+                    const newPendingKeyMessageId = pendingKeyMessageIdArray.splice(index);
+                    if (newPendingKeyMessageId.length === 0) {
+                        this.pendingKeys.delete(op.key);
+                    }
+                    else {
+                        this.pendingKeys.set(op.key, newPendingKeyMessageId);
+                    }
+                }
             }
             // If I have a NACK clear, we can ignore all ops.
             return false;
         }
-        const pendingKeyMessageId = this.pendingKeys.get(op.key);
-        if (pendingKeyMessageId !== undefined) {
+        const pendingKeyMessageIds = this.pendingKeys.get(op.key);
+        if (pendingKeyMessageIds !== undefined) {
             // Found an NACK op, clear it from the directory if the latest sequence number in the directory
             // match the message's and don't process the op.
             if (local) {
                 assert(localOpMetadata !== undefined && isKeyEditLocalOpMetadata(localOpMetadata), 0x011 /* pendingMessageId is missing from the local client's operation */);
-                const pendingMessageIds = this.pendingKeys.get(op.key);
-                assert(pendingMessageIds !== undefined && pendingMessageIds[0] === localOpMetadata.pendingMessageId, 0x331 /* Unexpected pending message received */);
-                pendingMessageIds.shift();
-                if (pendingMessageIds.length === 0) {
+                assert(pendingKeyMessageIds[0] === localOpMetadata.pendingMessageId, 0x331 /* Unexpected pending message received */);
+                pendingKeyMessageIds.shift();
+                if (pendingKeyMessageIds.length === 0) {
                     this.pendingKeys.delete(op.key);
                 }
             }
@@ -1237,6 +1667,19 @@ class SubDirectory extends TypedEventEmitter {
         // If we don't have a NACK op on the key, we need to process the remote ops.
         return !local;
     }
+    /**
+     * This return true if the message is for the current instance of this sub directory. As the sub directory
+     * 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
+     */
+    isMessageForCurrentInstanceOfSubDirectory(msg) {
+        // 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.
+        return ((msg.clientId !== null && this.clientIds.has(msg.clientId)) ||
+            this.clientIds.has("detached") ||
+            (this.seqData.seq !== -1 && this.seqData.seq <= msg.referenceSequenceNumber));
+    }
     /**
      * If our local operations that have not yet been ack'd will eventually overwrite an incoming operation, we should
      * not process the incoming operation.
@@ -1247,16 +1690,80 @@ class SubDirectory extends TypedEventEmitter {
      * For messages from a remote client, this will be undefined.
      * @returns True if the operation should be processed, false otherwise
      */
-    needProcessSubDirectoryOperation(op, local, localOpMetadata) {
-        const pendingSubDirectoryMessageId = this.pendingSubDirectories.get(op.subdirName);
-        if (pendingSubDirectoryMessageId !== undefined) {
+    needProcessSubDirectoryOperation(msg, op, local, localOpMetadata) {
+        assertNonNullClientId(msg.clientId);
+        const pendingDeleteCount = this.pendingDeleteSubDirectoriesTracker.get(op.subdirName);
+        const pendingCreateCount = this.pendingCreateSubDirectoriesTracker.get(op.subdirName);
+        if ((pendingDeleteCount !== undefined && pendingDeleteCount > 0) ||
+            (pendingCreateCount !== undefined && pendingCreateCount > 0)) {
             if (local) {
                 assert(isSubDirLocalOpMetadata(localOpMetadata), 0x012 /* pendingMessageId is missing from the local client's operation */);
-                const pendingMessageIds = this.pendingSubDirectories.get(op.subdirName);
-                assert(pendingMessageIds !== undefined && pendingMessageIds[0] === localOpMetadata.pendingMessageId, 0x332 /* Unexpected pending message received */);
-                pendingMessageIds.shift();
-                if (pendingMessageIds.length === 0) {
-                    this.pendingSubDirectories.delete(op.subdirName);
+                if (localOpMetadata.type === "deleteSubDir") {
+                    assert(pendingDeleteCount !== undefined && pendingDeleteCount > 0, 0x6c2 /* pendingDeleteCount should exist */);
+                    this.decrementPendingSubDirCount(this.pendingDeleteSubDirectoriesTracker, op.subdirName);
+                }
+                else if (localOpMetadata.type === "createSubDir") {
+                    assert(pendingCreateCount !== undefined && pendingCreateCount > 0, 0x6c3 /* pendingCreateCount should exist */);
+                    this.decrementPendingSubDirCount(this.pendingCreateSubDirectoriesTracker, op.subdirName);
+                }
+            }
+            if (op.type === "deleteSubDirectory") {
+                const resetSubDirectoryTree = (directory) => {
+                    if (!directory) {
+                        return;
+                    }
+                    // If this is delete op and we have keys in this subDirectory, then we need to delete these
+                    // keys except the pending ones as they will be sequenced after this delete.
+                    directory.clearExceptPendingKeys(local);
+                    // In case of delete op, we need to reset the creation seqNum, clientSeqNum and client ids of
+                    // creators as the previous directory is getting deleted and we will initialize again when
+                    // we will receive op for the create again.
+                    directory.seqData.seq = -1;
+                    directory.seqData.clientSeq = -1;
+                    directory.clientIds.clear();
+                    // Do the same thing for the subtree of the directory. If create is not pending for a child, then just
+                    // delete it.
+                    const subDirectories = directory.subdirectories();
+                    for (const [subDirName, subDir] of subDirectories) {
+                        if (directory.pendingCreateSubDirectoriesTracker.has(subDirName)) {
+                            resetSubDirectoryTree(subDir);
+                            continue;
+                        }
+                        directory.deleteSubDirectoryCore(subDirName, false);
+                    }
+                };
+                const subDirectory = this._subdirectories.get(op.subdirName);
+                // Clear the creation tracker record
+                this.ackedCreationSeqTracker.delete(op.subdirName);
+                resetSubDirectoryTree(subDirectory);
+            }
+            if (op.type === "createSubDirectory") {
+                const dir = this._subdirectories.get(op.subdirName);
+                // Child sub directory create seq number can't be lower than the parent subdirectory.
+                // The sequence number for multiple ops can be the same when multiple createSubDirectory occurs with grouped batching enabled, thus <= and not just <.
+                if (this.seqData.seq !== -1 && this.seqData.seq <= msg.sequenceNumber) {
+                    if (dir?.seqData.seq === -1) {
+                        // Only set the sequence data based on the first message
+                        dir.seqData.seq = msg.sequenceNumber;
+                        dir.seqData.clientSeq = msg.clientSequenceNumber;
+                        // set the creation seq in tracker
+                        if (!this.ackedCreationSeqTracker.has(op.subdirName) &&
+                            !this.pendingDeleteSubDirectoriesTracker.has(op.subdirName)) {
+                            this.ackedCreationSeqTracker.set(op.subdirName, {
+                                seq: msg.sequenceNumber,
+                                clientSeq: msg.clientSequenceNumber,
+                            });
+                            if (local) {
+                                this.localCreationSeqTracker.delete(op.subdirName);
+                            }
+                        }
+                    }
+                    // The client created the dir at or after the dirs seq, so list its client id as a creator.
+                    if (dir !== undefined &&
+                        !dir.clientIds.has(msg.clientId) &&
+                        dir.seqData.seq <= msg.sequenceNumber) {
+                        dir.clientIds.add(msg.clientId);
+                    }
                 }
             }
             return false;
@@ -1266,18 +1773,21 @@ class SubDirectory extends TypedEventEmitter {
     /**
      * Clear all keys in memory in response to a remote clear, but retain keys we have modified but not yet been ack'd.
      */
-    clearExceptPendingKeys() {
+    clearExceptPendingKeys(local) {
         // Assuming the pendingKeys is small and the map is large
         // we will get the value for the pendingKeys and clear the map
         const temp = new Map();
-        this.pendingKeys.forEach((value, key, map) => {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            temp.set(key, this._storage.get(key));
-        });
-        this.clearCore(false);
-        temp.forEach((value, key, map) => {
+        for (const [key] of this.pendingKeys) {
+            const value = this._storage.get(key);
+            // If this key is already deleted, then we don't need to add it again.
+            if (value !== undefined) {
+                temp.set(key, value);
+            }
+        }
+        this.clearCore(local);
+        for (const [key, value] of temp.entries()) {
             this.setCore(key, value, true);
-        });
+        }
     }
     /**
      * Clear implementation used for both locally sourced clears as well as incoming remote clears.
@@ -1295,7 +1805,7 @@ class SubDirectory extends TypedEventEmitter {
      */
     deleteCore(key, local) {
         const previousLocalValue = this._storage.get(key);
-        const previousValue = previousLocalValue === null || previousLocalValue === void 0 ? void 0 : previousLocalValue.value;
+        const previousValue = previousLocalValue?.value;
         const successfullyRemoved = this._storage.delete(key);
         if (successfullyRemoved) {
             const event = { key, path: this.absolutePath, previousValue };
@@ -1314,7 +1824,7 @@ class SubDirectory extends TypedEventEmitter {
      */
     setCore(key, value, local) {
         const previousLocalValue = this._storage.get(key);
-        const previousValue = previousLocalValue === null || previousLocalValue === void 0 ? void 0 : previousLocalValue.value;
+        const previousValue = previousLocalValue?.value;
         this._storage.set(key, value);
         const event = { key, path: this.absolutePath, previousValue };
         this.directory.emit("valueChanged", event, local, this.directory);
@@ -1326,17 +1836,33 @@ class SubDirectory extends TypedEventEmitter {
      * Create subdirectory implementation used for both locally sourced creation as well as incoming remote creation.
      * @param subdirName - The name of the subdirectory being created
      * @param local - Whether the message originated from the local client
-     * @returns - True if is newly created, false if it already existed.
+     * @param seqData - Sequence number and client sequence number at which this directory is created
+     * @param clientId - Id of client which created this directory.
+     * @returns True if is newly created, false if it already existed.
      */
-    createSubDirectoryCore(subdirName, local) {
-        if (!this._subdirectories.has(subdirName)) {
+    createSubDirectoryCore(subdirName, local, seqData, clientId) {
+        const subdir = this._subdirectories.get(subdirName);
+        if (subdir === undefined) {
             const absolutePath = posix.join(this.absolutePath, subdirName);
-            const subDir = new SubDirectory(this.directory, this.runtime, this.serializer, absolutePath);
+            const subDir = new SubDirectory({ ...seqData }, new Set([clientId]), this.directory, this.runtime, this.serializer, absolutePath);
+            /**
+             * 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 {
+                this.ackedCreationSeqTracker.set(subdirName, { ...seqData });
+            }
             this.registerEventsOnSubDirectory(subDir, subdirName);
             this._subdirectories.set(subdirName, subDir);
             this.emit("subDirectoryCreated", subdirName, local, this);
             return true;
         }
+        else {
+            subdir.clientIds.add(clientId);
+        }
         return false;
     }
     registerEventsOnSubDirectory(subDirectory, subDirName) {
@@ -1358,6 +1884,16 @@ class SubDirectory extends TypedEventEmitter {
         // Might want to consider cleaning out the structure more exhaustively though? But not when rollback.
         if (previousValue !== undefined) {
             this._subdirectories.delete(subdirName);
+            /**
+             * Remove the corresponding record from the proper creation tracker, based on whether the subdirectory has been
+             * ack'd already or still not committed yet (could be both).
+             */
+            if (this.ackedCreationSeqTracker.has(subdirName)) {
+                this.ackedCreationSeqTracker.delete(subdirName);
+            }
+            if (this.localCreationSeqTracker.has(subdirName)) {
+                this.localCreationSeqTracker.delete(subdirName);
+            }
             this.disposeSubDirectoryTree(previousValue);
             this.emit("subDirectoryDeleted", subdirName, local, this);
         }
@@ -1377,11 +1913,12 @@ class SubDirectory extends TypedEventEmitter {
         }
     }
     undeleteSubDirectoryTree(directory) {
-        // Restore deleted subdirectory tree. This will unmark "deleted" from the subdirectories from bottom to top.
-        for (const [_, subDirectory] of this._subdirectories.entries()) {
+        // Restore deleted subdirectory tree. Need to undispose the current directory first, then get access to the iterator.
+        // This will unmark "deleted" from the subdirectories from top to bottom.
+        directory.undispose();
+        for (const [_, subDirectory] of directory.subdirectories()) {
             this.undeleteSubDirectoryTree(subDirectory);
         }
-        directory.undispose();
     }
 }
-//# sourceMappingURL=directory.js.map
+//# sourceMappingURL=directory.mjs.map