@dxos/merkle-search-tree 0.8.4-main.406dc2a → 0.8.4-main.548089c

package/dist/lib/node-esm/index.mjs

@@ -63,77 +63,11 @@ 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 {
+  #nodes = /* @__PURE__ */ new Map();
+  itemHashOps = 0;
+  nodeHashOps = 0;
   async createTree(pairs) {
     const items = await Promise.all([
       ...pairs
@@ -146,7 +80,7 @@ var Forest = class {
       }
     }
     if (items.length === 0) {
-      return _class_private_method_get(this, _makeNode, makeNode).call(this, 0, [], []);
+      return this.#makeNode(0, [], []);
     }
     const buildLevel = async (level, from, to) => {
       invariant(level >= 0, void 0, {
@@ -159,7 +93,7 @@ var Forest = class {
         ]
       });
       if (level === 0) {
-        return _class_private_method_get(this, _makeNode, makeNode).call(this, 0, items.slice(from, to), []);
+        return this.#makeNode(0, items.slice(from, to), []);
       }
       let rangeBegin = from;
       const childItems = [];
@@ -176,7 +110,7 @@ var Forest = class {
         }
       }
       childNodes.push(await buildLevel(level - 1, rangeBegin, to));
-      return _class_private_method_get(this, _makeNode, makeNode).call(this, level, childItems, childNodes);
+      return this.#makeNode(level, childItems, childNodes);
     };
     const maxLevel = Math.max(...items.map((item) => item.level));
     const root = await buildLevel(maxLevel, 0, items.length);
@@ -184,7 +118,7 @@ var Forest = class {
   }
   async get(root, key) {
     const keyLevel = await getKeyLevel(key);
-    let node = _class_private_field_get(this, _nodes).get(root);
+    let node = this.#nodes.get(root);
     if (node !== void 0 && node.level < keyLevel) {
       return {
         kind: "missing"
@@ -207,7 +141,7 @@ var Forest = class {
         let found = false;
         for (let i = 0; i < node.items.length; i++) {
           if (node.items[i].key > key) {
-            node = _class_private_field_get(this, _nodes).get(node.children[i]);
+            node = this.#nodes.get(node.children[i]);
             found = true;
             break;
           }
@@ -222,7 +156,7 @@ var Forest = class {
               ""
             ]
           });
-          node = _class_private_field_get(this, _nodes).get(node.children[node.items.length]);
+          node = this.#nodes.get(node.children[node.items.length]);
         }
       }
     }
@@ -234,14 +168,14 @@ var Forest = class {
     if (digest1 === digest2) {
       return digest1;
     }
-    const node1 = _class_private_method_get(this, _requireNode, requireNode).call(this, digest1);
-    const node2 = _class_private_method_get(this, _requireNode, requireNode).call(this, digest2);
+    const node1 = this.#requireNode(digest1);
+    const node2 = this.#requireNode(digest2);
     if (node2.level < node1.level) {
-      return await this.merge(digest1, await _class_private_method_get(this, _makeNode, makeNode).call(this, node2.level + 1, [], [
+      return await this.merge(digest1, await this.#makeNode(node2.level + 1, [], [
         digest2
       ]), mergeFn);
     } else if (node1.level < node2.level) {
-      return await this.merge(await _class_private_method_get(this, _makeNode, makeNode).call(this, node1.level + 1, [], [
+      return await this.merge(await this.#makeNode(node1.level + 1, [], [
         digest1
       ]), digest2, mergeFn);
     }
@@ -314,7 +248,7 @@ var Forest = class {
         if (node1.level > 0) {
           resultChildren.push(await this.merge(child1, child2, mergeFn));
         }
-        resultItems.push(await _class_private_method_get(this, _mergeItem, mergeItem).call(this, mergeFn, node1.items[i1], node2.items[i2]));
+        resultItems.push(await this.#mergeItem(mergeFn, node1.items[i1], node2.items[i2]));
         carry1 = null;
         carry2 = null;
         i1++;
@@ -329,9 +263,9 @@ var Forest = class {
             ""
           ]
         });
-        resultItems.push(await _class_private_method_get(this, _mergeItem, mergeItem).call(this, mergeFn, null, node2.items[i2]));
+        resultItems.push(await this.#mergeItem(mergeFn, null, node2.items[i2]));
         if (node1.level > 0) {
-          const [left, right] = await _class_private_method_get(this, _splitAtKey, splitAtKey).call(this, child1, key2);
+          const [left, right] = await this.#splitAtKey(child1, key2);
           resultChildren.push(await this.merge(left, child2, mergeFn));
           carry1 = right;
           carry2 = null;
@@ -347,9 +281,9 @@ var Forest = class {
             ""
           ]
         });
-        resultItems.push(await _class_private_method_get(this, _mergeItem, mergeItem).call(this, mergeFn, node1.items[i1], null));
+        resultItems.push(await this.#mergeItem(mergeFn, node1.items[i1], null));
         if (node1.level > 0) {
-          const [left, right] = await _class_private_method_get(this, _splitAtKey, splitAtKey).call(this, child2, key1);
+          const [left, right] = await this.#splitAtKey(child2, key1);
           resultChildren.push(await this.merge(child1, left, mergeFn));
           carry1 = null;
           carry2 = right;
@@ -362,7 +296,7 @@ var Forest = class {
       const child2 = carry2 !== null ? carry2 : node2.children[node2.items.length];
       resultChildren.push(await this.merge(child1, child2, mergeFn));
     }
-    return await _class_private_method_get(this, _makeNode, makeNode).call(this, node1.level, resultItems, resultChildren);
+    return await this.#makeNode(node1.level, resultItems, resultChildren);
   }
   async setBatch(root, pairs) {
     const newTree = await this.createTree(pairs);
@@ -377,7 +311,7 @@ var Forest = class {
     ]);
   }
   *missingNodes(digest) {
-    const node = _class_private_field_get(this, _nodes).get(digest);
+    const node = this.#nodes.get(digest);
     if (!node) {
       yield digest;
     } else {
@@ -390,7 +324,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 makeNode1(node.level, items, node.children);
+      const { digest } = await makeNode(node.level, items, node.children);
       invariant(digest === node.digest, void 0, {
         F: __dxlog_file,
         L: 218,
@@ -400,7 +334,7 @@ var Forest = class {
           ""
         ]
       });
-      _class_private_field_get(this, _nodes).set(node.digest, {
+      this.#nodes.set(node.digest, {
         level: node.level,
         digest: node.digest,
         items,
@@ -413,7 +347,7 @@ var Forest = class {
   async getNodes(digests) {
     const result = [];
     for (const digest of digests) {
-      const node = _class_private_field_get(this, _nodes).get(digest);
+      const node = this.#nodes.get(digest);
       if (!node) {
         continue;
       }
@@ -434,7 +368,7 @@ var Forest = class {
   }
   formatToString(digest, { pad = 0 } = {}) {
     const padStr = "  ".repeat(pad);
-    const node = _class_private_field_get(this, _nodes).get(digest);
+    const node = this.#nodes.get(digest);
     if (!node) {
       return `${padStr} o (${digest.slice(0, 8)}) NOT AVAILABLE`;
     }
@@ -460,7 +394,7 @@ var Forest = class {
   * Items iterator ordered by key.
   */
   *items(digest) {
-    const node = _class_private_method_get(this, _requireNode, requireNode).call(this, 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]);
@@ -471,163 +405,140 @@ var Forest = class {
       yield* this.items(node.children[node.items.length]);
     }
   }
-  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()
-    });
-    _define_property(this, "itemHashOps", 0);
-    _define_property(this, "nodeHashOps", 0);
-    _class_private_field_init(this, _emptyNodeCache, {
-      writable: true,
-      value: void 0
+  #requireNode(digest) {
+    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;
   }
-};
-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)) {
+  async #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 if (item2 !== null && arraysEqual(item2.value, mergeResult)) {
-      return item2;
     } else {
-      this.itemHashOps++;
-      return await makeItem2(key, mergeResult);
+      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);
+      }
     }
   }
-}
-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))
-      ];
+  #emptyNodeCache = void 0;
+  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++;
     }
-    if (node.items[i].key > key) {
-      splitIndex = i;
-      break;
+    if (!this.#nodes.has(node.digest)) {
+      this.#nodes.set(node.digest, node);
     }
+    return node.digest;
   }
-  if (node.level === 0) {
-    if (splitIndex === 0) {
+  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 _class_private_method_get(this, _makeNode, makeNode).call(this, 0, [], []),
-        digest
+        await this.#makeNode(node.level, node.items.slice(0, splitIndex), []),
+        await this.#makeNode(node.level, node.items.slice(splitIndex), [])
       ];
-    } else if (splitIndex === node.items.length) {
+    } else {
+      const [left, right] = await this.#splitAtKey(node.children[splitIndex], key);
       return [
-        digest,
-        await _class_private_method_get(this, _makeNode, makeNode).call(this, 0, [], [])
+        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)
+        ])
       ];
     }
-    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 _class_private_field_get(this, _root);
+    return this.#root;
   }
   async get(key) {
-    return _class_private_field_get(this, _forest).get(_class_private_field_get(this, _root), key);
+    return this.#forest.get(this.#root, key);
   }
   async setBatch(pairs) {
-    _class_private_field_set(this, _root, await _class_private_field_get(this, _forest).setBatch(_class_private_field_get(this, _root), pairs));
+    this.#root = await this.#forest.setBatch(this.#root, pairs);
   }
   async set(key, value) {
-    _class_private_field_set(this, _root, await _class_private_field_get(this, _forest).set(_class_private_field_get(this, _root), key, value));
+    this.#root = await this.#forest.set(this.#root, key, value);
   }
   items() {
-    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);
+    return this.#forest.items(this.root);
   }
 };
-var makeNode1 = async (level, items, children) => {
+var makeNode = async (level, items, children) => {
   invariant(level > 0 ? items.length + 1 === children.length : children.length === 0, void 0, {
     F: __dxlog_file,
     L: 479,
@@ -698,88 +609,37 @@ 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);
-    _class_private_field_set2(tree, _currentRoot, await _class_private_field_get2(tree, _forest2).createTree([]));
+    tree.#currentRoot = await tree.#forest.createTree([]);
     return tree;
   }
+  #actor;
+  #forest = new Forest();
+  #currentRoot;
   get currentRoot() {
-    return _class_private_field_get2(this, _currentRoot);
+    return this.#currentRoot;
+  }
+  constructor(params) {
+    this.#actor = params.actor;
   }
   async get(key) {
-    const data = await _class_private_method_get2(this, _getData, getData).call(this, key);
+    const data = await this.#getData(key);
     return data?.value;
   }
   async setBatch(pairs) {
-    const prevDataBatch = await Promise.all(pairs.map(([key]) => _class_private_method_get2(this, _getData, getData).call(this, key)));
+    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 ? [
-        _class_private_field_get2(this, _actor),
+        this.#actor,
         0
       ] : [
-        _class_private_field_get2(this, _actor),
+        this.#actor,
         prevData.clock[1] + 1
       ];
-      const data = _class_private_method_get2(this, _encode, encode).call(this, {
+      const data = this.#encode({
         clock: newClock,
         value
       });
@@ -788,7 +648,7 @@ var LWWTree = class _LWWTree {
         data
       ];
     });
-    _class_private_field_set2(this, _currentRoot, await _class_private_field_get2(this, _forest2).setBatch(_class_private_field_get2(this, _currentRoot), updates));
+    this.#currentRoot = await this.#forest.setBatch(this.#currentRoot, updates);
   }
   async set(key, value) {
     await this.setBatch([
@@ -799,25 +659,25 @@ var LWWTree = class _LWWTree {
     ]);
   }
   async receiveSyncMessage(state, message) {
-    await _class_private_field_get2(this, _forest2).insertNodes(message.nodes);
+    await this.#forest.insertNodes(message.nodes);
     const remoteRoot = message.root ?? state.remoteRoot;
     if (remoteRoot !== null) {
       const missing = [
-        ...await _class_private_field_get2(this, _forest2).missingNodes(remoteRoot)
+        ...await this.#forest.missingNodes(remoteRoot)
       ];
       if (missing.length === 0) {
-        _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)));
+        this.#currentRoot = await this.#forest.merge(remoteRoot, this.#currentRoot, this.#merge.bind(this));
       } else if (state.remoteRoot !== null && state.remoteRoot !== remoteRoot) {
         const missingFromPrevRoot = [
-          ...await _class_private_field_get2(this, _forest2).missingNodes(state.remoteRoot)
+          ...await this.#forest.missingNodes(state.remoteRoot)
         ];
         if (missingFromPrevRoot.length === 0) {
-          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));
+          await this.#forest.merge(state.remoteRoot, this.#currentRoot, this.#merge.bind(this));
           const missing2 = [
-            ...await _class_private_field_get2(this, _forest2).missingNodes(remoteRoot)
+            ...await this.#forest.missingNodes(remoteRoot)
           ];
           if (missing2.length === 0) {
-            _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)));
+            this.#currentRoot = await this.#forest.merge(remoteRoot, this.#currentRoot, this.#merge.bind(this));
           }
         }
       }
@@ -829,15 +689,15 @@ var LWWTree = class _LWWTree {
     };
   }
   async generateSyncMessage(state) {
-    if (state.remoteRoot === _class_private_field_get2(this, _currentRoot) && state.remoteWant.length === 0 && !state.needsAck) {
+    if (state.remoteRoot === this.#currentRoot && state.remoteWant.length === 0 && !state.needsAck) {
       return [
         state,
         null
       ];
     }
-    const nodes = await _class_private_field_get2(this, _forest2).getNodes(state.remoteWant);
+    const nodes = await this.#forest.getNodes(state.remoteWant);
     const want = state.remoteRoot === null ? [] : [
-      ...await _class_private_field_get2(this, _forest2).missingNodes(state.remoteRoot)
+      ...await this.#forest.missingNodes(state.remoteRoot)
     ];
     return [
       {
@@ -846,70 +706,51 @@ var LWWTree = class _LWWTree {
         needsAck: false
       },
       {
-        root: _class_private_field_get2(this, _currentRoot),
+        root: this.#currentRoot,
         want,
         nodes
       }
     ];
   }
-  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 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);
+  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");
     }
-    case "missing":
-      return void 0;
-    case "not-available":
-      throw new Error("Key not available");
   }
-}
-async function merge(key, left, right) {
-  if (!left) {
-    return right;
+  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;
+    }
   }
-  if (!right) {
-    return left;
+  #decode(value) {
+    return JSON.parse(textDecoder.decode(value));
   }
-  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;
+  #encode(data) {
+    const { clock, value } = data;
+    return textEncoder3.encode(JSON.stringify({
+      clock,
+      value
+    }));
   }
-}
-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: [],
@@ -920,82 +761,33 @@ 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);
-    _class_private_field_set3(tree, _currentRoot2, await _class_private_field_get3(tree, _forest3).createTree([]));
+    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 _class_private_field_get3(this, _actor2);
+    return this.#actor;
   }
   get currentRoot() {
-    return _class_private_field_get3(this, _currentRoot2);
+    return this.#currentRoot;
   }
   get forest() {
-    return _class_private_field_get3(this, _forest3);
+    return this.#forest;
   }
   async getLocal(key) {
-    const entry = await _class_private_field_get3(this, _forest3).get(_class_private_field_get3(this, _currentRoot2), key);
+    const entry = await this.#forest.get(this.#currentRoot, key);
     switch (entry?.kind) {
       case "present":
-        return _class_private_method_get3(this, _decode2, decode2).call(this, entry.value);
+        return this.#decode(entry.value);
       case "missing":
         return void 0;
       case "not-available":
@@ -1005,22 +797,22 @@ var MirrorMultiMap = class _MirrorMultiMap {
   async setLocalBatch(pairs) {
     const updates = pairs.map(([key, value]) => [
       key,
-      _class_private_method_get3(this, _encode2, encode2).call(this, value)
+      this.#encode(value)
     ]);
-    _class_private_field_set3(this, _currentRoot2, await _class_private_field_get3(this, _forest3).setBatch(_class_private_field_get3(this, _currentRoot2), updates));
+    this.#currentRoot = await this.#forest.setBatch(this.#currentRoot, updates);
   }
   async getFor(actorId, key) {
-    const state = _class_private_field_get3(this, _remoteStates).get(actorId);
+    const state = this.#remoteStates.get(actorId);
     if (!state) {
       throw new Error(`Unknown actorId: ${actorId}`);
     }
     if (!state.remoteRoot) {
       return void 0;
     }
-    const entry = await _class_private_field_get3(this, _forest3).get(state.remoteRoot, key);
+    const entry = await this.#forest.get(state.remoteRoot, key);
     switch (entry?.kind) {
       case "present":
-        return _class_private_method_get3(this, _decode2, decode2).call(this, entry.value);
+        return this.#decode(entry.value);
       case "missing":
         return void 0;
       case "not-available":
@@ -1028,14 +820,14 @@ var MirrorMultiMap = class _MirrorMultiMap {
     }
   }
   async setForBatch(actorId, pairs) {
-    const remoteState = _class_private_field_get3(this, _remoteStates).get(actorId) ?? initSyncState();
+    const remoteState = this.#remoteStates.get(actorId) ?? initSyncState();
     const updates = pairs.map(([key, value]) => [
       key,
-      _class_private_method_get3(this, _encode2, encode2).call(this, value)
+      this.#encode(value)
     ]);
-    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, {
+    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,
@@ -1044,8 +836,8 @@ var MirrorMultiMap = class _MirrorMultiMap {
   }
   async getAll(key) {
     const result = /* @__PURE__ */ new Map();
-    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(this.#actor, await this.getLocal(key));
+    for (const [actorId, _state] of this.#remoteStates) {
       result.set(actorId, await this.getFor(actorId, key));
     }
     return result;
@@ -1053,20 +845,20 @@ var MirrorMultiMap = class _MirrorMultiMap {
   async getDifferent() {
     const resultByKey = /* @__PURE__ */ new Map();
     const actors = /* @__PURE__ */ new Set([
-      _class_private_field_get3(this, _actor2),
-      ..._class_private_field_get3(this, _remoteStates).keys()
+      this.#actor,
+      ...this.#remoteStates.keys()
     ]);
     for (const actor of actors) {
       let root;
-      if (actor === _class_private_field_get3(this, _actor2)) {
-        root = _class_private_field_get3(this, _currentRoot2);
+      if (actor === this.#actor) {
+        root = this.#currentRoot;
       } else {
-        root = _class_private_field_get3(this, _remoteStates).get(actor)?.remoteRoot;
+        root = this.#remoteStates.get(actor)?.remoteRoot;
       }
       if (!root) {
         continue;
       }
-      for (const item of _class_private_field_get3(this, _forest3).items(root)) {
+      for (const item of this.#forest.items(root)) {
         let subMap = resultByKey.get(item.key);
         if (!subMap) {
           subMap = /* @__PURE__ */ new Map();
@@ -1090,7 +882,7 @@ var MirrorMultiMap = class _MirrorMultiMap {
       if (!allEqual) {
         const resultSubMap = /* @__PURE__ */ new Map();
         for (const [actorId, value] of subMap) {
-          resultSubMap.set(actorId, _class_private_method_get3(this, _decode2, decode2).call(this, value));
+          resultSubMap.set(actorId, this.#decode(value));
         }
         result.set(key, resultSubMap);
       }
@@ -1098,11 +890,11 @@ var MirrorMultiMap = class _MirrorMultiMap {
     return result;
   }
   clearActorState(actorId) {
-    _class_private_field_get3(this, _remoteStates).delete(actorId);
+    this.#remoteStates.delete(actorId);
   }
   async receiveSyncMessage(actorId, message) {
-    await _class_private_field_get3(this, _forest3).insertNodes(message.nodes);
-    const state = _class_private_field_get3(this, _remoteStates).get(actorId) ?? initSyncState();
+    await this.#forest.insertNodes(message.nodes);
+    const state = this.#remoteStates.get(actorId) ?? initSyncState();
     const remoteRoot = message.root ?? state.remoteRoot;
     const newState = {
       remoteRoot,
@@ -1110,58 +902,37 @@ var MirrorMultiMap = class _MirrorMultiMap {
       remoteWant: message.want,
       needsAck: message.nodes.length > 0
     };
-    _class_private_field_get3(this, _remoteStates).set(actorId, newState);
+    this.#remoteStates.set(actorId, newState);
   }
   async generateSyncMessage(actorId) {
-    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) {
+    const state = this.#remoteStates.get(actorId) ?? initSyncState();
+    if (state.myRoot === this.#currentRoot && state.remoteWant.length === 0 && !state.needsAck) {
       return null;
     }
-    const nodes = await _class_private_field_get3(this, _forest3).getNodes(state.remoteWant);
+    const nodes = await this.#forest.getNodes(state.remoteWant);
     const want = state.remoteRoot === null ? [] : [
-      ...await _class_private_field_get3(this, _forest3).missingNodes(state.remoteRoot)
+      ...await this.#forest.missingNodes(state.remoteRoot)
     ];
-    _class_private_field_get3(this, _remoteStates).set(actorId, {
+    this.#remoteStates.set(actorId, {
       remoteRoot: state.remoteRoot,
       myRoot: state.myRoot,
       remoteWant: state.remoteWant,
       needsAck: false
     });
     return {
-      root: _class_private_field_get3(this, _currentRoot2),
+      root: this.#currentRoot,
       remoteRoot: state.remoteRoot,
       want,
       nodes
     };
   }
-  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);
+  #decode(value) {
+    return JSON.parse(textDecoder2.decode(value));
+  }
+  #encode(data) {
+    return textEncoder4.encode(JSON.stringify(data));
   }
 };
-function decode2(value) {
-  return JSON.parse(textDecoder2.decode(value));
-}
-function encode2(data) {
-  return textEncoder4.encode(JSON.stringify(data));
-}
 var initSyncState = () => ({
   remoteRoot: null,
   myRoot: null,