@dxos/merkle-search-tree 0.8.4-main.84f28bd → 0.8.4-main.a4bbb77

package/dist/lib/browser/index.mjs

@@ -61,15 +61,77 @@ var textEncoder = new TextEncoder();
 // src/forest.ts
 import { invariant } from "@dxos/invariant";
 import { arrayToHex as arrayToHex2, arraysEqual } from "@dxos/util";
+function _check_private_redeclaration(obj, privateCollection) {
+  if (privateCollection.has(obj)) {
+    throw new TypeError("Cannot initialize the same private elements twice on an object");
+  }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+  if (descriptor.get) {
+    return descriptor.get.call(receiver);
+  }
+  return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+  if (descriptor.set) {
+    descriptor.set.call(receiver, value);
+  } else {
+    if (!descriptor.writable) {
+      throw new TypeError("attempted to set read only private field");
+    }
+    descriptor.value = value;
+  }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+  if (!privateMap.has(receiver)) {
+    throw new TypeError("attempted to " + action + " private field on non-instance");
+  }
+  return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+  var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+  return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+  _check_private_redeclaration(obj, privateMap);
+  privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+  var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+  _class_apply_descriptor_set(receiver, descriptor, value);
+  return value;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+  if (!privateSet.has(receiver)) {
+    throw new TypeError("attempted to get private field on non-instance");
+  }
+  return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+  _check_private_redeclaration(obj, privateSet);
+  privateSet.add(obj);
+}
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
 var __dxlog_file = "/__w/dxos/dxos/packages/common/merkle-search-tree/src/forest.ts";
+var _nodes = /* @__PURE__ */ new WeakMap();
+var _requireNode = /* @__PURE__ */ new WeakSet();
+var _mergeItem = /* @__PURE__ */ new WeakSet();
+var _emptyNodeCache = /* @__PURE__ */ new WeakMap();
+var _makeNode = /* @__PURE__ */ new WeakSet();
+var _splitAtKey = /* @__PURE__ */ new WeakSet();
 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
@@ -82,7 +144,7 @@ var Forest = class {
       }
     }
     if (items.length === 0) {
-      return this.#makeNode(0, [], []);
+      return _class_private_method_get(this, _makeNode, makeNode).call(this, 0, [], []);
     }
     const buildLevel = async (level, from, to) => {
       invariant(level >= 0, void 0, {
@@ -95,7 +157,7 @@ var Forest = class {
         ]
       });
       if (level === 0) {
-        return this.#makeNode(0, items.slice(from, to), []);
+        return _class_private_method_get(this, _makeNode, makeNode).call(this, 0, items.slice(from, to), []);
       }
       let rangeBegin = from;
       const childItems = [];
@@ -112,7 +174,7 @@ var Forest = class {
         }
       }
       childNodes.push(await buildLevel(level - 1, rangeBegin, to));
-      return this.#makeNode(level, childItems, childNodes);
+      return _class_private_method_get(this, _makeNode, makeNode).call(this, level, childItems, childNodes);
     };
     const maxLevel = Math.max(...items.map((item) => item.level));
     const root = await buildLevel(maxLevel, 0, items.length);
@@ -120,7 +182,7 @@ var Forest = class {
   }
   async get(root, key) {
     const keyLevel = await getKeyLevel(key);
-    let node = this.#nodes.get(root);
+    let node = _class_private_field_get(this, _nodes).get(root);
     if (node !== void 0 && node.level < keyLevel) {
       return {
         kind: "missing"
@@ -143,7 +205,7 @@ var Forest = class {
         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]);
+            node = _class_private_field_get(this, _nodes).get(node.children[i]);
             found = true;
             break;
           }
@@ -158,7 +220,7 @@ var Forest = class {
               ""
             ]
           });
-          node = this.#nodes.get(node.children[node.items.length]);
+          node = _class_private_field_get(this, _nodes).get(node.children[node.items.length]);
         }
       }
     }
@@ -170,14 +232,14 @@ var Forest = class {
     if (digest1 === digest2) {
       return digest1;
     }
-    const node1 = this.#requireNode(digest1);
-    const node2 = this.#requireNode(digest2);
+    const node1 = _class_private_method_get(this, _requireNode, requireNode).call(this, digest1);
+    const node2 = _class_private_method_get(this, _requireNode, requireNode).call(this, digest2);
     if (node2.level < node1.level) {
-      return await this.merge(digest1, await this.#makeNode(node2.level + 1, [], [
+      return await this.merge(digest1, await _class_private_method_get(this, _makeNode, makeNode).call(this, node2.level + 1, [], [
         digest2
       ]), mergeFn);
     } else if (node1.level < node2.level) {
-      return await this.merge(await this.#makeNode(node1.level + 1, [], [
+      return await this.merge(await _class_private_method_get(this, _makeNode, makeNode).call(this, node1.level + 1, [], [
         digest1
       ]), digest2, mergeFn);
     }
@@ -250,7 +312,7 @@ var Forest = class {
         if (node1.level > 0) {
           resultChildren.push(await this.merge(child1, child2, mergeFn));
         }
-        resultItems.push(await this.#mergeItem(mergeFn, node1.items[i1], node2.items[i2]));
+        resultItems.push(await _class_private_method_get(this, _mergeItem, mergeItem).call(this, mergeFn, node1.items[i1], node2.items[i2]));
         carry1 = null;
         carry2 = null;
         i1++;
@@ -265,9 +327,9 @@ var Forest = class {
             ""
           ]
         });
-        resultItems.push(await this.#mergeItem(mergeFn, null, node2.items[i2]));
+        resultItems.push(await _class_private_method_get(this, _mergeItem, mergeItem).call(this, mergeFn, null, node2.items[i2]));
         if (node1.level > 0) {
-          const [left, right] = await this.#splitAtKey(child1, key2);
+          const [left, right] = await _class_private_method_get(this, _splitAtKey, splitAtKey).call(this, child1, key2);
           resultChildren.push(await this.merge(left, child2, mergeFn));
           carry1 = right;
           carry2 = null;
@@ -283,9 +345,9 @@ var Forest = class {
             ""
           ]
         });
-        resultItems.push(await this.#mergeItem(mergeFn, node1.items[i1], null));
+        resultItems.push(await _class_private_method_get(this, _mergeItem, mergeItem).call(this, mergeFn, node1.items[i1], null));
         if (node1.level > 0) {
-          const [left, right] = await this.#splitAtKey(child2, key1);
+          const [left, right] = await _class_private_method_get(this, _splitAtKey, splitAtKey).call(this, child2, key1);
           resultChildren.push(await this.merge(child1, left, mergeFn));
           carry1 = null;
           carry2 = right;
@@ -298,7 +360,7 @@ var Forest = class {
       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);
+    return await _class_private_method_get(this, _makeNode, makeNode).call(this, node1.level, resultItems, resultChildren);
   }
   async setBatch(root, pairs) {
     const newTree = await this.createTree(pairs);
@@ -313,7 +375,7 @@ var Forest = class {
     ]);
   }
   *missingNodes(digest) {
-    const node = this.#nodes.get(digest);
+    const node = _class_private_field_get(this, _nodes).get(digest);
     if (!node) {
       yield digest;
     } else {
@@ -326,7 +388,7 @@ var Forest = class {
     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);
+      const { digest } = await makeNode1(node.level, items, node.children);
       invariant(digest === node.digest, void 0, {
         F: __dxlog_file,
         L: 218,
@@ -336,7 +398,7 @@ var Forest = class {
           ""
         ]
       });
-      this.#nodes.set(node.digest, {
+      _class_private_field_get(this, _nodes).set(node.digest, {
         level: node.level,
         digest: node.digest,
         items,
@@ -349,7 +411,7 @@ var Forest = class {
   async getNodes(digests) {
     const result = [];
     for (const digest of digests) {
-      const node = this.#nodes.get(digest);
+      const node = _class_private_field_get(this, _nodes).get(digest);
       if (!node) {
         continue;
       }
@@ -370,7 +432,7 @@ var Forest = class {
   }
   formatToString(digest, { pad = 0 } = {}) {
     const padStr = "  ".repeat(pad);
-    const node = this.#nodes.get(digest);
+    const node = _class_private_field_get(this, _nodes).get(digest);
     if (!node) {
       return `${padStr} o (${digest.slice(0, 8)}) NOT AVAILABLE`;
     }
@@ -396,7 +458,7 @@ var Forest = class {
   * Items iterator ordered by key.
   */
   *items(digest) {
-    const node = this.#requireNode(digest);
+    const node = _class_private_method_get(this, _requireNode, requireNode).call(this, digest);
     for (let i = 0; i < node.items.length; i++) {
       if (node.level > 0) {
         yield* this.items(node.children[i]);
@@ -407,140 +469,163 @@ var Forest = class {
       yield* this.items(node.children[node.items.length]);
     }
   }
-  #requireNode(digest) {
-    invariant(validDigest(digest), void 0, {
-      F: __dxlog_file,
-      L: 295,
-      S: this,
-      A: [
-        "validDigest(digest)",
-        ""
-      ]
+  constructor() {
+    _class_private_method_init(this, _requireNode);
+    _class_private_method_init(this, _mergeItem);
+    _class_private_method_init(this, _makeNode);
+    _class_private_method_init(this, _splitAtKey);
+    _class_private_field_init(this, _nodes, {
+      writable: true,
+      value: /* @__PURE__ */ new Map()
     });
-    const node = this.#nodes.get(digest);
-    if (!node) {
-      throw new Error(`Node not available: ${digest}`);
-    }
-    return node;
-  }
-  async #mergeItem(mergeFn, item1, item2) {
-    invariant(item1 !== null || item2 !== null, void 0, {
-      F: __dxlog_file,
-      L: 304,
-      S: this,
-      A: [
-        "item1 !== null || item2 !== null",
-        ""
-      ]
+    _define_property(this, "itemHashOps", 0);
+    _define_property(this, "nodeHashOps", 0);
+    _class_private_field_init(this, _emptyNodeCache, {
+      writable: true,
+      value: void 0
     });
-    const key = item1?.key ?? item2?.key;
-    if (item1 !== null && item2 !== null && arraysEqual(item1.value, item2.value)) {
+  }
+};
+function requireNode(digest) {
+  invariant(validDigest(digest), void 0, {
+    F: __dxlog_file,
+    L: 295,
+    S: this,
+    A: [
+      "validDigest(digest)",
+      ""
+    ]
+  });
+  const node = _class_private_field_get(this, _nodes).get(digest);
+  if (!node) {
+    throw new Error(`Node not available: ${digest}`);
+  }
+  return node;
+}
+async function mergeItem(mergeFn, item1, item2) {
+  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 && arraysEqual(item1.value, item2.value)) {
+    return item1;
+  } else {
+    const mergeResult = await mergeFn(key, item1?.value ?? null, item2?.value ?? null);
+    if (item1 !== null && arraysEqual(item1.value, mergeResult)) {
       return item1;
+    } else if (item2 !== null && arraysEqual(item2.value, mergeResult)) {
+      return item2;
     } else {
-      const mergeResult = await mergeFn(key, item1?.value ?? null, item2?.value ?? null);
-      if (item1 !== null && arraysEqual(item1.value, mergeResult)) {
-        return item1;
-      } else if (item2 !== null && arraysEqual(item2.value, mergeResult)) {
-        return item2;
-      } else {
-        this.itemHashOps++;
-        return await makeItem2(key, mergeResult);
-      }
+      this.itemHashOps++;
+      return await makeItem2(key, mergeResult);
     }
   }
-  #emptyNodeCache;
-  async #makeNode(level, items, children) {
-    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++;
+}
+async function makeNode(level, items, children) {
+  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 _class_private_field_set(this, _emptyNodeCache, _class_private_field_get(this, _emptyNodeCache) ?? makeNode1(0, [], []));
+  } else {
+    node = await makeNode1(level, items, children);
+    this.nodeHashOps++;
+  }
+  if (!_class_private_field_get(this, _nodes).has(node.digest)) {
+    _class_private_field_get(this, _nodes).set(node.digest, node);
+  }
+  return node.digest;
+}
+async function splitAtKey(digest, key) {
+  const node = _class_private_method_get(this, _requireNode, requireNode).call(this, digest);
+  let splitIndex = node.items.length;
+  for (let i = 0; i < node.items.length; i++) {
+    if (node.items[i].key === key) {
+      return [
+        await _class_private_method_get(this, _makeNode, makeNode).call(this, node.level, node.items.slice(0, i), node.children.slice(0, i + 1)),
+        await _class_private_method_get(this, _makeNode, makeNode).call(this, node.level, node.items.slice(i + 1), node.children.slice(i + 2))
+      ];
     }
-    if (!this.#nodes.has(node.digest)) {
-      this.#nodes.set(node.digest, node);
+    if (node.items[i].key > key) {
+      splitIndex = i;
+      break;
     }
-    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, [], [])
-        ];
-      }
+  if (node.level === 0) {
+    if (splitIndex === 0) {
       return [
-        await this.#makeNode(node.level, node.items.slice(0, splitIndex), []),
-        await this.#makeNode(node.level, node.items.slice(splitIndex), [])
+        await _class_private_method_get(this, _makeNode, makeNode).call(this, 0, [], []),
+        digest
       ];
-    } else {
-      const [left, right] = await this.#splitAtKey(node.children[splitIndex], key);
+    } else if (splitIndex === node.items.length) {
       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)
-        ])
+        digest,
+        await _class_private_method_get(this, _makeNode, makeNode).call(this, 0, [], [])
       ];
     }
+    return [
+      await _class_private_method_get(this, _makeNode, makeNode).call(this, node.level, node.items.slice(0, splitIndex), []),
+      await _class_private_method_get(this, _makeNode, makeNode).call(this, node.level, node.items.slice(splitIndex), [])
+    ];
+  } else {
+    const [left, right] = await _class_private_method_get(this, _splitAtKey, splitAtKey).call(this, node.children[splitIndex], key);
+    return [
+      await _class_private_method_get(this, _makeNode, makeNode).call(this, node.level, node.items.slice(0, splitIndex), [
+        ...node.children.slice(0, splitIndex),
+        left
+      ]),
+      await _class_private_method_get(this, _makeNode, makeNode).call(this, node.level, node.items.slice(splitIndex), [
+        right,
+        ...node.children.slice(splitIndex + 1)
+      ])
+    ];
   }
-};
+}
+var _forest = /* @__PURE__ */ new WeakMap();
+var _root = /* @__PURE__ */ new WeakMap();
 var TreeMut = class {
-  #forest;
-  #root;
-  constructor(forest, root) {
-    this.#forest = forest;
-    this.#root = root;
-  }
   get root() {
-    return this.#root;
+    return _class_private_field_get(this, _root);
   }
   async get(key) {
-    return this.#forest.get(this.#root, key);
+    return _class_private_field_get(this, _forest).get(_class_private_field_get(this, _root), key);
   }
   async setBatch(pairs) {
-    this.#root = await this.#forest.setBatch(this.#root, pairs);
+    _class_private_field_set(this, _root, await _class_private_field_get(this, _forest).setBatch(_class_private_field_get(this, _root), pairs));
   }
   async set(key, value) {
-    this.#root = await this.#forest.set(this.#root, key, value);
+    _class_private_field_set(this, _root, await _class_private_field_get(this, _forest).set(_class_private_field_get(this, _root), key, value));
   }
   items() {
-    return this.#forest.items(this.root);
+    return _class_private_field_get(this, _forest).items(this.root);
+  }
+  constructor(forest, root) {
+    _class_private_field_init(this, _forest, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_init(this, _root, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_set(this, _forest, forest);
+    _class_private_field_set(this, _root, root);
   }
 };
-var makeNode = async (level, items, children) => {
+var makeNode1 = async (level, items, children) => {
   invariant(level > 0 ? items.length + 1 === children.length : children.length === 0, void 0, {
     F: __dxlog_file,
     L: 479,
@@ -611,37 +696,88 @@ var textEncoder2 = new TextEncoder();
 var validDigest = (digest) => typeof digest === "string" && digest.length > 0;
 
 // src/lww-tree.ts
+function _check_private_redeclaration2(obj, privateCollection) {
+  if (privateCollection.has(obj)) {
+    throw new TypeError("Cannot initialize the same private elements twice on an object");
+  }
+}
+function _class_apply_descriptor_get2(receiver, descriptor) {
+  if (descriptor.get) {
+    return descriptor.get.call(receiver);
+  }
+  return descriptor.value;
+}
+function _class_apply_descriptor_set2(receiver, descriptor, value) {
+  if (descriptor.set) {
+    descriptor.set.call(receiver, value);
+  } else {
+    if (!descriptor.writable) {
+      throw new TypeError("attempted to set read only private field");
+    }
+    descriptor.value = value;
+  }
+}
+function _class_extract_field_descriptor2(receiver, privateMap, action) {
+  if (!privateMap.has(receiver)) {
+    throw new TypeError("attempted to " + action + " private field on non-instance");
+  }
+  return privateMap.get(receiver);
+}
+function _class_private_field_get2(receiver, privateMap) {
+  var descriptor = _class_extract_field_descriptor2(receiver, privateMap, "get");
+  return _class_apply_descriptor_get2(receiver, descriptor);
+}
+function _class_private_field_init2(obj, privateMap, value) {
+  _check_private_redeclaration2(obj, privateMap);
+  privateMap.set(obj, value);
+}
+function _class_private_field_set2(receiver, privateMap, value) {
+  var descriptor = _class_extract_field_descriptor2(receiver, privateMap, "set");
+  _class_apply_descriptor_set2(receiver, descriptor, value);
+  return value;
+}
+function _class_private_method_get2(receiver, privateSet, fn) {
+  if (!privateSet.has(receiver)) {
+    throw new TypeError("attempted to get private field on non-instance");
+  }
+  return fn;
+}
+function _class_private_method_init2(obj, privateSet) {
+  _check_private_redeclaration2(obj, privateSet);
+  privateSet.add(obj);
+}
+var _actor = /* @__PURE__ */ new WeakMap();
+var _forest2 = /* @__PURE__ */ new WeakMap();
+var _currentRoot = /* @__PURE__ */ new WeakMap();
+var _getData = /* @__PURE__ */ new WeakSet();
+var _merge = /* @__PURE__ */ new WeakSet();
+var _decode = /* @__PURE__ */ new WeakSet();
+var _encode = /* @__PURE__ */ new WeakSet();
 var LWWTree = class _LWWTree {
   static async new(params) {
     const tree = new _LWWTree(params);
-    tree.#currentRoot = await tree.#forest.createTree([]);
+    _class_private_field_set2(tree, _currentRoot, await _class_private_field_get2(tree, _forest2).createTree([]));
     return tree;
   }
-  #actor;
-  #forest = new Forest();
-  #currentRoot;
   get currentRoot() {
-    return this.#currentRoot;
-  }
-  constructor(params) {
-    this.#actor = params.actor;
+    return _class_private_field_get2(this, _currentRoot);
   }
   async get(key) {
-    const data = await this.#getData(key);
+    const data = await _class_private_method_get2(this, _getData, getData).call(this, key);
     return data?.value;
   }
   async setBatch(pairs) {
-    const prevDataBatch = await Promise.all(pairs.map(([key]) => this.#getData(key)));
+    const prevDataBatch = await Promise.all(pairs.map(([key]) => _class_private_method_get2(this, _getData, getData).call(this, key)));
     const updates = pairs.map(([key, value], i) => {
       const prevData = prevDataBatch[i];
       const newClock = !prevData ? [
-        this.#actor,
+        _class_private_field_get2(this, _actor),
         0
       ] : [
-        this.#actor,
+        _class_private_field_get2(this, _actor),
         prevData.clock[1] + 1
       ];
-      const data = this.#encode({
+      const data = _class_private_method_get2(this, _encode, encode).call(this, {
         clock: newClock,
         value
       });
@@ -650,7 +786,7 @@ var LWWTree = class _LWWTree {
         data
       ];
     });
-    this.#currentRoot = await this.#forest.setBatch(this.#currentRoot, updates);
+    _class_private_field_set2(this, _currentRoot, await _class_private_field_get2(this, _forest2).setBatch(_class_private_field_get2(this, _currentRoot), updates));
   }
   async set(key, value) {
     await this.setBatch([
@@ -661,25 +797,25 @@ var LWWTree = class _LWWTree {
     ]);
   }
   async receiveSyncMessage(state, message) {
-    await this.#forest.insertNodes(message.nodes);
+    await _class_private_field_get2(this, _forest2).insertNodes(message.nodes);
     const remoteRoot = message.root ?? state.remoteRoot;
     if (remoteRoot !== null) {
       const missing = [
-        ...await this.#forest.missingNodes(remoteRoot)
+        ...await _class_private_field_get2(this, _forest2).missingNodes(remoteRoot)
       ];
       if (missing.length === 0) {
-        this.#currentRoot = await this.#forest.merge(remoteRoot, this.#currentRoot, this.#merge.bind(this));
+        _class_private_field_set2(this, _currentRoot, await _class_private_field_get2(this, _forest2).merge(remoteRoot, _class_private_field_get2(this, _currentRoot), _class_private_method_get2(this, _merge, merge).bind(this)));
       } else if (state.remoteRoot !== null && state.remoteRoot !== remoteRoot) {
         const missingFromPrevRoot = [
-          ...await this.#forest.missingNodes(state.remoteRoot)
+          ...await _class_private_field_get2(this, _forest2).missingNodes(state.remoteRoot)
         ];
         if (missingFromPrevRoot.length === 0) {
-          await this.#forest.merge(state.remoteRoot, this.#currentRoot, this.#merge.bind(this));
+          await _class_private_field_get2(this, _forest2).merge(state.remoteRoot, _class_private_field_get2(this, _currentRoot), _class_private_method_get2(this, _merge, merge).bind(this));
           const missing2 = [
-            ...await this.#forest.missingNodes(remoteRoot)
+            ...await _class_private_field_get2(this, _forest2).missingNodes(remoteRoot)
           ];
           if (missing2.length === 0) {
-            this.#currentRoot = await this.#forest.merge(remoteRoot, this.#currentRoot, this.#merge.bind(this));
+            _class_private_field_set2(this, _currentRoot, await _class_private_field_get2(this, _forest2).merge(remoteRoot, _class_private_field_get2(this, _currentRoot), _class_private_method_get2(this, _merge, merge).bind(this)));
           }
         }
       }
@@ -691,15 +827,15 @@ var LWWTree = class _LWWTree {
     };
   }
   async generateSyncMessage(state) {
-    if (state.remoteRoot === this.#currentRoot && state.remoteWant.length === 0 && !state.needsAck) {
+    if (state.remoteRoot === _class_private_field_get2(this, _currentRoot) && state.remoteWant.length === 0 && !state.needsAck) {
       return [
         state,
         null
       ];
     }
-    const nodes = await this.#forest.getNodes(state.remoteWant);
+    const nodes = await _class_private_field_get2(this, _forest2).getNodes(state.remoteWant);
     const want = state.remoteRoot === null ? [] : [
-      ...await this.#forest.missingNodes(state.remoteRoot)
+      ...await _class_private_field_get2(this, _forest2).missingNodes(state.remoteRoot)
     ];
     return [
       {
@@ -708,51 +844,70 @@ var LWWTree = class _LWWTree {
         needsAck: false
       },
       {
-        root: this.#currentRoot,
+        root: _class_private_field_get2(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");
-    }
+  constructor(params) {
+    _class_private_method_init2(this, _getData);
+    _class_private_method_init2(this, _merge);
+    _class_private_method_init2(this, _decode);
+    _class_private_method_init2(this, _encode);
+    _class_private_field_init2(this, _actor, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_init2(this, _forest2, {
+      writable: true,
+      value: new Forest()
+    });
+    _class_private_field_init2(this, _currentRoot, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_set2(this, _actor, params.actor);
   }
-  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;
+};
+async function getData(key) {
+  const res = await _class_private_field_get2(this, _forest2).get(_class_private_field_get2(this, _currentRoot), key);
+  switch (res.kind) {
+    case "present": {
+      return _class_private_method_get2(this, _decode, decode).call(this, res.value);
     }
+    case "missing":
+      return void 0;
+    case "not-available":
+      throw new Error("Key not available");
   }
-  #decode(value) {
-    return JSON.parse(textDecoder.decode(value));
+}
+async function merge(key, left, right) {
+  if (!left) {
+    return right;
   }
-  #encode(data) {
-    const { clock, value } = data;
-    return textEncoder3.encode(JSON.stringify({
-      clock,
-      value
-    }));
+  if (!right) {
+    return left;
   }
-};
+  const leftData = _class_private_method_get2(this, _decode, decode).call(this, left);
+  const rightData = _class_private_method_get2(this, _decode, decode).call(this, 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;
+  }
+}
+function decode(value) {
+  return JSON.parse(textDecoder.decode(value));
+}
+function encode(data) {
+  const { clock, value } = data;
+  return textEncoder3.encode(JSON.stringify({
+    clock,
+    value
+  }));
+}
 var initLWWTreeSyncState = () => ({
   remoteRoot: null,
   remoteWant: [],
@@ -763,33 +918,82 @@ var textEncoder3 = new TextEncoder();
 
 // src/mirror-multi-map.ts
 import { arraysEqual as arraysEqual2 } from "@dxos/util";
+function _check_private_redeclaration3(obj, privateCollection) {
+  if (privateCollection.has(obj)) {
+    throw new TypeError("Cannot initialize the same private elements twice on an object");
+  }
+}
+function _class_apply_descriptor_get3(receiver, descriptor) {
+  if (descriptor.get) {
+    return descriptor.get.call(receiver);
+  }
+  return descriptor.value;
+}
+function _class_apply_descriptor_set3(receiver, descriptor, value) {
+  if (descriptor.set) {
+    descriptor.set.call(receiver, value);
+  } else {
+    if (!descriptor.writable) {
+      throw new TypeError("attempted to set read only private field");
+    }
+    descriptor.value = value;
+  }
+}
+function _class_extract_field_descriptor3(receiver, privateMap, action) {
+  if (!privateMap.has(receiver)) {
+    throw new TypeError("attempted to " + action + " private field on non-instance");
+  }
+  return privateMap.get(receiver);
+}
+function _class_private_field_get3(receiver, privateMap) {
+  var descriptor = _class_extract_field_descriptor3(receiver, privateMap, "get");
+  return _class_apply_descriptor_get3(receiver, descriptor);
+}
+function _class_private_field_init3(obj, privateMap, value) {
+  _check_private_redeclaration3(obj, privateMap);
+  privateMap.set(obj, value);
+}
+function _class_private_field_set3(receiver, privateMap, value) {
+  var descriptor = _class_extract_field_descriptor3(receiver, privateMap, "set");
+  _class_apply_descriptor_set3(receiver, descriptor, value);
+  return value;
+}
+function _class_private_method_get3(receiver, privateSet, fn) {
+  if (!privateSet.has(receiver)) {
+    throw new TypeError("attempted to get private field on non-instance");
+  }
+  return fn;
+}
+function _class_private_method_init3(obj, privateSet) {
+  _check_private_redeclaration3(obj, privateSet);
+  privateSet.add(obj);
+}
+var _forest3 = /* @__PURE__ */ new WeakMap();
+var _actor2 = /* @__PURE__ */ new WeakMap();
+var _currentRoot2 = /* @__PURE__ */ new WeakMap();
+var _remoteStates = /* @__PURE__ */ new WeakMap();
+var _decode2 = /* @__PURE__ */ new WeakSet();
+var _encode2 = /* @__PURE__ */ new WeakSet();
 var MirrorMultiMap = class _MirrorMultiMap {
   static async new(params) {
     const tree = new _MirrorMultiMap(params);
-    tree.#currentRoot = await tree.#forest.createTree([]);
+    _class_private_field_set3(tree, _currentRoot2, await _class_private_field_get3(tree, _forest3).createTree([]));
     return tree;
   }
-  #forest = new Forest();
-  #actor;
-  #currentRoot;
-  #remoteStates = /* @__PURE__ */ new Map();
-  constructor(params) {
-    this.#actor = params.actor;
-  }
   get localActorId() {
-    return this.#actor;
+    return _class_private_field_get3(this, _actor2);
   }
   get currentRoot() {
-    return this.#currentRoot;
+    return _class_private_field_get3(this, _currentRoot2);
   }
   get forest() {
-    return this.#forest;
+    return _class_private_field_get3(this, _forest3);
   }
   async getLocal(key) {
-    const entry = await this.#forest.get(this.#currentRoot, key);
+    const entry = await _class_private_field_get3(this, _forest3).get(_class_private_field_get3(this, _currentRoot2), key);
     switch (entry?.kind) {
       case "present":
-        return this.#decode(entry.value);
+        return _class_private_method_get3(this, _decode2, decode2).call(this, entry.value);
       case "missing":
         return void 0;
       case "not-available":
@@ -799,22 +1003,22 @@ var MirrorMultiMap = class _MirrorMultiMap {
   async setLocalBatch(pairs) {
     const updates = pairs.map(([key, value]) => [
       key,
-      this.#encode(value)
+      _class_private_method_get3(this, _encode2, encode2).call(this, value)
     ]);
-    this.#currentRoot = await this.#forest.setBatch(this.#currentRoot, updates);
+    _class_private_field_set3(this, _currentRoot2, await _class_private_field_get3(this, _forest3).setBatch(_class_private_field_get3(this, _currentRoot2), updates));
   }
   async getFor(actorId, key) {
-    const state = this.#remoteStates.get(actorId);
+    const state = _class_private_field_get3(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);
+    const entry = await _class_private_field_get3(this, _forest3).get(state.remoteRoot, key);
     switch (entry?.kind) {
       case "present":
-        return this.#decode(entry.value);
+        return _class_private_method_get3(this, _decode2, decode2).call(this, entry.value);
       case "missing":
         return void 0;
       case "not-available":
@@ -822,14 +1026,14 @@ var MirrorMultiMap = class _MirrorMultiMap {
     }
   }
   async setForBatch(actorId, pairs) {
-    const remoteState = this.#remoteStates.get(actorId) ?? initSyncState();
+    const remoteState = _class_private_field_get3(this, _remoteStates).get(actorId) ?? initSyncState();
     const updates = pairs.map(([key, value]) => [
       key,
-      this.#encode(value)
+      _class_private_method_get3(this, _encode2, encode2).call(this, value)
     ]);
-    const prevRoot = remoteState.remoteRoot ?? await this.#forest.createTree([]);
-    const nextRoot = await this.#forest.setBatch(prevRoot, updates);
-    this.#remoteStates.set(actorId, {
+    const prevRoot = remoteState.remoteRoot ?? await _class_private_field_get3(this, _forest3).createTree([]);
+    const nextRoot = await _class_private_field_get3(this, _forest3).setBatch(prevRoot, updates);
+    _class_private_field_get3(this, _remoteStates).set(actorId, {
       remoteRoot: nextRoot,
       myRoot: null,
       remoteWant: remoteState.remoteWant,
@@ -838,8 +1042,8 @@ var MirrorMultiMap = class _MirrorMultiMap {
   }
   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(_class_private_field_get3(this, _actor2), await this.getLocal(key));
+    for (const [actorId, _state] of _class_private_field_get3(this, _remoteStates)) {
       result.set(actorId, await this.getFor(actorId, key));
     }
     return result;
@@ -847,20 +1051,20 @@ var MirrorMultiMap = class _MirrorMultiMap {
   async getDifferent() {
     const resultByKey = /* @__PURE__ */ new Map();
     const actors = /* @__PURE__ */ new Set([
-      this.#actor,
-      ...this.#remoteStates.keys()
+      _class_private_field_get3(this, _actor2),
+      ..._class_private_field_get3(this, _remoteStates).keys()
     ]);
     for (const actor of actors) {
       let root;
-      if (actor === this.#actor) {
-        root = this.#currentRoot;
+      if (actor === _class_private_field_get3(this, _actor2)) {
+        root = _class_private_field_get3(this, _currentRoot2);
       } else {
-        root = this.#remoteStates.get(actor)?.remoteRoot;
+        root = _class_private_field_get3(this, _remoteStates).get(actor)?.remoteRoot;
       }
       if (!root) {
         continue;
       }
-      for (const item of this.#forest.items(root)) {
+      for (const item of _class_private_field_get3(this, _forest3).items(root)) {
         let subMap = resultByKey.get(item.key);
         if (!subMap) {
           subMap = /* @__PURE__ */ new Map();
@@ -884,7 +1088,7 @@ var MirrorMultiMap = class _MirrorMultiMap {
       if (!allEqual) {
         const resultSubMap = /* @__PURE__ */ new Map();
         for (const [actorId, value] of subMap) {
-          resultSubMap.set(actorId, this.#decode(value));
+          resultSubMap.set(actorId, _class_private_method_get3(this, _decode2, decode2).call(this, value));
         }
         result.set(key, resultSubMap);
       }
@@ -892,11 +1096,11 @@ var MirrorMultiMap = class _MirrorMultiMap {
     return result;
   }
   clearActorState(actorId) {
-    this.#remoteStates.delete(actorId);
+    _class_private_field_get3(this, _remoteStates).delete(actorId);
   }
   async receiveSyncMessage(actorId, message) {
-    await this.#forest.insertNodes(message.nodes);
-    const state = this.#remoteStates.get(actorId) ?? initSyncState();
+    await _class_private_field_get3(this, _forest3).insertNodes(message.nodes);
+    const state = _class_private_field_get3(this, _remoteStates).get(actorId) ?? initSyncState();
     const remoteRoot = message.root ?? state.remoteRoot;
     const newState = {
       remoteRoot,
@@ -904,37 +1108,58 @@ var MirrorMultiMap = class _MirrorMultiMap {
       remoteWant: message.want,
       needsAck: message.nodes.length > 0
     };
-    this.#remoteStates.set(actorId, newState);
+    _class_private_field_get3(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) {
+    const state = _class_private_field_get3(this, _remoteStates).get(actorId) ?? initSyncState();
+    if (state.myRoot === _class_private_field_get3(this, _currentRoot2) && state.remoteWant.length === 0 && !state.needsAck) {
       return null;
     }
-    const nodes = await this.#forest.getNodes(state.remoteWant);
+    const nodes = await _class_private_field_get3(this, _forest3).getNodes(state.remoteWant);
     const want = state.remoteRoot === null ? [] : [
-      ...await this.#forest.missingNodes(state.remoteRoot)
+      ...await _class_private_field_get3(this, _forest3).missingNodes(state.remoteRoot)
     ];
-    this.#remoteStates.set(actorId, {
+    _class_private_field_get3(this, _remoteStates).set(actorId, {
       remoteRoot: state.remoteRoot,
       myRoot: state.myRoot,
       remoteWant: state.remoteWant,
       needsAck: false
     });
     return {
-      root: this.#currentRoot,
+      root: _class_private_field_get3(this, _currentRoot2),
       remoteRoot: state.remoteRoot,
       want,
       nodes
     };
   }
-  #decode(value) {
-    return JSON.parse(textDecoder2.decode(value));
-  }
-  #encode(data) {
-    return textEncoder4.encode(JSON.stringify(data));
+  constructor(params) {
+    _class_private_method_init3(this, _decode2);
+    _class_private_method_init3(this, _encode2);
+    _class_private_field_init3(this, _forest3, {
+      writable: true,
+      value: new Forest()
+    });
+    _class_private_field_init3(this, _actor2, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_init3(this, _currentRoot2, {
+      writable: true,
+      value: void 0
+    });
+    _class_private_field_init3(this, _remoteStates, {
+      writable: true,
+      value: /* @__PURE__ */ new Map()
+    });
+    _class_private_field_set3(this, _actor2, params.actor);
   }
 };
+function decode2(value) {
+  return JSON.parse(textDecoder2.decode(value));
+}
+function encode2(data) {
+  return textEncoder4.encode(JSON.stringify(data));
+}
 var initSyncState = () => ({
   remoteRoot: null,
   myRoot: null,