@cr_docs_t/dts 0.24.0 → 0.26.0

package/dist/dts/FugueTree/FugueTree.js

@@ -0,0 +1,351 @@
+import { Operation } from "../../types/FugueTree/Message.js";
+import { randomString } from "../../utils/index.js";
+import { FugueMessageSerialzier } from "../Serailizers/FugueTree/index.js";
+import { FTree } from "./FTree.js";
+/**
+ * A Fugue Tree CRDT, with insert and delete operations.
+ */
+export class FugueTree {
+    constructor(ws, documentID, userIdentity) {
+        this.counter = 0;
+        this.replicaID = randomString(3);
+        this.pendingMsgs = new Map();
+        // Tentative
+        this.batchSize = 100;
+        this.ws = ws;
+        this.documentID = documentID;
+        this.userIdentity = userIdentity;
+        this.tree = new FTree();
+    }
+    /**
+     * Make msg key for pending messages map
+     * @param msg - the message to make key for
+     * @returns the key for the message in pending messages map
+     */
+    makeMsgKey(msg) {
+        return `${msg.replicaId}-${msg.id.counter}`;
+    }
+    /**
+     * Propagates message or messages to replicas
+     * @param msg - Message or messages to propagate to replicas
+     */
+    propagate(msg) {
+        if (!this.ws)
+            return;
+        const allMsgs = Array.isArray(msg) ? msg : [msg];
+        const serializedFugueMsg = FugueMessageSerialzier.serialize(allMsgs);
+        this.ws.send(serializedFugueMsg);
+    }
+    /**
+     * Inserts a value at the given index and returns the corresponding FugueMessage.
+     * @param index - the index to insert the value at
+     * @param value - the value to insert
+     * @returns the FugueMessage representing the insert operation
+     */
+    insertImpl(index, value) {
+        const id = { sender: this.replicaID, counter: this.counter };
+        // PERF: optimize by caching the last accessed node and its index,
+        // so that if the next insert is nearby, we can start from there instead of the root
+        this.counter++;
+        const leftOrigin = index === 0 ? this.tree.root : this.tree.getByIndex(this.tree.root, index - 1);
+        let msg;
+        if (leftOrigin.rightChildren.length === 0) {
+            // leftOrigin has no right children, so the new node becomes
+            // a right child of leftOrigin.
+            msg = {
+                userIdentity: this.userIdentity,
+                operation: Operation.INSERT,
+                id,
+                data: value,
+                parent: leftOrigin.id,
+                side: "R",
+                replicaId: this.replicaId(),
+                documentID: this.documentID,
+            };
+            // rightOrigin is the node after leftOrigin in the tree traversal,
+            // given that leftOrigin has no right descendants.
+            const rightOrigin = this.tree.nextNonDescendant(leftOrigin);
+            msg.rightOrigin = rightOrigin === null ? undefined : rightOrigin.id;
+        }
+        else {
+            // Otherwise, the new node is added as a left child of rightOrigin, which
+            // is the next node after leftOrigin including deleted nodes.
+            // In this case, rightOrigin is the leftmost descendant of leftOrigin's
+            // first right child.
+            const rightOrigin = this.tree.leftmostDescendant(leftOrigin.rightChildren[0]);
+            msg = {
+                userIdentity: this.userIdentity,
+                operation: Operation.INSERT,
+                id,
+                data: value,
+                parent: rightOrigin.id,
+                side: "L",
+                replicaId: this.replicaId(),
+                documentID: this.documentID,
+            };
+        }
+        msg.userIdentity = this.userIdentity;
+        return msg;
+    }
+    /**
+     * Inserts multiple values starting at the given index. This is optimized for batch inserts, such as pasting a large chunk of text.
+     * @param index - the index to start inserting values at
+     * @param values - the string of values to insert, where each character is inserted as a separate node in the tree
+     */
+    insertMultiple(index, values) {
+        let msgs = [];
+        let returnedMsgs = []; //we need this to return messages whether or not we're online
+        for (let i = 0; i < values.length; i++) {
+            const val = values[i];
+            const idx = index + i;
+            const msg = this.insertImpl(idx, val);
+            this.tree.addNode(msg.id, val, this.tree.getByID(msg.parent), msg.side, msg.rightOrigin);
+            msgs.push(msg);
+            returnedMsgs.push(msg);
+            // Propagate this batch
+            if (msgs.length >= this.batchSize) {
+                if (this.ws?.readyState === WebSocket.OPEN) {
+                    this.propagate(msgs);
+                    msgs = [];
+                }
+            }
+        }
+        // Propagate any remaining messages that didn't fill up the last batch
+        if (msgs.length > 0) {
+            if (this.ws?.readyState === WebSocket.OPEN) {
+                this.propagate(msgs);
+                msgs = [];
+            }
+        }
+        return returnedMsgs;
+    }
+    /**
+     * Inserts a value at the given index and propagates the corresponding FugueMessage to replicas.
+     * @param index -  the index to insert the value at
+     * @param value -  the value to insert
+     */
+    insert(index, value) {
+        const msg = this.insertImpl(index, value);
+        this.tree.addNode(msg.id, value, this.tree.getByID(msg.parent), msg.side, msg.rightOrigin);
+        this.propagate(msg);
+    }
+    /**
+     * Deletes the value at the given index and returns the corresponding FugueMessage.
+     * @param index - the index to delete the value at
+     * @returns the FugueMessage representing the delete operation
+     */
+    deleteImpl(index) {
+        const node = this.tree.getByIndex(this.tree.root, index);
+        if (!node.isDeleted) {
+            node.value = null;
+            node.isDeleted = true;
+            this.tree.updateSize(node, -1);
+        }
+        const msg = {
+            operation: Operation.DELETE,
+            documentID: this.documentID,
+            replicaId: this.replicaID,
+            userIdentity: this.userIdentity,
+            id: node.id,
+            data: null,
+            side: "R",
+        };
+        return msg;
+    }
+    /**
+     * Deletes multiple values starting at the given index. This is optimized for batch deletes, such as deleting a large chunk of text.
+     * @param index - the index to start deleting values at
+     * @param length - the number of characters to delete, starting from the index
+     */
+    deleteMultiple(index, length) {
+        let msgs = [];
+        let returnedMsgs = [];
+        for (let i = 0; i < length; i++) {
+            const msg = this.deleteImpl(index);
+            msgs.push(msg);
+            returnedMsgs.push(msg);
+            // Propagate this batch
+            if (msgs.length >= this.batchSize) {
+                if (this.ws?.readyState === WebSocket.OPEN) {
+                    this.propagate(msgs);
+                    msgs = [];
+                }
+            }
+        }
+        // Propagate any remaining messages that didn't fill up the last batch
+        if (msgs.length > 0) {
+            if (this.ws?.readyState === WebSocket.OPEN) {
+                this.propagate(msgs);
+                msgs = [];
+            }
+        }
+        return returnedMsgs;
+    }
+    /**
+     * Deletes the value at the given index and propagates the corresponding FugueMessage to replicas.
+     * @param index - the index to delete the value at
+     */
+    delete(index) {
+        const msg = this.deleteImpl(index);
+        this.propagate(msg);
+    }
+    /**
+     * Applies a FugueMessage to the tree. Returns true if the message was successfully applied,
+     * or false if it could not be applied due to missing dependencies (e.g. parent node for an insert).
+     * @param msg - the FugueMessage to apply to the tree
+     */
+    applyToTree(msg) {
+        const { operation, data, id, parent, side, rightOrigin } = msg;
+        switch (operation) {
+            case Operation.INSERT:
+                try {
+                    if (!data)
+                        throw Error("Data is required for Operation.INSERT");
+                    if (!parent)
+                        throw Error("Parent is required for Operation.INSERT");
+                    this.tree.addNode(id, data, this.tree.getByID(parent), side, rightOrigin);
+                    return true;
+                }
+                catch (e) {
+                    return false;
+                }
+            case Operation.DELETE:
+                try {
+                    const node = this.tree.getByID(id);
+                    if (!node.isDeleted) {
+                        node.value = null;
+                        node.isDeleted = true;
+                        this.tree.updateSize(node, -1);
+                    }
+                    return true;
+                }
+                catch (e) {
+                    return false;
+                }
+            default:
+                throw Error("Invalid operation");
+        }
+    }
+    /**
+     * Processes pending messages that may now be applicable after applying new messages.
+     * This is called after successfully applying new messages, to check if any pending messages can now be applied due to their dependencies being satisfied.
+     * @param applied - the list of messages that were just applied, which may have satisfied dependencies for pending messages
+     */
+    processPending(applied) {
+        let changed = true;
+        // Iteratively try to apply pending messages until no more can be applied
+        // This avoids recursion and handles deep causal chains (A -> B -> C)
+        while (changed && this.pendingMsgs.size > 0) {
+            changed = false;
+            for (const [id, msg] of this.pendingMsgs) {
+                if (this.applyToTree(msg)) {
+                    applied.push(msg);
+                    this.pendingMsgs.delete(id);
+                    changed = true;
+                }
+            }
+        }
+    }
+    /**
+     * Applies effect messages to the list
+     * @param msg - Message or messages to apply effect for, can be batched
+     * @returns the list of messages that were successfully applied
+     */
+    effect(msg) {
+        const applied = [];
+        const msgs = Array.isArray(msg) ? msg : [msg];
+        for (const msg of msgs) {
+            // Skip messages from this replica
+            if (msg.replicaId == this.replicaId())
+                continue;
+            const succ = this.applyToTree(msg);
+            if (succ) {
+                applied.push(msg);
+            }
+            else {
+                // Deduplication of pending messages
+                if (!this.pendingMsgs.has(this.makeMsgKey(msg)))
+                    this.pendingMsgs.set(this.makeMsgKey(msg), msg);
+            }
+        }
+        if (applied.length > 0) {
+            this.processPending(applied);
+        }
+        return applied;
+    }
+    /**
+     * Gets the value at the given index in the visible string.
+     * @param index - the index to get the value at, where the index is based on the visible string
+     * @returns the value at the given index in the visible string
+     */
+    get(index) {
+        if (index < 0 || index >= this.length()) {
+            throw new Error("Index out of bounds");
+        }
+        const node = this.tree.getByIndex(this.tree.root, index);
+        return node.value;
+    }
+    /**
+     * Gets the length of the visible string, which is the number of non-deleted nodes in the tree.
+     * @returns the length of the visible string
+     */
+    length() {
+        return this.tree.root.size;
+    }
+    /**
+     * Returns the visible string by traversing the tree and concatenating the values of non-deleted nodes.
+     * @returns the visible string represented by the tree, which is the concatenation of values of non-deleted nodes in traversal order
+     */
+    observe() {
+        // PERF: find a way to just use the iterator without concatenating the whole string,
+        // since that can be expensive for large documents and we may only need to observe a
+        // portion of the document at a time (e.g. for rendering a viewport).
+        let res = "";
+        for (const t of this.tree.traverse(this.tree.root)) {
+            res += t;
+        }
+        return res;
+    }
+    /**
+     * Serializes the tree into a Uint8Array.
+     * @returns a Uint8Array representing the serialized tree.
+     */
+    save() {
+        const bytes = this.tree.save();
+        return bytes;
+    }
+    /**
+     * Loads the tree from a Uint8Array. This replaces the current tree with the loaded tree.
+     * @param data - a Uint8Array representing the serialized tree to load.
+     */
+    load(data) {
+        if (!data)
+            return;
+        this.tree.load(data);
+    }
+    /**
+     * Gets the replica ID of this FugueTree instance, which is a unique identifier for this replica in the distributed system.
+     * The replica ID is used in messages to identify the source of operations and to ensure that operations from the same replica
+     * are applied in order.
+     * @returns
+     */
+    replicaId() {
+        return this.replicaID;
+    }
+    /**
+     * Gets the FNode corresponding to the given ID.
+     * @param id - the ID of the node to retrieve
+     * @returns the FNode corresponding to the given ID, or null if no such node exists in the tree
+     */
+    getById(id) {
+        return this.tree.getByID(id);
+    }
+    /**
+     * Gets the index of the given node in the visible string.
+     * @param node - the FNode to get the visible index of
+     * @returns the index of the given node in the visible string
+     */
+    getVisibleIndex(node) {
+        return this.tree.getVisibleIndex(node);
+    }
+}

package/dist/dts/FugueTree/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./FTree.js";
+export * from "./FugueTree.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/dts/FugueTree/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dts/FugueTree/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC"}

package/dist/dts/FugueTree/index.js

@@ -0,0 +1,2 @@
+export * from "./FTree.js";
+export * from "./FugueTree.js";

package/dist/dts/Serailizers/Fugue/Message.d.ts

@@ -1,4 +1,4 @@
-import { FugueMessageType } from "../../../types/index.js";
+import { FugueMessageType } from "../../../types/Fugue/index.js";
 declare function serialize<P>(msgs: FugueMessageType<P>[]): Uint8Array<ArrayBuffer>;
 declare function deserialize<P>(data: Uint8Array): FugueMessageType<P>[];
 export declare const FugueMessageSerialzier: {

package/dist/dts/Serailizers/Fugue/Message.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Message.d.ts","sourceRoot":"","sources":["../../../../src/dts/Serailizers/Fugue/Message.ts"],"names":[],"mappings":"AACA,OAAO,EAGH,gBAAgB,EAInB,MAAM,yBAAyB,CAAC;AAEjC,iBAAS,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,2BAEhD;AAED,iBAAS,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,GAAG,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAM/D;AAqDD,eAAO,MAAM,sBAAsB;;;CAGlC,CAAC"}
+{"version":3,"file":"Message.d.ts","sourceRoot":"","sources":["../../../../src/dts/Serailizers/Fugue/Message.ts"],"names":[],"mappings":"AACA,OAAO,EAGH,gBAAgB,EAInB,MAAM,+BAA+B,CAAC;AAEvC,iBAAS,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,2BAEhD;AAED,iBAAS,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,GAAG,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAM/D;AA6DD,eAAO,MAAM,sBAAsB;;;CAGlC,CAAC"}

package/dist/dts/Serailizers/Fugue/Message.js

@@ -1,5 +1,5 @@
 import { encode, decode } from "@msgpack/msgpack";
-import { Operation, } from "../../../types/index.js";
+import { Operation, } from "../../../types/Fugue/index.js";
 function serialize(msgs) {
     return encode(msgs.map((m) => toTuple(m)));
 }
@@ -14,7 +14,15 @@ function toTuple(msg) {
     // Check if msg is of FugueJoinMessage type
     switch (msg.operation) {
         case Operation.JOIN:
-            return [msg.operation, msg.documentID, msg.state, msg.userIdentity, msg.collaborators, msg.offlineChanges, msg.replicaId];
+            return [
+                msg.operation,
+                msg.documentID,
+                msg.state,
+                msg.userIdentity,
+                msg.collaborators,
+                msg.offlineChanges,
+                msg.replicaId,
+            ];
         case Operation.INSERT:
         case Operation.DELETE:
             return [msg.operation, msg.documentID, msg.replicaId, msg.position, msg.data, msg.userIdentity];
@@ -35,7 +43,7 @@ function fromTuple(tuple) {
                 userIdentity: tuple[3],
                 collaborators: tuple[4],
                 offlineChanges: tuple[5],
-                replicaId: tuple[6]
+                replicaId: tuple[6],
             };
         case Operation.INSERT:
         case Operation.DELETE:
@@ -54,7 +62,7 @@ function fromTuple(tuple) {
         case Operation.LEAVE:
             return {
                 operation: tuple[0],
-                userIdentity: tuple[1]
+                userIdentity: tuple[1],
             };
     }
     throw new Error("Unknown tuple format");

package/dist/dts/Serailizers/Fugue/State.d.ts

@@ -1,4 +1,4 @@
-import { FugueState } from "../../../types/index.js";
+import { FugueState } from "../../../types/Fugue/index.js";
 declare function serialize(state: FugueState<string>): Uint8Array<ArrayBufferLike>;
 declare function deserialize(compressed: Uint8Array<ArrayBufferLike>): FugueState<string>;
 export declare const FugueStateSerializer: {

package/dist/dts/Serailizers/Fugue/State.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"State.d.ts","sourceRoot":"","sources":["../../../../src/dts/Serailizers/Fugue/State.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAErD,iBAAS,SAAS,CAAC,KAAK,EAAE,UAAU,CAAC,MAAM,CAAC,GAAG,UAAU,CAAC,eAAe,CAAC,CAKzE;AAED,iBAAS,WAAW,CAAC,UAAU,EAAE,UAAU,CAAC,eAAe,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,CAIhF;AAED,eAAO,MAAM,oBAAoB;;;CAGhC,CAAC"}
+{"version":3,"file":"State.d.ts","sourceRoot":"","sources":["../../../../src/dts/Serailizers/Fugue/State.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D,iBAAS,SAAS,CAAC,KAAK,EAAE,UAAU,CAAC,MAAM,CAAC,GAAG,UAAU,CAAC,eAAe,CAAC,CAKzE;AAED,iBAAS,WAAW,CAAC,UAAU,EAAE,UAAU,CAAC,eAAe,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,CAIhF;AAED,eAAO,MAAM,oBAAoB;;;CAGhC,CAAC"}

package/dist/dts/Serailizers/FugueTree/Message.d.ts

@@ -0,0 +1,13 @@
+import { BaseFugueMessage, FugueMessageType } from "../../../types/FugueTree/index.js";
+declare function serialize(msgs: BaseFugueMessage[]): Uint8Array<ArrayBuffer>;
+declare function serializeSingleMessage(msg: FugueMessageType): Uint8Array<ArrayBuffer>;
+declare function deserialize(data: Uint8Array): BaseFugueMessage[];
+declare function deserializeSingleMessage(data: Uint8Array): BaseFugueMessage;
+export declare const FugueMessageSerialzier: {
+    serialize: typeof serialize;
+    serializeSingleMessage: typeof serializeSingleMessage;
+    deserialize: typeof deserialize;
+    deserializeSingleMessage: typeof deserializeSingleMessage;
+};
+export {};
+//# sourceMappingURL=Message.d.ts.map

package/dist/dts/Serailizers/FugueTree/Message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Message.d.ts","sourceRoot":"","sources":["../../../../src/dts/Serailizers/FugueTree/Message.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAEvF,iBAAS,SAAS,CAAC,IAAI,EAAE,gBAAgB,EAAE,2BAE1C;AAED,iBAAS,sBAAsB,CAAC,GAAG,EAAE,gBAAgB,2BAEpD;AAED,iBAAS,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,gBAAgB,EAAE,CAGzD;AAED,iBAAS,wBAAwB,CAAC,IAAI,EAAE,UAAU,GAAG,gBAAgB,CAGpE;AAED,eAAO,MAAM,sBAAsB;;;;;CAKlC,CAAC"}

package/dist/dts/Serailizers/FugueTree/Message.js

@@ -0,0 +1,21 @@
+import { encode, decode } from "@msgpack/msgpack";
+function serialize(msgs) {
+    return encode(msgs);
+}
+function serializeSingleMessage(msg) {
+    return encode(msg);
+}
+function deserialize(data) {
+    const dec = decode(data);
+    return dec;
+}
+function deserializeSingleMessage(data) {
+    const dec = decode(data);
+    return dec;
+}
+export const FugueMessageSerialzier = {
+    serialize,
+    serializeSingleMessage,
+    deserialize,
+    deserializeSingleMessage,
+};

package/dist/dts/Serailizers/FugueTree/State.d.ts

@@ -0,0 +1,9 @@
+import { FTree } from "../../FugueTree/index.js";
+declare function serialize(state: FTree): Uint8Array<ArrayBufferLike>;
+declare function deserialize(compressed: Uint8Array<ArrayBufferLike>): FTree;
+export declare const FugueStateSerializer: {
+    serialize: typeof serialize;
+    deserialize: typeof deserialize;
+};
+export {};
+//# sourceMappingURL=State.d.ts.map

package/dist/dts/Serailizers/FugueTree/State.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"State.d.ts","sourceRoot":"","sources":["../../../../src/dts/Serailizers/FugueTree/State.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAEjD,iBAAS,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAAC,eAAe,CAAC,CAG5D;AAED,iBAAS,WAAW,CAAC,UAAU,EAAE,UAAU,CAAC,eAAe,CAAC,GAAG,KAAK,CAMnE;AAED,eAAO,MAAM,oBAAoB;;;CAGhC,CAAC"}

package/dist/dts/Serailizers/FugueTree/State.js

@@ -0,0 +1,16 @@
+import { FTree } from "../../FugueTree/index.js";
+function serialize(state) {
+    // return compress(state.save())
+    return state.save();
+}
+function deserialize(compressed) {
+    // const raw = decompress(compressed);
+    const raw = compressed;
+    const state = new FTree();
+    state.load(raw);
+    return state;
+}
+export const FugueStateSerializer = {
+    serialize,
+    deserialize,
+};

package/dist/dts/Serailizers/FugueTree/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Message.js";
+export * from "./State.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/dts/Serailizers/FugueTree/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/dts/Serailizers/FugueTree/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}

package/dist/dts/Serailizers/FugueTree/index.js

@@ -0,0 +1,2 @@
+export * from "./Message.js";
+export * from "./State.js";

package/dist/dts/Serailizers/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./Fugue/index.js";
+export * from "./FugueTree/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/dts/Serailizers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dts/Serailizers/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dts/Serailizers/index.ts"],"names":[],"mappings":"AACA,cAAc,sBAAsB,CAAC"}

package/dist/dts/Serailizers/index.js

@@ -1 +1,2 @@
-export * from "./Fugue/index.js";
+// export * from "./Fugue/index.js";
+export * from "./FugueTree/index.js";

package/dist/dts/TotalOrder/StringTotalOrder.d.ts

@@ -4,8 +4,8 @@ export declare class StringTotalOrder implements UniquelyDenseTotalOrder<StringP
     readonly replicaID: string;
     private counter;
     getReplicaId(): string;
-    compare(a: string, b: string): number;
+    compare(a: StringPosition, b: StringPosition): number;
     constructor(replicaID: string);
-    createBetween(a?: string, b?: string): string;
+    createBetween(a?: StringPosition, b?: StringPosition): string;
 }
 //# sourceMappingURL=StringTotalOrder.d.ts.map

package/dist/dts/TotalOrder/StringTotalOrder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StringTotalOrder.d.ts","sourceRoot":"","sources":["../../../src/dts/TotalOrder/StringTotalOrder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAEvE,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC;AAEpC,qBAAa,gBAAiB,YAAW,uBAAuB,CAAC,cAAc,CAAC;IAC5E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,OAAO,CAAK;IAEpB,YAAY,IAAI,MAAM;IAItB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;gBAIzB,SAAS,EAAE,MAAM;IAI7B,aAAa,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;CA6BhD"}
+{"version":3,"file":"StringTotalOrder.d.ts","sourceRoot":"","sources":["../../../src/dts/TotalOrder/StringTotalOrder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAEvE,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC;AAEpC,qBAAa,gBAAiB,YAAW,uBAAuB,CAAC,cAAc,CAAC;IAC5E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,OAAO,CAAK;IAEpB,YAAY,IAAI,MAAM;IAItB,OAAO,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC,EAAE,cAAc,GAAG,MAAM;gBAIzC,SAAS,EAAE,MAAM;IAI7B,aAAa,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC,CAAC,EAAE,cAAc,GAAG,MAAM;CA6BhE"}

package/dist/dts/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./CausalTree/index.js";
-export * from "./Fugue/index.js";
 export * from "./Serailizers/index.js";
 export * from "./TotalOrder/index.js";
+export * from "./Fugue/index.js";
+export * from "./FugueTree/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/dts/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dts/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dts/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC"}

package/dist/dts/index.js

@@ -1,4 +1,5 @@
 export * from "./CausalTree/index.js";
-export * from "./Fugue/index.js";
 export * from "./Serailizers/index.js";
 export * from "./TotalOrder/index.js";
+export * from "./Fugue/index.js";
+export * from "./FugueTree/index.js";

package/dist/tests/FugueTree.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=FugueTree.test.d.ts.map

package/dist/tests/FugueTree.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FugueTree.test.d.ts","sourceRoot":"","sources":["../../src/tests/FugueTree.test.ts"],"names":[],"mappings":""}

package/dist/tests/FugueTree.test.js

@@ -0,0 +1,8 @@
+import { emptyFugueTree } from "./mocks.js";
+describe("Fugue Tree Tests", () => {
+    describe("Given a Fugue tree ", () => {
+        test("Empty Fugue treee has an empty string", () => {
+            expect(emptyFugueTree.observe()).toBe("");
+        });
+    });
+});

package/dist/tests/mocks.d.ts

@@ -1,3 +1,4 @@
-import { FugueList } from "../dts/index.js";
+import { FugueList, FugueTree } from "../dts/index.js";
 export declare const emptyFugueList: FugueList<string>;
+export declare const emptyFugueTree: FugueTree;
 //# sourceMappingURL=mocks.d.ts.map

package/dist/tests/mocks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mocks.d.ts","sourceRoot":"","sources":["../../src/tests/mocks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAoB,MAAM,iBAAiB,CAAC;AAG9D,eAAO,MAAM,cAAc,mBAI1B,CAAC"}
+{"version":3,"file":"mocks.d.ts","sourceRoot":"","sources":["../../src/tests/mocks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,SAAS,EAAoB,MAAM,iBAAiB,CAAC;AAGzE,eAAO,MAAM,cAAc,mBAI1B,CAAC;AAEF,eAAO,MAAM,cAAc,WAA2E,CAAC"}

package/dist/tests/mocks.js

@@ -1,3 +1,4 @@
-import { FugueList, StringTotalOrder } from "../dts/index.js";
+import { FugueList, FugueTree, StringTotalOrder } from "../dts/index.js";
 import crypto from "crypto";
 export const emptyFugueList = new FugueList(new StringTotalOrder(crypto.randomBytes(3).toString("hex")), null, crypto.randomBytes(24).toString("hex"));
+export const emptyFugueTree = new FugueTree(null, crypto.randomBytes(24).toString("hex"), "test-tree");

package/dist/types/Fugue/Fugue.d.ts

@@ -1,3 +1,3 @@
-import { FNode } from "../../dts/index.js";
-export type FugueState<P> = FNode<P>[][];
+import { FListNode } from "../../dts/Fugue/FNode.js";
+export type FugueState<P> = FListNode<P>[][];
 //# sourceMappingURL=Fugue.d.ts.map

package/dist/types/Fugue/Fugue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Fugue.d.ts","sourceRoot":"","sources":["../../../src/types/Fugue/Fugue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAE3C,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC"}
+{"version":3,"file":"Fugue.d.ts","sourceRoot":"","sources":["../../../src/types/Fugue/Fugue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAErD,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC"}