@dxos/merkle-search-tree 0.8.3 → 0.8.4-main.f9ba587

package/dist/lib/node/index.cjs

@@ -1,994 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var node_exports = {};
-__export(node_exports, {
-  Forest: () => Forest,
-  LWWTree: () => LWWTree,
-  MirrorMultiMap: () => MirrorMultiMap,
-  TreeMut: () => TreeMut,
-  createValue: () => createValue,
-  digestEquals: () => digestEquals,
-  formatDigest: () => formatDigest,
-  getLevel: () => getLevel,
-  getLevelHex: () => getLevelHex,
-  initLWWTreeSyncState: () => initLWWTreeSyncState,
-  makeItem: () => makeItem,
-  randomKey: () => randomKey,
-  randomSample: () => randomSample
-});
-module.exports = __toCommonJS(node_exports);
-var import_util = require("@dxos/util");
-var import_invariant = require("@dxos/invariant");
-var import_util2 = require("@dxos/util");
-var import_util3 = require("@dxos/util");
-var makeItem = async (key, value) => {
-  const keyBytes = textEncoder.encode(key);
-  const data = new Uint8Array(keyBytes.length + value.length);
-  data.set(keyBytes, 0);
-  data.set(value, keyBytes.length);
-  const digest = await crypto.subtle.digest({
-    name: "SHA-256"
-  }, data);
-  return {
-    key,
-    value,
-    digest: new Uint8Array(digest)
-  };
-};
-var getLevel = (digest) => {
-  let level = 0;
-  for (let i = 0; i < digest.length; i++) {
-    const byte = digest[i];
-    if (byte >> 4 === 0) {
-      level++;
-    } else {
-      break;
-    }
-    if ((byte & 15) === 0) {
-      level++;
-    } else {
-      break;
-    }
-  }
-  return level;
-};
-var formatDigest = (digest) => {
-  return (0, import_util.arrayToHex)(digest.buffer);
-};
-var getLevelHex = (digest) => {
-  let level = 0;
-  for (let i = 0; i < digest.length; i++) {
-    if (digest[i] === "0") {
-      level++;
-    } else {
-      break;
-    }
-  }
-  return level;
-};
-var digestEquals = (a, b) => {
-  if (a.length !== b.length) {
-    return false;
-  }
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) {
-      return false;
-    }
-  }
-  return true;
-};
-var textEncoder = new TextEncoder();
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/common/merkle-search-tree/src/forest.ts";
-var Forest = class {
-  constructor() {
-    this.#nodes = /* @__PURE__ */ new Map();
-    this.itemHashOps = 0;
-    this.nodeHashOps = 0;
-    this.#emptyNodeCache = void 0;
-  }
-  #nodes;
-  async createTree(pairs) {
-    const items = await Promise.all([
-      ...pairs
-    ].map(([key, value]) => makeItem2(key, value)));
-    this.itemHashOps += items.length;
-    items.sort((a, b) => a.key < b.key ? -1 : 1);
-    for (let i = 0; i < items.length; i++) {
-      if (i + 1 < items.length && items[i].key === items[i + 1].key) {
-        throw new Error("Duplicate key");
-      }
-    }
-    if (items.length === 0) {
-      return this.#makeNode(0, [], []);
-    }
-    const buildLevel = async (level, from, to) => {
-      (0, import_invariant.invariant)(level >= 0, void 0, {
-        F: __dxlog_file,
-        L: 37,
-        S: this,
-        A: [
-          "level >= 0",
-          ""
-        ]
-      });
-      if (level === 0) {
-        return this.#makeNode(0, items.slice(from, to), []);
-      }
-      let rangeBegin = from;
-      const childItems = [];
-      const childNodes = [];
-      for (let i = from; i < to; i++) {
-        if (items[i].level > level) {
-          throw new Error("BUG - Node level is higher then expected");
-        }
-        if (items[i].level === level) {
-          const node = await buildLevel(level - 1, rangeBegin, i);
-          childNodes.push(node);
-          childItems.push(items[i]);
-          rangeBegin = i + 1;
-        }
-      }
-      childNodes.push(await buildLevel(level - 1, rangeBegin, to));
-      return this.#makeNode(level, childItems, childNodes);
-    };
-    const maxLevel = Math.max(...items.map((item) => item.level));
-    const root = await buildLevel(maxLevel, 0, items.length);
-    return root;
-  }
-  async get(root, key) {
-    const keyLevel = await getKeyLevel(key);
-    let node = this.#nodes.get(root);
-    if (node !== void 0 && node.level < keyLevel) {
-      return {
-        kind: "missing"
-      };
-    }
-    while (node !== void 0) {
-      if (node.level === keyLevel) {
-        for (let i = 0; i < node.items.length; i++) {
-          if (node.items[i].key === key) {
-            return {
-              kind: "present",
-              value: node.items[i].value
-            };
-          }
-        }
-        return {
-          kind: "missing"
-        };
-      } else {
-        let found = false;
-        for (let i = 0; i < node.items.length; i++) {
-          if (node.items[i].key > key) {
-            node = this.#nodes.get(node.children[i]);
-            found = true;
-            break;
-          }
-        }
-        if (!found) {
-          (0, import_invariant.invariant)(node.level > 0, void 0, {
-            F: __dxlog_file,
-            L: 96,
-            S: this,
-            A: [
-              "node!.level > 0",
-              ""
-            ]
-          });
-          node = this.#nodes.get(node.children[node.items.length]);
-        }
-      }
-    }
-    return {
-      kind: "not-available"
-    };
-  }
-  async merge(digest1, digest2, mergeFn) {
-    if (digest1 === digest2) {
-      return digest1;
-    }
-    const node1 = this.#requireNode(digest1);
-    const node2 = this.#requireNode(digest2);
-    if (node2.level < node1.level) {
-      return await this.merge(digest1, await this.#makeNode(node2.level + 1, [], [
-        digest2
-      ]), mergeFn);
-    } else if (node1.level < node2.level) {
-      return await this.merge(await this.#makeNode(node1.level + 1, [], [
-        digest1
-      ]), digest2, mergeFn);
-    }
-    (0, import_invariant.invariant)(node1.level === node2.level, void 0, {
-      F: __dxlog_file,
-      L: 119,
-      S: this,
-      A: [
-        "node1.level === node2.level",
-        ""
-      ]
-    });
-    const resultItems = [];
-    const resultChildren = [];
-    let carry1 = null;
-    let carry2 = null;
-    for (let i1 = 0, i2 = 0; i1 < node1.items.length || i2 < node2.items.length; void 0) {
-      (0, import_invariant.invariant)(i1 <= node1.items.length, void 0, {
-        F: __dxlog_file,
-        L: 132,
-        S: this,
-        A: [
-          "i1 <= node1.items.length",
-          ""
-        ]
-      });
-      (0, import_invariant.invariant)(i2 <= node2.items.length, void 0, {
-        F: __dxlog_file,
-        L: 133,
-        S: this,
-        A: [
-          "i2 <= node2.items.length",
-          ""
-        ]
-      });
-      const key1 = i1 < node1.items.length ? node1.items[i1].key : null;
-      const key2 = i2 < node2.items.length ? node2.items[i2].key : null;
-      (0, import_invariant.invariant)(key1 !== null || key2 !== null, void 0, {
-        F: __dxlog_file,
-        L: 137,
-        S: this,
-        A: [
-          "key1 !== null || key2 !== null",
-          ""
-        ]
-      });
-      const child1 = carry1 !== null ? carry1 : node1.children[i1];
-      const child2 = carry2 !== null ? carry2 : node2.children[i2];
-      if (node1.level > 0) {
-        (0, import_invariant.invariant)(validDigest(child1), void 0, {
-          F: __dxlog_file,
-          L: 142,
-          S: this,
-          A: [
-            "validDigest(child1)",
-            ""
-          ]
-        });
-        (0, import_invariant.invariant)(validDigest(child2), void 0, {
-          F: __dxlog_file,
-          L: 143,
-          S: this,
-          A: [
-            "validDigest(child2)",
-            ""
-          ]
-        });
-      }
-      if (key1 === key2) {
-        if (node1.level > 0) {
-          resultChildren.push(await this.merge(child1, child2, mergeFn));
-        }
-        resultItems.push(await this.#mergeItem(mergeFn, node1.items[i1], node2.items[i2]));
-        carry1 = null;
-        carry2 = null;
-        i1++;
-        i2++;
-      } else if (key2 !== null && (key1 === null || key1 > key2)) {
-        (0, import_invariant.invariant)(key2 !== null, void 0, {
-          F: __dxlog_file,
-          L: 157,
-          S: this,
-          A: [
-            "key2 !== null",
-            ""
-          ]
-        });
-        resultItems.push(await this.#mergeItem(mergeFn, null, node2.items[i2]));
-        if (node1.level > 0) {
-          const [left, right] = await this.#splitAtKey(child1, key2);
-          resultChildren.push(await this.merge(left, child2, mergeFn));
-          carry1 = right;
-          carry2 = null;
-        }
-        i2++;
-      } else {
-        (0, import_invariant.invariant)(key1 !== null, void 0, {
-          F: __dxlog_file,
-          L: 170,
-          S: this,
-          A: [
-            "key1 !== null",
-            ""
-          ]
-        });
-        resultItems.push(await this.#mergeItem(mergeFn, node1.items[i1], null));
-        if (node1.level > 0) {
-          const [left, right] = await this.#splitAtKey(child2, key1);
-          resultChildren.push(await this.merge(child1, left, mergeFn));
-          carry1 = null;
-          carry2 = right;
-        }
-        i1++;
-      }
-    }
-    if (node1.level > 0) {
-      const child1 = carry1 !== null ? carry1 : node1.children[node1.items.length];
-      const child2 = carry2 !== null ? carry2 : node2.children[node2.items.length];
-      resultChildren.push(await this.merge(child1, child2, mergeFn));
-    }
-    return await this.#makeNode(node1.level, resultItems, resultChildren);
-  }
-  async setBatch(root, pairs) {
-    const newTree = await this.createTree(pairs);
-    return await this.merge(root, newTree, async (key, value1, value2) => value2 !== null ? value2 : value1);
-  }
-  async set(root, key, value) {
-    return this.setBatch(root, [
-      [
-        key,
-        value
-      ]
-    ]);
-  }
-  *missingNodes(digest) {
-    const node = this.#nodes.get(digest);
-    if (!node) {
-      yield digest;
-    } else {
-      for (const child of node.children) {
-        yield* this.missingNodes(child);
-      }
-    }
-  }
-  async insertNodes(nodes) {
-    const result = [];
-    for (const node of nodes) {
-      const items = await Promise.all(node.items.map((item) => makeItem2(item.key, item.value)));
-      const { digest } = await makeNode(node.level, items, node.children);
-      (0, import_invariant.invariant)(digest === node.digest, void 0, {
-        F: __dxlog_file,
-        L: 218,
-        S: this,
-        A: [
-          "digest === node.digest",
-          ""
-        ]
-      });
-      this.#nodes.set(node.digest, {
-        level: node.level,
-        digest: node.digest,
-        items,
-        children: node.children
-      });
-      result.push(node.digest);
-    }
-    return result;
-  }
-  async getNodes(digests) {
-    const result = [];
-    for (const digest of digests) {
-      const node = this.#nodes.get(digest);
-      if (!node) {
-        continue;
-      }
-      result.push({
-        level: node.level,
-        digest: node.digest,
-        items: node.items.map((item) => ({
-          key: item.key,
-          value: item.value
-        })),
-        children: node.children
-      });
-    }
-    return result;
-  }
-  treeMut(root) {
-    return new TreeMut(this, root);
-  }
-  formatToString(digest, { pad = 0 } = {}) {
-    const padStr = "  ".repeat(pad);
-    const node = this.#nodes.get(digest);
-    if (!node) {
-      return `${padStr} o (${digest.slice(0, 8)}) NOT AVAILABLE`;
-    }
-    let string = `${padStr} o (${digest.slice(0, 8)}) level=${node.level} size=${node.items.length}
-`;
-    for (let i = 0; i < node.items.length; i++) {
-      if (node.level > 0) {
-        string += this.formatToString(node.children[i], {
-          pad: pad + 1
-        });
-      }
-      string += `${padStr}   - [${node.items[i].itemDigest.slice(0, 8)}] level=${node.items[i].level} ${node.items[i].key.slice(0, 10)} -> ${(0, import_util2.arrayToHex)(node.items[i].value.slice(0, 10).buffer)} 
-`;
-    }
-    if (node.level > 0) {
-      string += this.formatToString(node.children[node.items.length], {
-        pad: pad + 1
-      });
-    }
-    return string;
-  }
-  /**
-  * Items iterator ordered by key.
-  */
-  *items(digest) {
-    const node = this.#requireNode(digest);
-    for (let i = 0; i < node.items.length; i++) {
-      if (node.level > 0) {
-        yield* this.items(node.children[i]);
-      }
-      yield node.items[i];
-    }
-    if (node.level > 0) {
-      yield* this.items(node.children[node.items.length]);
-    }
-  }
-  #requireNode(digest) {
-    (0, import_invariant.invariant)(validDigest(digest), void 0, {
-      F: __dxlog_file,
-      L: 295,
-      S: this,
-      A: [
-        "validDigest(digest)",
-        ""
-      ]
-    });
-    const node = this.#nodes.get(digest);
-    if (!node) {
-      throw new Error(`Node not available: ${digest}`);
-    }
-    return node;
-  }
-  async #mergeItem(mergeFn, item1, item2) {
-    (0, import_invariant.invariant)(item1 !== null || item2 !== null, void 0, {
-      F: __dxlog_file,
-      L: 304,
-      S: this,
-      A: [
-        "item1 !== null || item2 !== null",
-        ""
-      ]
-    });
-    const key = item1?.key ?? item2?.key;
-    if (item1 !== null && item2 !== null && (0, import_util2.arraysEqual)(item1.value, item2.value)) {
-      return item1;
-    } else {
-      const mergeResult = await mergeFn(key, item1?.value ?? null, item2?.value ?? null);
-      if (item1 !== null && (0, import_util2.arraysEqual)(item1.value, mergeResult)) {
-        return item1;
-      } else if (item2 !== null && (0, import_util2.arraysEqual)(item2.value, mergeResult)) {
-        return item2;
-      } else {
-        this.itemHashOps++;
-        return await makeItem2(key, mergeResult);
-      }
-    }
-  }
-  #emptyNodeCache;
-  async #makeNode(level, items, children) {
-    (0, import_invariant.invariant)(level > 0 ? items.length + 1 === children.length : children.length === 0, void 0, {
-      F: __dxlog_file,
-      L: 328,
-      S: this,
-      A: [
-        "level > 0 ? items.length + 1 === children.length : children.length === 0",
-        ""
-      ]
-    });
-    let node;
-    if (level === 0 && items.length === 0) {
-      node = await (this.#emptyNodeCache ??= makeNode(0, [], []));
-    } else {
-      node = await makeNode(level, items, children);
-      this.nodeHashOps++;
-    }
-    if (!this.#nodes.has(node.digest)) {
-      this.#nodes.set(node.digest, node);
-    }
-    return node.digest;
-  }
-  async #splitAtKey(digest, key) {
-    const node = this.#requireNode(digest);
-    let splitIndex = node.items.length;
-    for (let i = 0; i < node.items.length; i++) {
-      if (node.items[i].key === key) {
-        return [
-          await this.#makeNode(node.level, node.items.slice(0, i), node.children.slice(0, i + 1)),
-          await this.#makeNode(node.level, node.items.slice(i + 1), node.children.slice(i + 2))
-        ];
-      }
-      if (node.items[i].key > key) {
-        splitIndex = i;
-        break;
-      }
-    }
-    if (node.level === 0) {
-      if (splitIndex === 0) {
-        return [
-          await this.#makeNode(0, [], []),
-          digest
-        ];
-      } else if (splitIndex === node.items.length) {
-        return [
-          digest,
-          await this.#makeNode(0, [], [])
-        ];
-      }
-      return [
-        await this.#makeNode(node.level, node.items.slice(0, splitIndex), []),
-        await this.#makeNode(node.level, node.items.slice(splitIndex), [])
-      ];
-    } else {
-      const [left, right] = await this.#splitAtKey(node.children[splitIndex], key);
-      return [
-        await this.#makeNode(node.level, node.items.slice(0, splitIndex), [
-          ...node.children.slice(0, splitIndex),
-          left
-        ]),
-        await this.#makeNode(node.level, node.items.slice(splitIndex), [
-          right,
-          ...node.children.slice(splitIndex + 1)
-        ])
-      ];
-    }
-  }
-};
-var TreeMut = class {
-  #forest;
-  #root;
-  constructor(forest, root) {
-    this.#forest = forest;
-    this.#root = root;
-  }
-  get root() {
-    return this.#root;
-  }
-  async get(key) {
-    return this.#forest.get(this.#root, key);
-  }
-  async setBatch(pairs) {
-    this.#root = await this.#forest.setBatch(this.#root, pairs);
-  }
-  async set(key, value) {
-    this.#root = await this.#forest.set(this.#root, key, value);
-  }
-  items() {
-    return this.#forest.items(this.root);
-  }
-};
-var makeNode = async (level, items, children) => {
-  (0, import_invariant.invariant)(level > 0 ? items.length + 1 === children.length : children.length === 0, void 0, {
-    F: __dxlog_file,
-    L: 479,
-    S: void 0,
-    A: [
-      "level > 0 ? items.length + 1 === children.length : children.length === 0",
-      ""
-    ]
-  });
-  const nodeInputData = textEncoder2.encode(items.map((item) => item.itemDigest).join("") + children.join(""));
-  const digest = await crypto.subtle.digest({
-    name: "SHA-256"
-  }, nodeInputData);
-  return {
-    level,
-    digest: formatDigest(new Uint8Array(digest)),
-    items,
-    children
-  };
-};
-var makeItem2 = async (key, value) => {
-  (0, import_invariant.invariant)(typeof key === "string", void 0, {
-    F: __dxlog_file,
-    L: 501,
-    S: void 0,
-    A: [
-      "typeof key === 'string'",
-      ""
-    ]
-  });
-  (0, import_invariant.invariant)(value !== null, void 0, {
-    F: __dxlog_file,
-    L: 502,
-    S: void 0,
-    A: [
-      "value !== null",
-      ""
-    ]
-  });
-  const keyBytes = textEncoder2.encode(key);
-  const keyDigest = await crypto.subtle.digest({
-    name: "SHA-256"
-  }, keyBytes);
-  const keyDigestHex = formatDigest(new Uint8Array(keyDigest));
-  const data = new Uint8Array(keyBytes.length + value.length);
-  data.set(keyBytes, 0);
-  data.set(value, keyBytes.length);
-  const itemDigest = await crypto.subtle.digest({
-    name: "SHA-256"
-  }, data);
-  return {
-    level: getLevelHex(keyDigestHex),
-    key,
-    value,
-    keyDigest: keyDigestHex,
-    itemDigest: formatDigest(new Uint8Array(itemDigest))
-  };
-};
-var getKeyLevel = async (key) => {
-  const keyBytes = textEncoder2.encode(key);
-  const keyDigest = await crypto.subtle.digest({
-    name: "SHA-256"
-  }, keyBytes);
-  const keyDigestHex = formatDigest(new Uint8Array(keyDigest));
-  return getLevelHex(keyDigestHex);
-};
-var textEncoder2 = new TextEncoder();
-var validDigest = (digest) => typeof digest === "string" && digest.length > 0;
-var LWWTree = class _LWWTree {
-  static async new(params) {
-    const tree = new _LWWTree(params);
-    tree.#currentRoot = await tree.#forest.createTree([]);
-    return tree;
-  }
-  #actor;
-  #forest = new Forest();
-  #currentRoot;
-  get currentRoot() {
-    return this.#currentRoot;
-  }
-  constructor(params) {
-    this.#actor = params.actor;
-  }
-  async get(key) {
-    const data = await this.#getData(key);
-    return data?.value;
-  }
-  async setBatch(pairs) {
-    const prevDataBatch = await Promise.all(pairs.map(([key]) => this.#getData(key)));
-    const updates = pairs.map(([key, value], i) => {
-      const prevData = prevDataBatch[i];
-      const newClock = !prevData ? [
-        this.#actor,
-        0
-      ] : [
-        this.#actor,
-        prevData.clock[1] + 1
-      ];
-      const data = this.#encode({
-        clock: newClock,
-        value
-      });
-      return [
-        key,
-        data
-      ];
-    });
-    this.#currentRoot = await this.#forest.setBatch(this.#currentRoot, updates);
-  }
-  async set(key, value) {
-    await this.setBatch([
-      [
-        key,
-        value
-      ]
-    ]);
-  }
-  async receiveSyncMessage(state, message) {
-    await this.#forest.insertNodes(message.nodes);
-    const remoteRoot = message.root ?? state.remoteRoot;
-    if (remoteRoot !== null) {
-      const missing = [
-        ...await this.#forest.missingNodes(remoteRoot)
-      ];
-      if (missing.length === 0) {
-        this.#currentRoot = await this.#forest.merge(remoteRoot, this.#currentRoot, this.#merge.bind(this));
-      } else if (state.remoteRoot !== null && state.remoteRoot !== remoteRoot) {
-        const missingFromPrevRoot = [
-          ...await this.#forest.missingNodes(state.remoteRoot)
-        ];
-        if (missingFromPrevRoot.length === 0) {
-          await this.#forest.merge(state.remoteRoot, this.#currentRoot, this.#merge.bind(this));
-          const missing2 = [
-            ...await this.#forest.missingNodes(remoteRoot)
-          ];
-          if (missing2.length === 0) {
-            this.#currentRoot = await this.#forest.merge(remoteRoot, this.#currentRoot, this.#merge.bind(this));
-          }
-        }
-      }
-    }
-    return {
-      remoteRoot,
-      remoteWant: message.want,
-      needsAck: message.nodes.length > 0
-    };
-  }
-  async generateSyncMessage(state) {
-    if (state.remoteRoot === this.#currentRoot && state.remoteWant.length === 0 && !state.needsAck) {
-      return [
-        state,
-        null
-      ];
-    }
-    const nodes = await this.#forest.getNodes(state.remoteWant);
-    const want = state.remoteRoot === null ? [] : [
-      ...await this.#forest.missingNodes(state.remoteRoot)
-    ];
-    return [
-      {
-        remoteRoot: state.remoteRoot,
-        remoteWant: state.remoteWant,
-        needsAck: false
-      },
-      {
-        root: this.#currentRoot,
-        want,
-        nodes
-      }
-    ];
-  }
-  async #getData(key) {
-    const res = await this.#forest.get(this.#currentRoot, key);
-    switch (res.kind) {
-      case "present": {
-        return this.#decode(res.value);
-      }
-      case "missing":
-        return void 0;
-      case "not-available":
-        throw new Error("Key not available");
-    }
-  }
-  async #merge(key, left, right) {
-    if (!left) {
-      return right;
-    }
-    if (!right) {
-      return left;
-    }
-    const leftData = this.#decode(left);
-    const rightData = this.#decode(right);
-    const cmp = leftData.clock[1] === rightData.clock[1] ? leftData.clock[0].localeCompare(rightData.clock[0]) : leftData.clock[1] - rightData.clock[1];
-    if (cmp >= 0) {
-      return left;
-    } else {
-      return right;
-    }
-  }
-  #decode(value) {
-    return JSON.parse(textDecoder.decode(value));
-  }
-  #encode(data) {
-    const { clock, value } = data;
-    return textEncoder3.encode(JSON.stringify({
-      clock,
-      value
-    }));
-  }
-};
-var initLWWTreeSyncState = () => ({
-  remoteRoot: null,
-  remoteWant: [],
-  needsAck: false
-});
-var textDecoder = new TextDecoder();
-var textEncoder3 = new TextEncoder();
-var MirrorMultiMap = class _MirrorMultiMap {
-  static async new(params) {
-    const tree = new _MirrorMultiMap(params);
-    tree.#currentRoot = await tree.#forest.createTree([]);
-    return tree;
-  }
-  #forest = new Forest();
-  #actor;
-  #currentRoot;
-  #remoteStates = /* @__PURE__ */ new Map();
-  constructor(params) {
-    this.#actor = params.actor;
-  }
-  get localActorId() {
-    return this.#actor;
-  }
-  get currentRoot() {
-    return this.#currentRoot;
-  }
-  get forest() {
-    return this.#forest;
-  }
-  async getLocal(key) {
-    const entry = await this.#forest.get(this.#currentRoot, key);
-    switch (entry?.kind) {
-      case "present":
-        return this.#decode(entry.value);
-      case "missing":
-        return void 0;
-      case "not-available":
-        throw new Error("Unexpected local entry not available");
-    }
-  }
-  async setLocalBatch(pairs) {
-    const updates = pairs.map(([key, value]) => [
-      key,
-      this.#encode(value)
-    ]);
-    this.#currentRoot = await this.#forest.setBatch(this.#currentRoot, updates);
-  }
-  async getFor(actorId, key) {
-    const state = this.#remoteStates.get(actorId);
-    if (!state) {
-      throw new Error(`Unknown actorId: ${actorId}`);
-    }
-    if (!state.remoteRoot) {
-      return void 0;
-    }
-    const entry = await this.#forest.get(state.remoteRoot, key);
-    switch (entry?.kind) {
-      case "present":
-        return this.#decode(entry.value);
-      case "missing":
-        return void 0;
-      case "not-available":
-        throw new Error("Unexpected remote entry not available");
-    }
-  }
-  async setForBatch(actorId, pairs) {
-    const remoteState = this.#remoteStates.get(actorId) ?? initSyncState();
-    const updates = pairs.map(([key, value]) => [
-      key,
-      this.#encode(value)
-    ]);
-    const prevRoot = remoteState.remoteRoot ?? await this.#forest.createTree([]);
-    const nextRoot = await this.#forest.setBatch(prevRoot, updates);
-    this.#remoteStates.set(actorId, {
-      remoteRoot: nextRoot,
-      myRoot: null,
-      remoteWant: remoteState.remoteWant,
-      needsAck: remoteState.needsAck
-    });
-  }
-  async getAll(key) {
-    const result = /* @__PURE__ */ new Map();
-    result.set(this.#actor, await this.getLocal(key));
-    for (const [actorId, _state] of this.#remoteStates) {
-      result.set(actorId, await this.getFor(actorId, key));
-    }
-    return result;
-  }
-  async getDifferent() {
-    const resultByKey = /* @__PURE__ */ new Map();
-    const actors = /* @__PURE__ */ new Set([
-      this.#actor,
-      ...this.#remoteStates.keys()
-    ]);
-    for (const actor of actors) {
-      let root;
-      if (actor === this.#actor) {
-        root = this.#currentRoot;
-      } else {
-        root = this.#remoteStates.get(actor)?.remoteRoot;
-      }
-      if (!root) {
-        continue;
-      }
-      for (const item of this.#forest.items(root)) {
-        let subMap = resultByKey.get(item.key);
-        if (!subMap) {
-          subMap = /* @__PURE__ */ new Map();
-          resultByKey.set(item.key, subMap);
-        }
-        subMap.set(actor, item.value);
-      }
-    }
-    const result = /* @__PURE__ */ new Map();
-    for (const [key, subMap] of resultByKey) {
-      const first = subMap.values().next().value;
-      let allEqual = subMap.size === actors.size;
-      if (allEqual) {
-        for (const value of subMap.values()) {
-          if (!(0, import_util3.arraysEqual)(first, value)) {
-            allEqual = false;
-            break;
-          }
-        }
-      }
-      if (!allEqual) {
-        const resultSubMap = /* @__PURE__ */ new Map();
-        for (const [actorId, value] of subMap) {
-          resultSubMap.set(actorId, this.#decode(value));
-        }
-        result.set(key, resultSubMap);
-      }
-    }
-    return result;
-  }
-  clearActorState(actorId) {
-    this.#remoteStates.delete(actorId);
-  }
-  async receiveSyncMessage(actorId, message) {
-    await this.#forest.insertNodes(message.nodes);
-    const state = this.#remoteStates.get(actorId) ?? initSyncState();
-    const remoteRoot = message.root ?? state.remoteRoot;
-    const newState = {
-      remoteRoot,
-      myRoot: message.remoteRoot ?? state.myRoot,
-      remoteWant: message.want,
-      needsAck: message.nodes.length > 0
-    };
-    this.#remoteStates.set(actorId, newState);
-  }
-  async generateSyncMessage(actorId) {
-    const state = this.#remoteStates.get(actorId) ?? initSyncState();
-    if (state.myRoot === this.#currentRoot && state.remoteWant.length === 0 && !state.needsAck) {
-      return null;
-    }
-    const nodes = await this.#forest.getNodes(state.remoteWant);
-    const want = state.remoteRoot === null ? [] : [
-      ...await this.#forest.missingNodes(state.remoteRoot)
-    ];
-    this.#remoteStates.set(actorId, {
-      remoteRoot: state.remoteRoot,
-      myRoot: state.myRoot,
-      remoteWant: state.remoteWant,
-      needsAck: false
-    });
-    return {
-      root: this.#currentRoot,
-      remoteRoot: state.remoteRoot,
-      want,
-      nodes
-    };
-  }
-  #decode(value) {
-    return JSON.parse(textDecoder2.decode(value));
-  }
-  #encode(data) {
-    return textEncoder4.encode(JSON.stringify(data));
-  }
-};
-var initSyncState = () => ({
-  remoteRoot: null,
-  myRoot: null,
-  remoteWant: [],
-  needsAck: false
-});
-var textDecoder2 = new TextDecoder();
-var textEncoder4 = new TextEncoder();
-var createValue = (source) => new Uint8Array(textEncoder5.encode(source));
-var textEncoder5 = new TextEncoder();
-var randomKey = () => crypto.randomUUID();
-var randomSample = (data, count) => data.toSorted(() => Math.random() - 0.5).slice(0, count);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Forest,
-  LWWTree,
-  MirrorMultiMap,
-  TreeMut,
-  createValue,
-  digestEquals,
-  formatDigest,
-  getLevel,
-  getLevelHex,
-  initLWWTreeSyncState,
-  makeItem,
-  randomKey,
-  randomSample
-});
-//# sourceMappingURL=index.cjs.map