@cr_docs_t/dts 0.34.0 → 0.35.1

package/dist/tests/unit/FugueTree.test.js

@@ -0,0 +1,416 @@
+import { describe, test, expect } from "@jest/globals";
+import { Operation, MessageType } from "../../types/index.js";
+import { makeFugueTree, treeWithText, makeForeignInsertMsg, makeForeignDeleteMsg, DOC_ID, USER_ID, } from "./mocks/FugueTree-mocks.js";
+// ---------------------------------------------------------------------------
+// observe / length
+// ---------------------------------------------------------------------------
+describe("FugueTree", () => {
+    describe("observe", () => {
+        test("empty tree has an empty string", () => {
+            expect(makeFugueTree().observe()).toBe("");
+        });
+        test("observe returns the full inserted text in order", () => {
+            const tree = treeWithText("hello");
+            expect(tree.observe()).toBe("hello");
+        });
+        test("observe reflects characters deleted from the middle", () => {
+            const tree = treeWithText("hello");
+            tree.delete(2); // remove 'l' at index 2
+            expect(tree.observe()).toBe("helo");
+        });
+        test("observe is empty after deleting all characters", () => {
+            const tree = treeWithText("hi");
+            tree.delete(0);
+            tree.delete(0);
+            expect(tree.observe()).toBe("");
+        });
+    });
+    // -----------------------------------------------------------------------
+    // length
+    // -----------------------------------------------------------------------
+    describe("length", () => {
+        test("empty tree has length 0", () => {
+            expect(makeFugueTree().length()).toBe(0);
+        });
+        test("length matches number of inserted characters", () => {
+            const tree = treeWithText("abc");
+            expect(tree.length()).toBe(3);
+        });
+        test("length decrements after a delete", () => {
+            const tree = treeWithText("abc");
+            tree.delete(1);
+            expect(tree.length()).toBe(2);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // get
+    // -----------------------------------------------------------------------
+    describe("get", () => {
+        test("returns the character at the given visible index", () => {
+            const tree = treeWithText("abc");
+            expect(tree.get(0)).toBe("a");
+            expect(tree.get(1)).toBe("b");
+            expect(tree.get(2)).toBe("c");
+        });
+        test("throws when index is negative", () => {
+            const tree = treeWithText("abc");
+            expect(() => tree.get(-1)).toThrow();
+        });
+        test("throws when index equals length", () => {
+            const tree = treeWithText("abc");
+            expect(() => tree.get(3)).toThrow();
+        });
+        test("returns correct character after a deletion shifts visible indices", () => {
+            const tree = treeWithText("abc");
+            tree.delete(0); // removes 'a'; visible string is now "bc"
+            expect(tree.get(0)).toBe("b");
+            expect(tree.get(1)).toBe("c");
+        });
+    });
+    // -----------------------------------------------------------------------
+    // insert (single character)
+    // -----------------------------------------------------------------------
+    describe("insert", () => {
+        test("returns a FugueMessage with INSERT operation", () => {
+            const tree = makeFugueTree();
+            const msg = tree.insert(0, "x");
+            expect(msg.operation).toBe(Operation.INSERT);
+            expect(msg.msgType).toBe(MessageType.FUGUE);
+        });
+        test("returned message carries the inserted character", () => {
+            const tree = makeFugueTree();
+            const msg = tree.insert(0, "z");
+            expect(msg.data).toBe("z");
+        });
+        test("returned message contains the tree's replicaId", () => {
+            const tree = makeFugueTree();
+            const msg = tree.insert(0, "a");
+            expect(msg.replicaId).toBe(tree.replicaId());
+        });
+        test("returned message contains the correct documentID and userIdentity", () => {
+            const tree = makeFugueTree();
+            const msg = tree.insert(0, "a");
+            expect(msg.documentID).toBe(DOC_ID);
+            expect(msg.userIdentity).toBe(USER_ID);
+        });
+        test("inserting at index 0 prepends the character", () => {
+            const tree = treeWithText("bc");
+            tree.insert(0, "a");
+            expect(tree.observe()).toBe("abc");
+        });
+        test("inserting at the end appends the character", () => {
+            const tree = treeWithText("ab");
+            tree.insert(2, "c");
+            expect(tree.observe()).toBe("abc");
+        });
+        test("inserting in the middle places the character correctly", () => {
+            const tree = treeWithText("ac");
+            tree.insert(1, "b");
+            expect(tree.observe()).toBe("abc");
+        });
+        test("counter increments with each insert so IDs are unique", () => {
+            const tree = makeFugueTree();
+            const msg1 = tree.insert(0, "a");
+            const msg2 = tree.insert(1, "b");
+            expect(msg2.id.counter).toBeGreaterThan(msg1.id.counter);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // insertMultiple
+    // -----------------------------------------------------------------------
+    describe("insertMultiple", () => {
+        test("inserts each character and returns one message per character", () => {
+            const tree = makeFugueTree();
+            const msgs = tree.insertMultiple(0, "hello");
+            expect(msgs).toHaveLength(5);
+            expect(tree.observe()).toBe("hello");
+        });
+        test("each returned message has a unique id counter", () => {
+            const tree = makeFugueTree();
+            const msgs = tree.insertMultiple(0, "abc");
+            const counters = msgs.map((m) => m.id.counter);
+            expect(new Set(counters).size).toBe(3);
+        });
+        test("returns an empty array when given an empty string", () => {
+            const tree = makeFugueTree();
+            const msgs = tree.insertMultiple(0, "");
+            expect(msgs).toHaveLength(0);
+            expect(tree.observe()).toBe("");
+        });
+        test("inserting multiple characters in the middle produces correct order", () => {
+            const tree = treeWithText("ad");
+            tree.insertMultiple(1, "bc");
+            expect(tree.observe()).toBe("abcd");
+        });
+    });
+    // -----------------------------------------------------------------------
+    // delete (single character)
+    // -----------------------------------------------------------------------
+    describe("delete", () => {
+        test("removing the only character results in an empty document", () => {
+            const tree = treeWithText("x");
+            tree.delete(0);
+            expect(tree.observe()).toBe("");
+            expect(tree.length()).toBe(0);
+        });
+        test("deleting the first character of several is correct", () => {
+            const tree = treeWithText("abc");
+            tree.delete(0);
+            expect(tree.observe()).toBe("bc");
+        });
+        test("deleting the last character is correct", () => {
+            const tree = treeWithText("abc");
+            tree.delete(2);
+            expect(tree.observe()).toBe("ab");
+        });
+        test("deleting the same index twice reflects the shifted visible string", () => {
+            const tree = treeWithText("abc");
+            tree.delete(0); // removes 'a'
+            tree.delete(0); // removes 'b' (now at visible index 0)
+            expect(tree.observe()).toBe("c");
+        });
+    });
+    // -----------------------------------------------------------------------
+    // deleteMultiple
+    // -----------------------------------------------------------------------
+    describe("deleteMultiple", () => {
+        test("deletes the specified number of characters and returns one message per deletion", () => {
+            const tree = treeWithText("hello");
+            const msgs = tree.deleteMultiple(1, 3);
+            expect(msgs).toHaveLength(3);
+            expect(tree.observe()).toBe("ho");
+        });
+        test("deleting length 0 returns an empty array and leaves the document unchanged", () => {
+            const tree = treeWithText("abc");
+            const msgs = tree.deleteMultiple(0, 0);
+            expect(msgs).toHaveLength(0);
+            expect(tree.observe()).toBe("abc");
+        });
+        test("all returned messages have DELETE operation", () => {
+            const tree = treeWithText("abc");
+            const msgs = tree.deleteMultiple(0, 2);
+            msgs.forEach((msg) => expect(msg.operation).toBe(Operation.DELETE));
+        });
+    });
+    // -----------------------------------------------------------------------
+    // effect — applying remote messages
+    // -----------------------------------------------------------------------
+    describe("effect", () => {
+        test("applying a remote INSERT from a different replica updates the document", () => {
+            const tree = makeFugueTree();
+            const foreignId = "foreign-replica";
+            const msg = makeForeignInsertMsg(foreignId, 0, "x");
+            const applied = tree.effect(msg);
+            expect(applied).toHaveLength(1);
+            expect(tree.observe()).toBe("x");
+        });
+        test("messages from this replica are skipped", () => {
+            const tree = makeFugueTree();
+            // Build a message that looks like it came from the same replicaId
+            const selfMsg = makeForeignInsertMsg(tree.replicaId(), 0, "x");
+            const applied = tree.effect(selfMsg);
+            expect(applied).toHaveLength(0);
+            expect(tree.observe()).toBe("");
+        });
+        test("accepts an array of messages and returns all successfully applied ones", () => {
+            const tree = makeFugueTree();
+            const msgs = [makeForeignInsertMsg("replica-b", 0, "a"), makeForeignInsertMsg("replica-b", 1, "b")];
+            // counter 1 depends on counter 0 being the parent — both are right children of root, so both apply
+            const applied = tree.effect(msgs);
+            expect(applied.length).toBeGreaterThanOrEqual(1);
+        });
+        test("duplicate pending messages are not stored twice", () => {
+            const tree = makeFugueTree();
+            // A message that references a non-existent parent will be deferred
+            const orphanMsg = {
+                ...makeForeignInsertMsg("rep-x", 0, "z"),
+                parent: { sender: "ghost", counter: 99 },
+            };
+            tree.effect(orphanMsg);
+            tree.effect(orphanMsg); // second call with same key
+            // pendingMsgs should have exactly one entry
+            expect(tree.pendingMsgs.size).toBe(1);
+        });
+        test("pending messages are applied once their dependency arrives", () => {
+            const tree = makeFugueTree();
+            // msg2 references msg1 as parent, so msg1 must arrive first
+            const msg1 = makeForeignInsertMsg("rep-a", 0, "A");
+            const msg2 = {
+                ...makeForeignInsertMsg("rep-a", 1, "B"),
+                parent: { sender: "rep-a", counter: 0 },
+                side: "R",
+            };
+            // Send msg2 first — it can't be applied yet
+            tree.effect(msg2);
+            expect(tree.pendingMsgs.size).toBe(1);
+            expect(tree.observe()).toBe("");
+            // Now send msg1 — msg2 should be resolved automatically
+            tree.effect(msg1);
+            expect(tree.pendingMsgs.size).toBe(0);
+            expect(tree.observe()).toContain("A");
+        });
+        test("applying a remote DELETE removes the character from the visible string", () => {
+            // Insert locally first, then simulate a remote delete of the same node
+            const tree = makeFugueTree();
+            const insertMsg = tree.insert(0, "x");
+            // Build a foreign delete targeting the node just inserted
+            const delMsg = makeForeignDeleteMsg("other-replica", insertMsg.id);
+            // Override replicaId to something different from the tree's own ID
+            const foreignDel = { ...delMsg, replicaId: "other-replica" };
+            tree.effect(foreignDel);
+            expect(tree.observe()).toBe("");
+        });
+    });
+    // -----------------------------------------------------------------------
+    // getById / getVisibleIndex
+    // -----------------------------------------------------------------------
+    describe("getById", () => {
+        test("returns the node corresponding to an inserted character's ID", () => {
+            const tree = makeFugueTree();
+            const msg = tree.insert(0, "q");
+            const node = tree.getById(msg.id);
+            expect(node.value).toBe("q");
+        });
+        test("throws for an unknown ID", () => {
+            const tree = makeFugueTree();
+            expect(() => tree.getById({ sender: "nobody", counter: 99 })).toThrow();
+        });
+    });
+    describe("getVisibleIndex", () => {
+        test("returns the correct index of an inserted node", () => {
+            const tree = treeWithText("abc");
+            const msgC = tree.insert(3, "d"); // 'd' is now at visible index 3
+            const node = tree.getById(msgC.id);
+            expect(tree.getVisibleIndex(node)).toBe(3);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // replicaId
+    // -----------------------------------------------------------------------
+    describe("replicaId", () => {
+        test("replicaId returns a non-empty string", () => {
+            const tree = makeFugueTree();
+            expect(typeof tree.replicaId()).toBe("string");
+            expect(tree.replicaId().length).toBeGreaterThan(0);
+        });
+        test("two different FugueTree instances have different replicaIds", () => {
+            const treeA = makeFugueTree();
+            const treeB = makeFugueTree();
+            expect(treeA.replicaId()).not.toBe(treeB.replicaId());
+        });
+    });
+    // -----------------------------------------------------------------------
+    // save / load round-trip
+    // -----------------------------------------------------------------------
+    describe("save / load", () => {
+        test("save returns a non-empty Uint8Array", () => {
+            const tree = treeWithText("hello");
+            const bytes = tree.save();
+            expect(bytes).toBeInstanceOf(Uint8Array);
+            expect(bytes.length).toBeGreaterThan(0);
+        });
+        test("loading saved state into a new tree reproduces the same document", () => {
+            const original = treeWithText("hello world");
+            const bytes = original.save();
+            const restored = makeFugueTree();
+            restored.load(bytes);
+            expect(restored.observe()).toBe("hello world");
+        });
+        test("loading null is a no-op and leaves the tree unchanged", () => {
+            const tree = treeWithText("abc");
+            tree.load(null);
+            expect(tree.observe()).toBe("abc");
+        });
+        test("save / load round-trip preserves deletions", () => {
+            const original = treeWithText("hello");
+            original.delete(0); // remove 'h'
+            const bytes = original.save();
+            const restored = makeFugueTree();
+            restored.load(bytes);
+            expect(restored.observe()).toBe("ello");
+        });
+    });
+    // -----------------------------------------------------------------------
+    // traverse
+    // -----------------------------------------------------------------------
+    describe("traverse", () => {
+        test("iterating traverse yields the visible characters in document order", () => {
+            const tree = treeWithText("abc");
+            expect([...tree.traverse()]).toEqual(["a", "b", "c"]);
+        });
+        test("deleted characters are excluded from traverse", () => {
+            const tree = treeWithText("abc");
+            tree.delete(1); // remove 'b'
+            expect([...tree.traverse()]).toEqual(["a", "c"]);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // clear
+    // -----------------------------------------------------------------------
+    describe("clear", () => {
+        test("clear resets the document to an empty string", () => {
+            const tree = treeWithText("hello");
+            tree.clear();
+            expect(tree.observe()).toBe("");
+            expect(tree.length()).toBe(0);
+        });
+        test("insertions after clear work correctly", () => {
+            const tree = treeWithText("old");
+            tree.clear();
+            tree.insertMultiple(0, "new");
+            expect(tree.observe()).toBe("new");
+        });
+    });
+    // -----------------------------------------------------------------------
+    // nextNonDescendant (public proxy)
+    // -----------------------------------------------------------------------
+    describe("nextNonDescendant", () => {
+        test("returns null for the last character in the document", () => {
+            const tree = treeWithText("a");
+            const msg = tree.insert(0, "b"); // 'b' is now at index 1 (last)
+            const node = tree.getById(msg.id);
+            // The last node in the tree has no next non-descendant
+            const next = tree.nextNonDescendant(node);
+            // It may or may not be null depending on tree structure, but must not throw
+            expect(next === null || next !== undefined).toBe(true);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // Ordering / CRDT convergence
+    // -----------------------------------------------------------------------
+    describe("CRDT ordering guarantees", () => {
+        test("concurrent inserts at the same index from two replicas both survive", () => {
+            const replicaA = makeFugueTree();
+            const replicaB = makeFugueTree();
+            const msgA = replicaA.insert(0, "A");
+            const msgB = replicaB.insert(0, "B");
+            // Cross-apply
+            replicaA.effect({ ...msgB, replicaId: replicaB.replicaId() });
+            replicaB.effect({ ...msgA, replicaId: replicaA.replicaId() });
+            // Both replicas must have 2 characters
+            expect(replicaA.length()).toBe(2);
+            expect(replicaB.length()).toBe(2);
+        });
+        test("two replicas converge to the same string after exchanging all messages", () => {
+            const replicaA = makeFugueTree();
+            const replicaB = makeFugueTree();
+            const msgsA = replicaA.insertMultiple(0, "hello");
+            const msgsB = replicaB.insertMultiple(0, "world");
+            // Apply A's messages to B and vice-versa
+            replicaA.effect(msgsB.map((m) => ({ ...m, replicaId: replicaB.replicaId() })));
+            replicaB.effect(msgsA.map((m) => ({ ...m, replicaId: replicaA.replicaId() })));
+            expect(replicaA.observe()).toBe(replicaB.observe());
+        });
+        test("insert followed by delete yields the same result regardless of message delivery order", () => {
+            const replicaA = makeFugueTree();
+            const replicaB = makeFugueTree();
+            // A inserts 'x', then deletes it
+            const insertMsg = replicaA.insert(0, "x");
+            const deleteMsg = replicaA.deleteMultiple(0, 1)[0];
+            // B receives delete before insert (out-of-order)
+            replicaB.effect({ ...deleteMsg, replicaId: replicaA.replicaId() });
+            replicaB.effect({ ...insertMsg, replicaId: replicaA.replicaId() });
+            expect(replicaB.observe()).toBe("");
+        });
+    });
+});

package/dist/tests/unit/mocks/BragiAST-mocks.d.ts

@@ -0,0 +1,2 @@
+export * from "../../utils.js";
+//# sourceMappingURL=BragiAST-mocks.d.ts.map

package/dist/tests/unit/mocks/BragiAST-mocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BragiAST-mocks.d.ts","sourceRoot":"","sources":["../../../../src/tests/unit/mocks/BragiAST-mocks.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/dist/tests/unit/mocks/BragiAST-mocks.js

@@ -0,0 +1 @@
+export * from "../../utils.js";

package/dist/tests/unit/mocks/FTree-mocks.d.ts

@@ -0,0 +1,20 @@
+import type { FNode, ID, FTree } from "../../../dts/index.js";
+export declare const ROOT_ID: ID;
+/**
+ * Builds a minimal FNode without inserting it into any tree.
+ * Useful for constructing expected-value objects in assertions.
+ */
+export declare function makeNode(sender: string, counter: number, value: string | null, parent: FNode | null, side: "L" | "R", isDeleted?: boolean): FNode;
+export declare const ID_A0: ID;
+export declare const ID_A1: ID;
+export declare const ID_A2: ID;
+export declare const ID_B0: ID;
+export declare const ID_B1: ID;
+export declare const ID_C0: ID;
+/**
+ * Inserts the string "hello" into a fresh FTree one character at a time
+ * under the root, right-side, no rightOrigin. Returns the tree and the
+ * five inserted nodes in insertion order.
+ */
+export declare function buildHelloTree(tree: FTree): ID[];
+//# sourceMappingURL=FTree-mocks.d.ts.map

package/dist/tests/unit/mocks/FTree-mocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FTree-mocks.d.ts","sourceRoot":"","sources":["../../../../src/tests/unit/mocks/FTree-mocks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAE9D,eAAO,MAAM,OAAO,EAAE,EAA+B,CAAC;AAEtD;;;GAGG;AACH,wBAAgB,QAAQ,CACpB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GAAG,IAAI,EACpB,MAAM,EAAE,KAAK,GAAG,IAAI,EACpB,IAAI,EAAE,GAAG,GAAG,GAAG,EACf,SAAS,UAAQ,GAClB,KAAK,CAWP;AAED,eAAO,MAAM,KAAK,EAAE,EAAgC,CAAC;AACrD,eAAO,MAAM,KAAK,EAAE,EAAgC,CAAC;AACrD,eAAO,MAAM,KAAK,EAAE,EAAgC,CAAC;AACrD,eAAO,MAAM,KAAK,EAAE,EAAgC,CAAC;AACrD,eAAO,MAAM,KAAK,EAAE,EAAgC,CAAC;AACrD,eAAO,MAAM,KAAK,EAAE,EAAgC,CAAC;AAErD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,KAAK,QAOzC"}

package/dist/tests/unit/mocks/FTree-mocks.js

@@ -0,0 +1,36 @@
+export const ROOT_ID = { sender: "", counter: 0 };
+/**
+ * Builds a minimal FNode without inserting it into any tree.
+ * Useful for constructing expected-value objects in assertions.
+ */
+export function makeNode(sender, counter, value, parent, side, isDeleted = false) {
+    return {
+        id: { sender, counter },
+        value,
+        isDeleted,
+        parent,
+        side,
+        leftChildren: [],
+        rightChildren: [],
+        size: 0,
+    };
+}
+export const ID_A0 = { sender: "A", counter: 0 };
+export const ID_A1 = { sender: "A", counter: 1 };
+export const ID_A2 = { sender: "A", counter: 2 };
+export const ID_B0 = { sender: "B", counter: 0 };
+export const ID_B1 = { sender: "B", counter: 1 };
+export const ID_C0 = { sender: "C", counter: 0 };
+/**
+ * Inserts the string "hello" into a fresh FTree one character at a time
+ * under the root, right-side, no rightOrigin. Returns the tree and the
+ * five inserted nodes in insertion order.
+ */
+export function buildHelloTree(tree) {
+    const chars = ["h", "e", "l", "l", "o"];
+    const ids = chars.map((_, i) => ({ sender: "A", counter: i }));
+    for (let i = 0; i < chars.length; i++) {
+        tree.addNode(ids[i], chars[i], tree.root, "R");
+    }
+    return ids;
+}

package/dist/tests/unit/mocks/FugueTree-mocks.d.ts

@@ -0,0 +1,24 @@
+import { FugueTree } from "../../../dts/index.js";
+import { FugueMessage } from "../../../types/index.js";
+export declare const DOC_ID = "test-doc";
+export declare const USER_ID = "test-user";
+/**
+ * A fresh FugueTree with no WebSocket and stable IDs for deterministic tests.
+ */
+export declare function makeFugueTree(docId?: string, userId?: string): FugueTree;
+export declare const emptyFugueTree: FugueTree;
+/**
+ * Build a FugueTree pre-populated with the given string via insertMultiple.
+ */
+export declare function treeWithText(text: string): FugueTree;
+/**
+ * Craft a minimal FugueMessage from one replica so that effect() can be
+ * called on a different replica. The parent ID must match the root node
+ * ({sender:"", counter:0}).
+ */
+export declare function makeForeignInsertMsg(replicaId: string, counter: number, data: string, documentID?: string): FugueMessage;
+export declare function makeForeignDeleteMsg(replicaId: string, targetId: {
+    sender: string;
+    counter: number;
+}, documentID?: string): FugueMessage;
+//# sourceMappingURL=FugueTree-mocks.d.ts.map

package/dist/tests/unit/mocks/FugueTree-mocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FugueTree-mocks.d.ts","sourceRoot":"","sources":["../../../../src/tests/unit/mocks/FugueTree-mocks.ts"],"names":[],"mappings":"AACA,OAAO,EAAa,SAAS,EAAoB,MAAM,uBAAuB,CAAC;AAC/E,OAAO,EAAE,YAAY,EAA0B,MAAM,yBAAyB,CAAC;AAE/E,eAAO,MAAM,MAAM,aAAa,CAAC;AACjC,eAAO,MAAM,OAAO,cAAc,CAAC;AAEnC;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAExE;AAED,eAAO,MAAM,cAAc,WAAkB,CAAC;AAE9C;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAOpD;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAChC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,UAAU,GAAE,MAAe,GAC5B,YAAY,CAYd;AAED,wBAAgB,oBAAoB,CAChC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,EAC7C,UAAU,GAAE,MAAe,GAC5B,YAAY,CAWd"}

package/dist/tests/unit/mocks/FugueTree-mocks.js

@@ -0,0 +1,52 @@
+import { FugueTree } from "../../../dts/index.js";
+import { Operation, MessageType } from "../../../types/index.js";
+export const DOC_ID = "test-doc";
+export const USER_ID = "test-user";
+/**
+ * A fresh FugueTree with no WebSocket and stable IDs for deterministic tests.
+ */
+export function makeFugueTree(docId, userId) {
+    return new FugueTree(null, docId ? docId : DOC_ID, userId ? userId : USER_ID);
+}
+export const emptyFugueTree = makeFugueTree();
+/**
+ * Build a FugueTree pre-populated with the given string via insertMultiple.
+ */
+export function treeWithText(text) {
+    const tree = makeFugueTree();
+    const msgs = tree.insertMultiple(0, text);
+    msgs.forEach((msg) => {
+        /* already applied inside insertMultiple */
+    });
+    return tree;
+}
+/**
+ * Craft a minimal FugueMessage from one replica so that effect() can be
+ * called on a different replica. The parent ID must match the root node
+ * ({sender:"", counter:0}).
+ */
+export function makeForeignInsertMsg(replicaId, counter, data, documentID = DOC_ID) {
+    return {
+        msgType: MessageType.FUGUE,
+        operation: Operation.INSERT,
+        replicaId,
+        userIdentity: "foreign-user",
+        documentID,
+        id: { sender: replicaId, counter },
+        data,
+        parent: { sender: "", counter: 0 },
+        side: "R",
+    };
+}
+export function makeForeignDeleteMsg(replicaId, targetId, documentID = DOC_ID) {
+    return {
+        msgType: MessageType.FUGUE,
+        operation: Operation.DELETE,
+        replicaId,
+        userIdentity: "foreign-user",
+        documentID,
+        id: targetId,
+        data: null,
+        side: "R",
+    };
+}

package/dist/tests/utils.d.ts

@@ -0,0 +1,9 @@
+import { BragiAST } from "../treesitter/types/AST.js";
+import { Parser } from "web-tree-sitter";
+export declare const getParser: () => Promise<Parser>;
+/**
+ * Safely parses source code into a JS AST and instantly destroys the WASM
+ * memory. Use this in your tests instead of calling getParser() directly!
+ */
+export declare const getSafeAst: (sourceCode: string) => Promise<BragiAST>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/tests/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAGhE,OAAO,EAAY,MAAM,EAAE,MAAM,iBAAiB,CAAC;AA4BnD,eAAO,MAAM,SAAS,QAAa,OAAO,CAAC,MAAM,CAOhD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,UAAU,GAAU,YAAY,MAAM,KAAG,OAAO,CAAC,QAAQ,CAcrE,CAAC"}

package/dist/tests/utils.js

@@ -0,0 +1,47 @@
+import { parseCST } from "../treesitter/types/AST.js";
+import { fileURLToPath } from "url";
+import { join, resolve } from "path";
+import { Language, Parser } from "web-tree-sitter";
+const __filename = fileURLToPath(import.meta.url);
+const __cwd = process.cwd();
+let initPromise = null;
+let latexLanguage = null;
+const ensureInit = async () => {
+    if (initPromise)
+        return initPromise;
+    const treeSitterWasm = join(__cwd, "src", "wasm", "web-tree-sitter.wasm");
+    const latexWasm = join(__cwd, "src", "wasm", "tree-sitter-latex.wasm");
+    initPromise = (async () => {
+        await Parser.init({
+            locateFile: (name) => {
+                // if (name === "tree-sitter.wasm") return resolve(treeSitterWasm);
+                return resolve(treeSitterWasm);
+            },
+        });
+        // Language.load is also a WASM allocation — cache it for the same reason.
+        latexLanguage = await Language.load(resolve(latexWasm));
+    })();
+    return initPromise;
+};
+export const getParser = async () => {
+    await ensureInit();
+    const parser = new Parser();
+    // latexLanguage is guaranteed non-null after ensureInit resolves
+    parser.setLanguage(latexLanguage);
+    return parser;
+};
+/**
+ * Safely parses source code into a JS AST and instantly destroys the WASM
+ * memory. Use this in your tests instead of calling getParser() directly!
+ */
+export const getSafeAst = async (sourceCode) => {
+    const parser = await getParser();
+    const tree = parser.parse(sourceCode);
+    if (!tree || !tree.rootNode) {
+        throw new Error("Parse failed");
+    }
+    const ast = parseCST(tree.rootNode);
+    tree.delete();
+    parser.delete();
+    return ast;
+};

package/dist/treesitter/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./parser.js";
 export * from "./types/index.js";
+export * from "./utils.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/treesitter/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/treesitter/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}

package/dist/treesitter/index.js

@@ -1,2 +1,3 @@
 export * from "./parser.js";
 export * from "./types/index.js";
+export * from "./utils.js";

package/dist/treesitter/utils.d.ts

@@ -0,0 +1,9 @@
+import { AstNode, BragiAST } from "./types/index.js";
+export declare const preoderAstTraversalFunc: (ast: BragiAST, callback: (node: AstNode) => void) => void;
+export declare const postorderAstTraversalFunc: (ast: BragiAST, callback: (node: AstNode) => void) => void;
+export declare const breadthFirstAstTraversalFunc: (ast: BragiAST, callback: (node: AstNode) => void) => void;
+export declare const preoderAstTraversal: (ast: BragiAST) => AstNode[];
+export declare const postorderAstTraversal: (ast: BragiAST) => AstNode[];
+export declare const breadthFirstAstTraversal: (ast: BragiAST) => AstNode[];
+export declare const preorderAstTraversalIterator: (ast: BragiAST) => IterableIterator<AstNode>;
+//# sourceMappingURL=utils.d.ts.map