reptree 0.9.0 → 1.0.0

package/dist/index.js

@@ -46,24 +46,24 @@ function opIdToString(opId) {
 }
 
 // src/operations.ts
-function isMoveVertexOp(op) {
+function isMoveNodeOp(op) {
   return "parentId" in op;
 }
 function isAnyPropertyOp(op) {
   return "key" in op;
 }
-function newMoveVertexOp(clock, peerId, targetId, parentId) {
+function newMoveNodeOp(clock, peerId, targetId, parentId) {
   return { id: createOpId(clock, peerId), targetId, parentId };
 }
-function newSetVertexPropertyOp(clock, peerId, targetId, key, value) {
+function newSetNodePropertyOp(clock, peerId, targetId, key, value) {
   return { id: createOpId(clock, peerId), targetId, key, value, transient: false };
 }
-function newSetTransientVertexPropertyOp(clock, peerId, targetId, key, value) {
+function newSetTransientNodePropertyOp(clock, peerId, targetId, key, value) {
   return { id: createOpId(clock, peerId), targetId, key, value, transient: true };
 }
 
-// src/VertexState.ts
-var VertexState = class {
+// src/NodeState.ts
+var NodeState = class {
   constructor(id, parentId) {
     this.id = id;
     this.parentId = parentId;
@@ -140,21 +140,31 @@ var VertexState = class {
 };
 
 // src/TreeState.ts
-var TreeState = class {
+var _TreeState = class _TreeState {
   constructor() {
     this.changeCallbacks = /* @__PURE__ */ new Map();
     this.globalChangeCallbacks = /* @__PURE__ */ new Set();
     this.batchedEvents = /* @__PURE__ */ new Map();
-    this.vertices = /* @__PURE__ */ new Map();
-    this.batchTickInterval = setInterval(() => {
-      this.processBatchedEvents();
-    }, 33.3);
+    this.nodes = /* @__PURE__ */ new Map();
   }
   dispose() {
-    clearInterval(this.batchTickInterval);
+    if (this.batchTickTimeout) {
+      clearTimeout(this.batchTickTimeout);
+      this.batchTickTimeout = void 0;
+    }
+    this.batchedEvents.clear();
+  }
+  scheduleBatchProcessing() {
+    if (this.batchTickTimeout) {
+      return;
+    }
+    this.batchTickTimeout = setTimeout(() => {
+      this.batchTickTimeout = void 0;
+      this.processBatchedEvents();
+    }, _TreeState.BATCH_DELAY_MS);
   }
   processBatchedEvents() {
-    for (const [vertexId, events] of this.batchedEvents) {
+    for (const [nodeId, events] of this.batchedEvents) {
       let lastMoveEvent = null;
       let lastChildrenEvent = null;
       const propertyEventsByKey = /* @__PURE__ */ new Map();
@@ -175,24 +185,21 @@ var TreeState = class {
         ...propertyEventsByKey.values()
       ];
       this.globalChangeCallbacks.forEach((listener) => listener(filteredEvents));
-      this.changeCallbacks.get(vertexId)?.forEach((listener) => listener(filteredEvents));
+      this.changeCallbacks.get(nodeId)?.forEach((listener) => listener(filteredEvents));
     }
     this.batchedEvents.clear();
   }
-  getAllVertices() {
-    return Array.from(this.vertices.values());
+  getAllNodes() {
+    return Array.from(this.nodes.values());
   }
-  getVertex(id) {
-    return this.vertices.get(id);
+  getNode(id) {
+    return this.nodes.get(id);
   }
-  getChildrenIds(vertexId) {
-    return this.getVertex(vertexId)?.children ?? [];
+  getChildrenIds(nodeId) {
+    return this.getNode(nodeId)?.children ?? [];
   }
-  getChildren(vertexId) {
-    return this.getChildrenIds(vertexId).map((id) => {
-      const vertex = this.vertices.get(id);
-      return vertex ? vertex : void 0;
-    }).filter((vertex) => vertex !== void 0).sort((a, b) => {
+  getChildren(nodeId) {
+    return this.getChildrenIds(nodeId).map((id) => this.nodes.get(id)).filter((node) => node !== void 0).sort((a, b) => {
       const aDate = a.getProperty("_c");
       const bDate = b.getProperty("_c");
       if (!aDate) return -1;
@@ -200,100 +207,99 @@ var TreeState = class {
       return new Date(aDate).getTime() - new Date(bDate).getTime();
     });
   }
-  moveVertex(vertexId, newParentId) {
-    let vertex = this.getVertex(vertexId);
-    const prevParentId = vertex ? vertex.parentId : void 0;
-    if (!vertex) {
-      vertex = new VertexState(vertexId, newParentId);
-      this.vertices.set(vertexId, vertex);
+  moveNode(nodeId, newParentId) {
+    let node = this.getNode(nodeId);
+    const prevParentId = node ? node.parentId : void 0;
+    if (!node) {
+      node = new NodeState(nodeId, newParentId);
+      this.nodes.set(nodeId, node);
     }
     if (prevParentId === newParentId) {
-      return vertex;
+      return node;
     }
-    vertex.parentId = newParentId;
+    node.parentId = newParentId;
     let childrenInNewParent = null;
     let childrenInOldParent = null;
     if (prevParentId) {
-      const oldParentVertex = this.getVertex(prevParentId);
-      if (oldParentVertex) {
-        oldParentVertex.children = oldParentVertex.children.filter((child) => child !== vertexId);
-        childrenInOldParent = oldParentVertex.children;
+      const oldParentNode = this.getNode(prevParentId);
+      if (oldParentNode) {
+        oldParentNode.children = oldParentNode.children.filter((child) => child !== nodeId);
+        childrenInOldParent = oldParentNode.children;
       } else {
-        console.error(`Old parent vertex not found for ${prevParentId}`);
+        console.error(`Old parent node not found for ${prevParentId}`);
       }
     }
     if (newParentId !== null) {
-      const newParentVertex = this.vertices.get(newParentId);
-      if (newParentVertex) {
-        newParentVertex.children.push(vertexId);
-        childrenInNewParent = newParentVertex.children;
+      const newParentNode = this.nodes.get(newParentId);
+      if (newParentNode) {
+        newParentNode.children.push(nodeId);
+        childrenInNewParent = newParentNode.children;
       } else {
-        console.error(`New parent vertex not found for ${newParentId}`);
+        console.error(`New parent node not found for ${newParentId}`);
       }
     }
     this.notifyChange({
       type: "move",
-      vertexId,
+      nodeId,
       oldParentId: prevParentId,
       newParentId
     });
     if (childrenInNewParent !== null && newParentId !== null) {
       this.notifyChange({
         type: "children",
-        vertexId: newParentId,
-        children: childrenInNewParent.map((id) => this.vertices.get(id))
+        nodeId: newParentId,
+        children: childrenInNewParent.map((id) => this.nodes.get(id))
       });
     }
     if (childrenInOldParent !== null && prevParentId) {
       this.notifyChange({
         type: "children",
-        vertexId: prevParentId,
-        children: childrenInOldParent.map((id) => this.vertices.get(id))
+        nodeId: prevParentId,
+        children: childrenInOldParent.map((id) => this.nodes.get(id))
       });
     }
-    return vertex;
+    return node;
   }
-  setProperty(vertexId, key, value) {
-    const vertex = this.getVertex(vertexId);
-    if (!vertex) {
-      throw new Error(`Vertex ${vertexId} not found`);
+  setProperty(nodeId, key, value) {
+    const node = this.getNode(nodeId);
+    if (!node) {
+      throw new Error(`Node ${nodeId} not found`);
     }
-    vertex.setProperty(key, value);
+    node.setProperty(key, value);
     this.notifyChange({
       type: "property",
-      vertexId,
+      nodeId,
       key,
       value
     });
-    if (vertex.parentId !== null) {
+    if (node.parentId !== null) {
       this.notifyChange({
         type: "children",
-        vertexId: vertex.parentId,
-        children: [vertex]
-        // @TODO: shoulld I set all children or rename this property?
+        nodeId: node.parentId,
+        children: this.getChildren(node.parentId)
       });
     }
   }
-  setTransientProperty(vertexId, key, value) {
-    const vertex = this.getVertex(vertexId);
-    if (vertex) {
-      vertex.setTransientProperty(key, value);
+  setTransientProperty(nodeId, key, value) {
+    const node = this.getNode(nodeId);
+    if (node) {
+      node.setTransientProperty(key, value);
     }
     this.notifyChange({
       type: "property",
-      vertexId,
+      nodeId,
       key,
       value
     });
   }
-  addChangeCallback(vertexId, listener) {
-    if (!this.changeCallbacks.has(vertexId)) {
-      this.changeCallbacks.set(vertexId, /* @__PURE__ */ new Set());
+  addChangeCallback(nodeId, listener) {
+    if (!this.changeCallbacks.has(nodeId)) {
+      this.changeCallbacks.set(nodeId, /* @__PURE__ */ new Set());
     }
-    this.changeCallbacks.get(vertexId).add(listener);
+    this.changeCallbacks.get(nodeId).add(listener);
   }
-  removeChangeCallback(vertexId, listener) {
-    this.changeCallbacks.get(vertexId)?.delete(listener);
+  removeChangeCallback(nodeId, listener) {
+    this.changeCallbacks.get(nodeId)?.delete(listener);
   }
   addGlobalChangeCallback(listener) {
     this.globalChangeCallbacks.add(listener);
@@ -302,23 +308,24 @@ var TreeState = class {
     this.globalChangeCallbacks.delete(listener);
   }
   notifyChange(event) {
-    let events = this.batchedEvents.get(event.vertexId);
+    let events = this.batchedEvents.get(event.nodeId);
     if (!events) {
       events = [];
-      this.batchedEvents.set(event.vertexId, events);
+      this.batchedEvents.set(event.nodeId, events);
     }
     events.push(event);
+    this.scheduleBatchProcessing();
   }
-  printTree(vertexId, indent = "", isLast = true) {
+  printTree(nodeId, indent = "", isLast = true) {
     const prefix = indent + (isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ");
-    let result = prefix + vertexId + "\n";
-    let vertexName = null;
-    if (vertexId !== null) {
-      const vertex = this.getVertex(vertexId);
-      if (vertex) {
-        for (const prop of vertex.getAllProperties()) {
+    let result = prefix + nodeId + "\n";
+    let nodeName = null;
+    if (nodeId !== null) {
+      const node = this.getNode(nodeId);
+      if (node) {
+        for (const prop of node.getAllProperties()) {
           if (prop.key === "name") {
-            vertexName = prop.value;
+            nodeName = prop.value;
           }
           const propPrefix = indent + (isLast ? "    " : "\u2502   ") + "\u2022 ";
           result += `${propPrefix}${prop.key}: ${JSON.stringify(prop.value)}
@@ -326,12 +333,12 @@ var TreeState = class {
         }
       }
     }
-    const children = this.getChildrenIds(vertexId);
+    const children = this.getChildrenIds(nodeId);
     const sortedChildren = [...children].sort((a, b) => {
-      const vertexA = this.getVertex(a);
-      const vertexB = this.getVertex(b);
-      const nameA = vertexA?.getProperty("name");
-      const nameB = vertexB?.getProperty("name");
+      const nodeA = this.getNode(a);
+      const nodeB = this.getNode(b);
+      const nameA = nodeA?.getProperty("name");
+      const nameB = nodeB?.getProperty("name");
       if (nameA && nameB) {
         return nameA.localeCompare(nameB);
       }
@@ -347,6 +354,8 @@ var TreeState = class {
     return result;
   }
 };
+_TreeState.BATCH_DELAY_MS = 33.3;
+var TreeState = _TreeState;
 
 // src/utils/uuid.ts
 var removeDashes = (guid) => guid.replace(/-/g, "");
@@ -355,28 +364,28 @@ function uuid() {
 }
 
 // src/reactive.ts
-function bindVertex(tree, id, schemaOrOptions) {
+function bindNode(tree, id, schemaOrOptions) {
   const isOptions = typeof schemaOrOptions === "object" && schemaOrOptions !== null && (Object.prototype.hasOwnProperty.call(schemaOrOptions, "includeInternalKeys") || Object.prototype.hasOwnProperty.call(schemaOrOptions, "schema"));
   const options = isOptions ? schemaOrOptions : { schema: schemaOrOptions };
   const schema = options.schema;
   const obj = {};
   Object.defineProperties(obj, {
-    $vertex: { get: () => tree.getVertex(id), enumerable: false, configurable: true },
+    $node: { get: () => tree.getNode(id), enumerable: false, configurable: true },
     $id: { get: () => id, enumerable: false, configurable: true },
-    $parentId: { get: () => tree.getVertex(id)?.parentId ?? null, enumerable: false, configurable: true },
-    $parent: { get: () => tree.getVertex(id)?.parent, enumerable: false, configurable: true },
+    $parentId: { get: () => tree.getNode(id)?.parentId ?? null, enumerable: false, configurable: true },
+    $parent: { get: () => tree.getNode(id)?.parent, enumerable: false, configurable: true },
     $children: { get: () => tree.getChildren(id), enumerable: false, configurable: true },
     $childrenIds: { get: () => tree.getChildrenIds(id), enumerable: false, configurable: true },
     $moveTo: {
       value: (parent) => {
         const parentId = typeof parent === "object" && parent !== null ? parent.id || parent.$id : parent;
-        tree.moveVertex(id, parentId);
+        tree.moveNode(id, parentId);
       },
       enumerable: false,
       configurable: true,
       writable: false
     },
-    $delete: { value: () => tree.deleteVertex(id), enumerable: false, configurable: true, writable: false },
+    $delete: { value: () => tree.deleteNode(id), enumerable: false, configurable: true, writable: false },
     $observe: { value: (listener) => tree.observe(id, listener), enumerable: false, configurable: true, writable: false },
     $observeChildren: {
       value: (listener) => tree.observe(id, (events) => {
@@ -388,20 +397,20 @@ function bindVertex(tree, id, schemaOrOptions) {
       configurable: true,
       writable: false
     },
-    $newChild: { value: (props) => tree.getVertex(id).newChild(props), enumerable: false, configurable: true, writable: false },
-    $newNamedChild: { value: (name, props) => tree.getVertex(id).newNamedChild(name, props), enumerable: false, configurable: true, writable: false },
+    $newChild: { value: (props) => tree.getNode(id).newChild(props), enumerable: false, configurable: true, writable: false },
+    $newNamedChild: { value: (name, props) => tree.getNode(id).newNamedChild(name, props), enumerable: false, configurable: true, writable: false },
     $useTransients: {
       value: function(fn) {
         const transientProxy = new Proxy({}, {
           set(_, prop, value) {
             if (typeof prop === "string") {
-              tree.setTransientVertexProperty(id, prop, value);
+              tree.setTransientNodeProperty(id, prop, value);
             }
             return true;
           },
           get(_, prop) {
             if (typeof prop !== "string") return void 0;
-            const rawValue = tree.getVertexProperty(id, prop, true);
+            const rawValue = tree.getNodeProperty(id, prop, true);
             return rawValue;
           }
         });
@@ -432,7 +441,7 @@ function bindVertex(tree, id, schemaOrOptions) {
       if (prop in target) {
         return Reflect.get(target, prop, receiver);
       }
-      const rawValue = tree.getVertexProperty(id, prop, true);
+      const rawValue = tree.getNodeProperty(id, prop, true);
       return rawValue;
     },
     set(target, prop, value) {
@@ -447,46 +456,46 @@ function bindVertex(tree, id, schemaOrOptions) {
           value = res.data;
         }
       }
-      tree.setVertexProperty(id, prop, value);
+      tree.setNodeProperty(id, prop, value);
       return true;
     },
     deleteProperty(_target, prop) {
       if (typeof prop !== "string") {
         return true;
       }
-      tree.setVertexProperty(id, prop, void 0);
+      tree.setNodeProperty(id, prop, void 0);
       return true;
     }
   });
   return proxy;
 }
 
-// src/Vertex.ts
-var Vertex = class {
+// src/Node.ts
+var Node = class {
   constructor(tree, state) {
     this.state = state;
     this._tree = tree;
   }
-  /** Returns the tree this vertex belongs to. */
+  /** Returns the tree this node belongs to. */
   get tree() {
     return this._tree;
   }
   set tree(value) {
     this._tree = value;
   }
-  /** Returns the ID of this vertex. */
+  /** Returns the ID of this node. */
   get id() {
     return this.state.id;
   }
-  /** Returns the name of this vertex. The name is stored as a property with the key 'name'. */
+  /** Returns the name of this node. The name is stored as a property with the key 'name'. */
   get name() {
     return this.getProperty("name");
   }
-  /** Sets the name of this vertex. The name is stored as a property with the key 'name'. */
+  /** Sets the name of this node. The name is stored as a property with the key 'name'. */
   set name(name) {
-    this.tree.setVertexProperty(this.id, "name", name);
+    this.tree.setNodeProperty(this.id, "name", name);
   }
-  /** Returns the creation date of this vertex. The creation date is stored as a property with the key '_c'. */
+  /** Returns the creation date of this node. The creation date is stored as a property with the key '_c'. */
   get createdAt() {
     const createdAt = this.getProperty("_c");
     if (!createdAt) {
@@ -494,41 +503,41 @@ var Vertex = class {
     }
     return new Date(createdAt);
   }
-  /** Returns the ID of the parent vertex of this vertex. */
+  /** Returns the ID of the parent node of this node. */
   get parentId() {
     return this.state.parentId;
   }
-  /** Returns the parent vertex of this vertex. */
+  /** Returns the parent node of this node. */
   get parent() {
     if (!this.parentId) {
       return void 0;
     }
-    return this.tree.getVertex(this.parentId);
+    return this.tree.getNode(this.parentId);
   }
-  /** Returns the children vertices of this vertex. */
+  /** Returns the children nodes of this node. */
   get children() {
     return this.tree.getChildren(this.id);
   }
-  /** Returns the IDs of the children vertices of this vertex. */
+  /** Returns the IDs of the children nodes of this node. */
   get childrenIds() {
     return this.tree.getChildrenIds(this.id);
   }
-  /** Returns the ancestors of this vertex. The first element is the root vertex.
+  /** Returns the ancestors of this node. The first element is the root node.
    * E.g root -> grandparent -> parent.
-   * Doesn't include this vertex in the array.
+   * Doesn't include this node in the array.
    */
   get ancestors() {
     return this.tree.getAncestors(this.id);
   }
-  /** Returns the ID of the root vertex of the tree this vertex belongs to. */
+  /** Returns the ID of the root node of the tree this node belongs to. */
   get treeId() {
     return this.root.id;
   }
-  /** Returns the root vertex of the tree this vertex belongs to. */
+  /** Returns the root node of the tree this node belongs to. */
   get root() {
     const root = this.tree.root;
     if (!root) {
-      throw new Error("Root vertex of the tree is not set");
+      throw new Error("Root node of the tree is not set");
     }
     return root;
   }
@@ -538,48 +547,48 @@ var Vertex = class {
   getChildrenAsTypedArray() {
     return this.children.map((v) => v.getAsTypedObject());
   }
-  /** Creates a new child vertex of this vertex. */
+  /** Creates a new child node of this node. */
   newChild(props) {
-    return this.tree.newVertex(this.id, props);
+    return this.tree.newNode(this.id, props);
   }
-  /** Creates a new named child vertex of this vertex. */
+  /** Creates a new named child node of this node. */
   newNamedChild(name, props) {
-    return this.tree.newNamedVertex(this.id, name, props);
+    return this.tree.newNamedNode(this.id, name, props);
   }
-  /** Sets a property on this vertex. */
+  /** Sets a property on this node. */
   setProperty(key, value) {
     const existingValue = this.getProperty(key, false);
     if (existingValue === value) {
       return;
     }
-    this.tree.setVertexProperty(this.id, key, value);
+    this.tree.setNodeProperty(this.id, key, value);
   }
-  /** Sets a transient property on this vertex. Transient properties are not persisted to the tree and are not included in the state vector. */
+  /** Sets a transient property on this node. Transient properties are not persisted to the tree and are not included in the state vector. */
   setTransientProperty(key, value) {
     const existingValue = this.getProperty(key);
     if (existingValue === value) {
       return;
     }
-    this.tree.setTransientVertexProperty(this.id, key, value);
+    this.tree.setTransientNodeProperty(this.id, key, value);
   }
   /** Promotes all transient (temporary) properties to persistent properties. */
   commitTransients() {
     this.tree.commitTransients(this.id);
   }
-  /** Sets multiple properties on this vertex. */
+  /** Sets multiple properties on this node. */
   setProperties(props) {
     for (const [key, value] of Object.entries(props)) {
       this.setProperty(key, value);
     }
   }
-  /** Returns the value of a property on this vertex. */
+  /** Returns the value of a property on this node. */
   getProperty(key, includingTransient = true) {
-    return this.tree.getVertexProperty(this.id, key, includingTransient);
+    return this.tree.getNodeProperty(this.id, key, includingTransient);
   }
-  /** Returns all properties on this vertex. */
+  /** Returns all properties on this node. */
   getProperties() {
     const props = {};
-    this.tree.getVertexProperties(this.id).forEach((p) => {
+    this.tree.getNodeProperties(this.id).forEach((p) => {
       props[p.key] = p.value;
     });
     return props;
@@ -587,21 +596,21 @@ var Vertex = class {
   findAllChildrenWithProperty(key, value) {
     return this.children.filter((c) => c.getProperty(key) === value);
   }
-  findFirstChildVertexWithProperty(key, value) {
+  findFirstChildNodeWithProperty(key, value) {
     return this.children.find((c) => c.getProperty(key) === value);
   }
   findFirstTypedChildWithProperty(key, value) {
-    return this.findFirstChildVertexWithProperty(key, value)?.getAsTypedObject();
+    return this.findFirstChildNodeWithProperty(key, value)?.getAsTypedObject();
   }
   findAllTypedChildrenWithProperty(key, value) {
     return this.findAllChildrenWithProperty(key, value).map((c) => c.getAsTypedObject());
   }
-  /** Observes changes to this vertex. */
+  /** Observes changes to this node. */
   observe(listener) {
     const unobserve = this.tree.observe(this.id, listener);
     return () => unobserve();
   }
-  /** Observes changes to the children of this vertex. */
+  /** Observes changes to the children of this node. */
   observeChildren(listener) {
     const unobserve = this.tree.observe(this.id, (events) => {
       if (events.some((e) => e.type === "children")) {
@@ -616,14 +625,14 @@ var Vertex = class {
     });
   }
   delete() {
-    this.tree.deleteVertex(this.id);
+    this.tree.deleteNode(this.id);
   }
   moveTo(parent) {
-    this.tree.moveVertex(this.id, parent.id);
+    this.tree.moveNode(this.id, parent.id);
   }
-  /** Returns a live reactive object bound to this vertex. Accepts schema or options. */
+  /** Returns a live reactive object bound to this node. Accepts schema or options. */
   bind(schemaOrOptions) {
-    return bindVertex(this.tree, this.id, schemaOrOptions);
+    return bindNode(this.tree, this.id, schemaOrOptions);
   }
 };
 
@@ -674,7 +683,7 @@ var StateVector = class _StateVector {
   /**
    * Updates the state vector with a newly applied operation.
    * Assumes ranges are sorted and non-overlapping.
-   * 
+   *
    * @param peerId The peer ID of the operation
    * @param counter The counter value of the operation
    */
@@ -735,7 +744,7 @@ var StateVector = class _StateVector {
   }
   /**
    * Updates the state vector with a newly applied operation.
-   * 
+   *
    * @param op The operation that was just applied
    */
   updateFromOp(op) {
@@ -751,7 +760,7 @@ var StateVector = class _StateVector {
   /**
    * Calculates which operation ranges we have that the other state vector is missing
    * by comparing state vectors.
-   * 
+   *
    * @param other The other state vector to compare against
    * @returns Array of operation ID ranges that we have but they don't
    */
@@ -775,7 +784,7 @@ var StateVector = class _StateVector {
   }
   /**
    * Checks if the state vector contains the given operation ID
-   * 
+   *
    * @param opId The operation ID to check
    * @returns true if the operation is in the state vector, false otherwise
    */
@@ -871,50 +880,54 @@ function isJsonValue(v) {
 var _RepTree = class _RepTree {
   /**
    * @param peerId - The peer ID of the current client. Should be unique across all peers.
-   * @param ops - The operations to replicate an existing tree, if not provided - an empty tree will be created without a root vertex
+   * @param ops - The operations to replicate an existing tree, if not provided - an empty tree will be created without a root node
    */
   constructor(peerId, ops) {
-    this.lamportClock = 0;
+    this.moveClock = 0;
+    this.propClock = 0;
     this.moveOps = [];
-    this.setPropertyOps = [];
-    this.propertiesAndTheirOpIds = /* @__PURE__ */ new Map();
+    this.propertyOpsByKey = /* @__PURE__ */ new Map();
     this.transientPropertiesAndTheirOpIds = /* @__PURE__ */ new Map();
     this.localOps = [];
     this.pendingMovesWithMissingParent = /* @__PURE__ */ new Map();
-    this.pendingPropertiesWithMissingVertex = /* @__PURE__ */ new Map();
+    this.pendingPropertiesWithMissingNode = /* @__PURE__ */ new Map();
     this.knownOps = /* @__PURE__ */ new Set();
     this.parentIdBeforeMove = /* @__PURE__ */ new Map();
     this.opAppliedCallbacks = [];
     this._stateVectorEnabled = true;
     this.peerId = peerId;
     this.state = new TreeState();
-    this.stateVector = new StateVector();
+    this.moveStateVector = new StateVector();
+    this.propStateVector = new StateVector();
     if (ops && ops.length > 0) {
       this.applyOps(ops);
       const root = this.root;
       if (!root) {
-        throw new Error("There has to be a root vertex in the operations");
+        throw new Error("There has to be a root node in the operations");
       }
     } else {
-      this.ensureNullVertex();
+      this.ensureNullNode();
     }
   }
+  dispose() {
+    this.state.dispose();
+  }
   get root() {
-    if (!this.rootVertexId) {
-      const vertices = this.state.getAllVertices();
-      for (const vertex of vertices) {
-        if (vertex.parentId === null && vertex.id !== _RepTree.NULL_VERTEX_ID) {
-          this.rootVertexId = vertex.id;
-          return new Vertex(this, vertex);
+    if (!this.rootNodeId) {
+      const nodes = this.state.getAllNodes();
+      for (const node of nodes) {
+        if (node.parentId === null && node.id !== _RepTree.NULL_NODE_ID) {
+          this.rootNodeId = node.id;
+          return new Node(this, node);
         }
       }
       return void 0;
     }
-    const rootVertex = this.state.getVertex(this.rootVertexId);
-    if (!rootVertex) {
-      throw new Error("Root vertex not found");
+    const rootNode = this.state.getNode(this.rootNodeId);
+    if (!rootNode) {
+      throw new Error("Root node not found");
     }
-    return new Vertex(this, rootVertex);
+    return new Node(this, rootNode);
   }
   replicate(newPeerId) {
     return new _RepTree(newPeerId, this.getAllOps());
@@ -923,54 +936,54 @@ var _RepTree = class _RepTree {
     return this.moveOps;
   }
   getAllOps() {
-    return [...this.moveOps, ...this.setPropertyOps];
+    return [...this.moveOps, ...this.getPropertyOps()];
   }
-  getVertex(vertexId) {
-    const vertex = this.state.getVertex(vertexId);
-    return vertex ? new Vertex(this, vertex) : void 0;
+  getNode(nodeId) {
+    const node = this.state.getNode(nodeId);
+    return node ? new Node(this, node) : void 0;
   }
-  getAllVertices() {
-    return this.state.getAllVertices().map((v) => new Vertex(this, v));
+  getAllNodes() {
+    return this.state.getAllNodes().map((v) => new Node(this, v));
   }
-  getParent(vertexId) {
-    const parentId = this.state.getVertex(vertexId)?.parentId;
-    const parent = parentId ? this.state.getVertex(parentId) : void 0;
-    return parent ? new Vertex(this, parent) : void 0;
+  getParent(nodeId) {
+    const parentId = this.state.getNode(nodeId)?.parentId;
+    const parent = parentId ? this.state.getNode(parentId) : void 0;
+    return parent ? new Node(this, parent) : void 0;
   }
-  getChildren(vertexId) {
-    return this.state.getChildren(vertexId).map((v) => new Vertex(this, v));
+  getChildren(nodeId) {
+    return this.state.getChildren(nodeId).map((v) => new Node(this, v));
   }
-  getChildrenIds(vertexId) {
-    return this.state.getChildrenIds(vertexId);
+  getChildrenIds(nodeId) {
+    return this.state.getChildrenIds(nodeId);
   }
-  /** Returns the ancestors of the given vertex. The first element is the root vertex. */
-  getAncestors(vertexId) {
+  /** Returns the ancestors of the given node. The first element is the root node. */
+  getAncestors(nodeId) {
     const ancestors = [];
-    let currentVertex = this.state.getVertex(vertexId);
-    while (currentVertex && currentVertex.parentId) {
-      const parentVertex = this.state.getVertex(currentVertex.parentId);
-      if (parentVertex) {
-        ancestors.push(new Vertex(this, parentVertex));
-        currentVertex = parentVertex;
+    let currentNode = this.state.getNode(nodeId);
+    while (currentNode && currentNode.parentId) {
+      const parentNode = this.state.getNode(currentNode.parentId);
+      if (parentNode) {
+        ancestors.push(new Node(this, parentNode));
+        currentNode = parentNode;
       } else {
         break;
       }
     }
     return ancestors;
   }
-  getVertexProperty(vertexId, key, includingTransient = true) {
-    const vertex = this.state.getVertex(vertexId);
-    if (!vertex) {
+  getNodeProperty(nodeId, key, includingTransient = true) {
+    const node = this.state.getNode(nodeId);
+    if (!node) {
       return void 0;
     }
-    return vertex.getProperty(key, includingTransient);
+    return node.getProperty(key, includingTransient);
   }
-  getVertexProperties(vertexId) {
-    const vertex = this.state.getVertex(vertexId);
-    if (!vertex) {
+  getNodeProperties(nodeId) {
+    const node = this.state.getNode(nodeId);
+    if (!node) {
       return [];
     }
-    return vertex.getAllProperties();
+    return node.getAllProperties();
   }
   /**
    * Returns all local operations and clears the local operations list.
@@ -982,158 +995,144 @@ var _RepTree = class _RepTree {
     return ops;
   }
   /**
-   * This is the first vertex that will contain all other vertices.
+   * This is the first node that will contain all other nodes.
    * If you plan to replicate a tree then don't use this method and instead merge
-   * in the ops from another tree (that will also contain the root vertex).
-   * @returns The root vertex
+   * in the ops from another tree (that will also contain the root node).
+   * @returns The root node
    */
   createRoot() {
-    if (this.rootVertexId) {
-      throw new Error("Root vertex already exists");
+    if (this.rootNodeId) {
+      throw new Error("Root node already exists");
     }
-    this.rootVertexId = this.newVertexInternalWithUUID(null);
-    const rootVertex = this.state.getVertex(this.rootVertexId);
-    if (!rootVertex) {
-      throw new Error("Root vertex not found");
+    this.rootNodeId = this.newNodeInternalWithUUID(null);
+    const rootNode = this.state.getNode(this.rootNodeId);
+    if (!rootNode) {
+      throw new Error("Root node not found");
     }
-    return new Vertex(this, rootVertex);
+    return new Node(this, rootNode);
   }
-  newVertex(parentId, props = null) {
+  newNode(parentId, props = null) {
     const typedProps = props;
-    const vertexId = this.newVertexInternalWithUUID(parentId);
+    const nodeId = this.newNodeInternalWithUUID(parentId);
     if (typedProps) {
-      this.setVertexProperties(vertexId, typedProps);
+      this.setNodeProperties(nodeId, typedProps);
     }
-    const vertex = this.state.getVertex(vertexId);
-    if (!vertex) {
-      throw new Error("Failed to create vertex");
+    const node = this.state.getNode(nodeId);
+    if (!node) {
+      throw new Error("Failed to create node");
     }
-    return new Vertex(this, vertex);
+    return new Node(this, node);
   }
-  newNamedVertex(parentId, name, props = null) {
+  newNamedNode(parentId, name, props = null) {
     const typedProps = props;
-    const vertexId = this.newVertexInternalWithUUID(parentId);
+    const nodeId = this.newNodeInternalWithUUID(parentId);
     if (typedProps) {
-      this.setVertexProperties(vertexId, typedProps);
+      this.setNodeProperties(nodeId, typedProps);
     }
-    this.setVertexProperty(vertexId, "name", name);
-    const vertex = this.state.getVertex(vertexId);
-    if (!vertex) {
-      throw new Error("Failed to create named vertex");
+    this.setNodeProperty(nodeId, "name", name);
+    const node = this.state.getNode(nodeId);
+    if (!node) {
+      throw new Error("Failed to create named node");
     }
-    return new Vertex(this, vertex);
+    return new Node(this, node);
   }
-  moveVertex(vertexId, parentId) {
-    this.lamportClock++;
-    const op = newMoveVertexOp(this.lamportClock, this.peerId, vertexId, parentId);
+  moveNode(nodeId, parentId) {
+    this.moveClock++;
+    const op = newMoveNodeOp(this.moveClock, this.peerId, nodeId, parentId);
     this.localOps.push(op);
     this.applyMove(op);
   }
-  deleteVertex(vertexId) {
-    this.moveVertex(vertexId, _RepTree.NULL_VERTEX_ID);
+  deleteNode(nodeId) {
+    this.moveNode(nodeId, _RepTree.NULL_NODE_ID);
   }
-  setTransientVertexProperty(vertexId, key, value) {
+  setTransientNodeProperty(nodeId, key, value) {
     if (!isJsonValue(value)) {
       throw new Error(`Unsupported transient property value for key "${key}"`);
     }
-    this.lamportClock++;
-    const op = newSetTransientVertexPropertyOp(this.lamportClock, this.peerId, vertexId, key, value);
+    this.propClock++;
+    const op = newSetTransientNodePropertyOp(this.propClock, this.peerId, nodeId, key, value);
     this.localOps.push(op);
     this.applyProperty(op);
   }
   /**
    * Promotes all transient (temporary) properties to persistent properties.
-   * @param vertexId - The ID of the vertex to commit transients for.
-   * @returns 
+   * @param nodeId - The ID of the node to commit transients for.
+   * @returns
    */
-  commitTransients(vertexId) {
-    const vertex = this.state.getVertex(vertexId);
-    if (!vertex) {
+  commitTransients(nodeId) {
+    const node = this.state.getNode(nodeId);
+    if (!node) {
       return;
     }
-    const transientProps = vertex.getTransientProperties();
+    const transientProps = node.getTransientProperties();
     for (const prop of transientProps) {
-      this.setVertexProperty(vertexId, prop.key, prop.value);
+      this.setNodeProperty(nodeId, prop.key, prop.value);
     }
     for (const prop of transientProps) {
-      this.transientPropertiesAndTheirOpIds.delete(`${prop.key}@${vertexId}`);
-    }
-    vertex.clearAllTransientProperties();
-  }
-  setVertexProperty(vertexId, key, value) {
-    const isJsonValue2 = (v) => {
-      if (v === void 0) return true;
-      if (v === null) return true;
-      const t = typeof v;
-      if (t === "string" || t === "number" || t === "boolean") return true;
-      if (t === "bigint" || t === "function" || t === "symbol") return false;
-      if (Array.isArray(v)) return v.every(isJsonValue2);
-      if (t === "object") {
-        if (v instanceof Date) return false;
-        if (v instanceof Map || v instanceof Set || v instanceof RegExp) return false;
-        if (ArrayBuffer.isView(v)) return false;
-        const proto = Object.getPrototypeOf(v);
-        if (proto !== Object.prototype && proto !== null) return false;
-        for (const val of Object.values(v)) {
-          if (!isJsonValue2(val)) return false;
-        }
-        return true;
-      }
-      return false;
-    };
-    if (!isJsonValue2(value)) {
+      this.transientPropertiesAndTheirOpIds.delete(`${prop.key}@${nodeId}`);
+    }
+    node.clearAllTransientProperties();
+  }
+  setNodeProperty(nodeId, key, value) {
+    if (!isJsonValue(value)) {
       throw new Error(`Unsupported property value for key "${key}"`);
     }
-    this.lamportClock++;
-    const op = newSetVertexPropertyOp(this.lamportClock, this.peerId, vertexId, key, value);
+    this.propClock++;
+    const op = newSetNodePropertyOp(this.propClock, this.peerId, nodeId, key, value);
     this.localOps.push(op);
     this.applyProperty(op);
   }
-  setVertexProperties(vertexId, props) {
+  setNodeProperties(nodeId, props) {
     const typedProps = props;
     for (const [key, value] of Object.entries(typedProps)) {
-      this.setVertexProperty(vertexId, key, value);
+      this.setNodeProperty(nodeId, key, value);
     }
   }
-  getVertexByPath(path) {
+  getNodeByPath(path) {
     path = path.replace(/^\/+/, "");
     path = path.replace(/\/+$/, "");
-    const pathParts = path.split("/");
-    if (!this.rootVertexId) {
+    const root = this.root;
+    if (!root) {
       return void 0;
     }
-    const root = this.state.getVertex(this.rootVertexId);
-    if (!root) {
-      throw new Error("The root vertex is not found");
+    if (path === "") {
+      return root;
     }
-    const vertex = this.getVertexByPathArray(new Vertex(this, root), pathParts);
-    return vertex;
+    return this.getNodeByPathArray(root, path.split("/"));
   }
-  getVertexByPathArray(vertex, path) {
+  getNodeByPathArray(node, path) {
     if (path.length === 0) {
-      return vertex ?? void 0;
+      return node ?? void 0;
     }
     const targetName = path[0];
-    const children = this.getChildren(vertex.id);
+    const children = this.getChildren(node.id);
     for (const child of children) {
       if (child.getProperty("name") === targetName) {
-        return this.getVertexByPathArray(child, path.slice(1));
+        return this.getNodeByPathArray(child, path.slice(1));
       }
     }
     return void 0;
   }
   printTree() {
-    if (!this.rootVertexId) {
+    if (!this.rootNodeId) {
       return "";
     }
-    return this.state.printTree(this.rootVertexId);
+    return this.state.printTree(this.rootNodeId);
   }
   merge(ops) {
     this.applyOps(ops);
   }
   applyOps(ops) {
-    for (const op of ops) {
-      if (this.knownOps.has(opIdToString(op.id))) {
+    const moveOps = ops.filter((op) => isMoveNodeOp(op));
+    const propertyOps = ops.filter((op) => isAnyPropertyOp(op));
+    for (const op of moveOps) {
+      if (this.knownOps.has(this.getOpKey(op))) {
+        continue;
+      }
+      this.applyOperation(op);
+    }
+    for (const op of propertyOps) {
+      if (this.knownOps.has(this.getOpKey(op))) {
         continue;
       }
       this.applyOperation(op);
@@ -1141,7 +1140,7 @@ var _RepTree = class _RepTree {
   }
   /** Applies operations in an optimized way, sorting move ops by OpId to avoid undo-do-redo cycles */
   applyOpsOptimizedForLotsOfMoves(ops) {
-    const newMoveOps = ops.filter((op) => isMoveVertexOp(op) && !this.knownOps.has(opIdToString(op.id)));
+    const newMoveOps = ops.filter((op) => isMoveNodeOp(op) && !this.knownOps.has(this.getOpKey(op)));
     if (newMoveOps.length > 0) {
       const allMoveOps = [...this.moveOps, ...newMoveOps];
       allMoveOps.sort((a, b) => compareOpId(a.id, b.id));
@@ -1150,7 +1149,7 @@ var _RepTree = class _RepTree {
         this.applyMove(op);
       }
     }
-    const propertyOps = ops.filter((op) => isAnyPropertyOp(op) && !this.knownOps.has(opIdToString(op.id)));
+    const propertyOps = ops.filter((op) => isAnyPropertyOp(op) && !this.knownOps.has(this.getOpKey(op)));
     for (let i = 0, len = propertyOps.length; i < len; i++) {
       const op = propertyOps[i];
       this.applyProperty(op);
@@ -1160,10 +1159,10 @@ var _RepTree = class _RepTree {
     if (this.root?.id !== other.root?.id) {
       return false;
     }
-    if (!this.rootVertexId) {
+    if (!this.rootNodeId) {
       return true;
     }
-    return _RepTree.compareVertices(this.rootVertexId, this, other);
+    return _RepTree.compareNodes(this.rootNodeId, this, other);
   }
   compareMoveOps(other) {
     const movesA = this.moveOps;
@@ -1181,65 +1180,65 @@ var _RepTree = class _RepTree {
   /** Checks if the given `ancestorId` is an ancestor of `childId` in the tree */
   isAncestor(childId, ancestorId) {
     let targetId = childId;
-    let vertex;
-    const visitedVertices = /* @__PURE__ */ new Set();
-    while (vertex = this.state.getVertex(targetId)) {
-      if (vertex.parentId === ancestorId) return true;
-      if (!vertex.parentId) return false;
-      if (visitedVertices.has(targetId)) {
+    let node;
+    const visitedNodes = /* @__PURE__ */ new Set();
+    while (node = this.state.getNode(targetId)) {
+      if (node.parentId === ancestorId) return true;
+      if (!node.parentId) return false;
+      if (visitedNodes.has(targetId)) {
         console.error(`isAncestor: cycle detected in the tree structure.`);
         return false;
       }
-      visitedVertices.add(targetId);
-      targetId = vertex.parentId;
+      visitedNodes.add(targetId);
+      targetId = node.parentId;
     }
     return false;
   }
-  observeVertex(vertexId, callback) {
-    const vertex = this.getVertex(vertexId);
-    if (vertex) {
-      callback(vertex);
+  observeNode(nodeId, callback) {
+    const node = this.getNode(nodeId);
+    if (node) {
+      callback(node);
     }
-    const unsubscribe = this.observe(vertexId, (_) => {
-      const vertex2 = this.getVertex(vertexId);
-      if (vertex2) {
-        callback(vertex2);
+    const unsubscribe = this.observe(nodeId, (_) => {
+      const node2 = this.getNode(nodeId);
+      if (node2) {
+        callback(node2);
       }
     });
     return () => {
       unsubscribe();
     };
   }
-  observeVertexMove(callback) {
+  observeNodeMove(callback) {
     const listener = (events) => {
       const moveEvent = events.find((e) => e.type === "move");
       if (moveEvent) {
-        const vertex = this.getVertex(moveEvent.vertexId);
-        if (vertex) {
-          callback(vertex, moveEvent.oldParentId === void 0);
+        const node = this.getNode(moveEvent.nodeId);
+        if (node) {
+          callback(node, moveEvent.oldParentId === void 0);
         }
       }
     };
     this.state.addGlobalChangeCallback(listener);
     return () => this.state.removeGlobalChangeCallback(listener);
   }
-  observe(vertexId, callback) {
-    this.state.addChangeCallback(vertexId, callback);
-    return () => this.state.removeChangeCallback(vertexId, callback);
+  observe(nodeId, callback) {
+    this.state.addChangeCallback(nodeId, callback);
+    return () => this.state.removeChangeCallback(nodeId, callback);
   }
   observeOpApplied(callback) {
     this.opAppliedCallbacks.push(callback);
     return () => this.opAppliedCallbacks = this.opAppliedCallbacks.filter((l) => l !== callback);
   }
-  static compareVertices(vertexId, treeA, treeB) {
-    const childrenA = treeA.state.getChildrenIds(vertexId);
-    const childrenB = treeB.state.getChildrenIds(vertexId);
+  static compareNodes(nodeId, treeA, treeB) {
+    const childrenA = treeA.state.getChildrenIds(nodeId);
+    const childrenB = treeB.state.getChildrenIds(nodeId);
     if (childrenA.length !== childrenB.length) {
       return false;
     }
-    if (vertexId !== null) {
-      const propertiesA = treeA.getVertexProperties(vertexId);
-      const propertiesB = treeB.getVertexProperties(vertexId);
+    if (nodeId !== null) {
+      const propertiesA = treeA.getNodeProperties(nodeId);
+      const propertiesB = treeB.getNodeProperties(nodeId);
       if (propertiesA.length !== propertiesB.length) {
         return false;
       }
@@ -1253,39 +1252,44 @@ var _RepTree = class _RepTree {
       if (!childrenB.includes(childId)) {
         return false;
       }
-      if (!_RepTree.compareVertices(childId, treeA, treeB)) {
+      if (!_RepTree.compareNodes(childId, treeA, treeB)) {
         return false;
       }
     }
     return true;
   }
-  newVertexInternal(vertexId, parentId) {
-    this.lamportClock++;
-    const op = newMoveVertexOp(this.lamportClock, this.peerId, vertexId, parentId);
+  newNodeInternal(nodeId, parentId) {
+    this.moveClock++;
+    const op = newMoveNodeOp(this.moveClock, this.peerId, nodeId, parentId);
     this.localOps.push(op);
     this.applyMove(op);
-    this.setVertexProperty(vertexId, "_c", (/* @__PURE__ */ new Date()).toISOString());
-    return vertexId;
+    this.setNodeProperty(nodeId, "_c", (/* @__PURE__ */ new Date()).toISOString());
+    return nodeId;
   }
-  newVertexInternalWithUUID(parentId) {
-    const vertexId = uuid();
-    return this.newVertexInternal(vertexId, parentId);
+  newNodeInternalWithUUID(parentId) {
+    const nodeId = uuid();
+    return this.newNodeInternal(nodeId, parentId);
   }
-  ensureNullVertex() {
-    const vertexId = _RepTree.NULL_VERTEX_ID;
-    if (this.state.getVertex(vertexId)) {
+  ensureNullNode() {
+    const nodeId = _RepTree.NULL_NODE_ID;
+    if (this.state.getNode(nodeId)) {
       return;
     }
-    this.newVertexInternal(vertexId, null);
+    this.newNodeInternal(nodeId, null);
   }
   /** Updates the lamport clock with the counter value of the operation */
-  updateLamportClock(operation) {
-    if (operation.id.counter > this.lamportClock) {
-      this.lamportClock = operation.id.counter;
+  updateMoveClock(operation) {
+    if (operation.id.counter > this.moveClock) {
+      this.moveClock = operation.id.counter;
+    }
+  }
+  updatePropClock(operation) {
+    if (operation.id.counter > this.propClock) {
+      this.propClock = operation.id.counter;
     }
   }
   applyPendingMovesForParent(parentId) {
-    if (!this.state.getVertex(parentId)) {
+    if (!this.state.getNode(parentId)) {
       return;
     }
     const pendingMoves = this.pendingMovesWithMissingParent.get(parentId);
@@ -1298,14 +1302,15 @@ var _RepTree = class _RepTree {
     }
   }
   applyMove(op) {
-    if (op.parentId !== null && !this.state.getVertex(op.parentId)) {
+    if (op.parentId !== null && !this.state.getNode(op.parentId)) {
       if (!this.pendingMovesWithMissingParent.has(op.parentId)) {
         this.pendingMovesWithMissingParent.set(op.parentId, []);
       }
       this.pendingMovesWithMissingParent.get(op.parentId).push(op);
+      this.markOpSeen(op, true);
       return;
     }
-    this.updateLamportClock(op);
+    this.updateMoveClock(op);
     const lastOp = this.moveOps.length > 0 ? this.moveOps[this.moveOps.length - 1] : null;
     if (lastOp === null || isOpIdGreaterThan(op.id, lastOp.id)) {
       this.moveOps.push(op);
@@ -1332,130 +1337,138 @@ var _RepTree = class _RepTree {
     this.applyPendingMovesForParent(op.targetId);
   }
   setLLWPropertyAndItsOpId(op) {
-    this.propertiesAndTheirOpIds.set(`${op.key}@${op.targetId}`, op.id);
+    this.propertyOpsByKey.set(`${op.key}@${op.targetId}`, op);
     this.state.setProperty(op.targetId, op.key, op.value);
-    this.reportOpAsApplied(op);
+    this.reportOpAsApplied(op, false);
+    this.refreshPropStateVector();
   }
   setTransientPropertyAndItsOpId(op) {
     this.transientPropertiesAndTheirOpIds.set(`${op.key}@${op.targetId}`, op.id);
     this.state.setTransientProperty(op.targetId, op.key, op.value);
-    this.reportOpAsApplied(op);
+    this.reportOpAsApplied(op, false);
   }
   applyProperty(op) {
-    const targetVertex = this.state.getVertex(op.targetId);
-    if (!targetVertex) {
+    const targetNode = this.state.getNode(op.targetId);
+    if (!targetNode) {
       if (op.transient) {
         return;
       }
-      if (!this.pendingPropertiesWithMissingVertex.has(op.targetId)) {
-        this.pendingPropertiesWithMissingVertex.set(op.targetId, []);
+      if (!this.pendingPropertiesWithMissingNode.has(op.targetId)) {
+        this.pendingPropertiesWithMissingNode.set(op.targetId, []);
       }
-      this.pendingPropertiesWithMissingVertex.get(op.targetId).push(op);
+      this.pendingPropertiesWithMissingNode.get(op.targetId).push(op);
+      this.markOpSeen(op, false);
       return;
     }
-    this.updateLamportClock(op);
-    this.applyLLWProperty(op, targetVertex);
+    this.updatePropClock(op);
+    this.applyLLWProperty(op, targetNode);
   }
-  applyLLWProperty(op, targetVertex) {
+  applyLLWProperty(op, targetNode) {
     const prevTransientOpId = this.transientPropertiesAndTheirOpIds.get(`${op.key}@${op.targetId}`);
-    const prevOpId = this.propertiesAndTheirOpIds.get(`${op.key}@${op.targetId}`);
+    const prevOpId = this.propertyOpsByKey.get(`${op.key}@${op.targetId}`)?.id;
     if (!op.transient) {
-      this.setPropertyOps.push(op);
       if (!prevOpId || isOpIdGreaterThan(op.id, prevOpId)) {
         this.setLLWPropertyAndItsOpId(op);
       } else {
-        this.knownOps.add(opIdToString(op.id));
+        this.markOpSeen(op, false);
       }
       if (prevTransientOpId && isOpIdGreaterThan(op.id, prevTransientOpId)) {
         this.transientPropertiesAndTheirOpIds.delete(`${op.key}@${op.targetId}`);
-        targetVertex.removeTransientProperty(op.key);
+        targetNode.removeTransientProperty(op.key);
       }
     } else {
       if (!prevTransientOpId || isOpIdGreaterThan(op.id, prevTransientOpId)) {
         this.setTransientPropertyAndItsOpId(op);
+      } else {
+        this.markOpSeen(op, false);
       }
     }
   }
   applyOperation(op) {
-    if (isMoveVertexOp(op)) {
+    if (isMoveNodeOp(op)) {
       this.applyMove(op);
     } else if (isAnyPropertyOp(op)) {
       this.applyProperty(op);
     }
   }
-  reportOpAsApplied(op) {
-    this.knownOps.add(opIdToString(op.id));
-    if (this._stateVectorEnabled) {
-      this.stateVector.updateFromOp(op);
+  markOpSeen(op, includeInStateVector) {
+    this.knownOps.add(this.getOpKey(op));
+    if (includeInStateVector && this._stateVectorEnabled) {
+      if (isMoveNodeOp(op)) {
+        this.moveStateVector.updateFromOp(op);
+      } else if (isAnyPropertyOp(op)) {
+        this.propStateVector.updateFromOp(op);
+      }
     }
+  }
+  reportOpAsApplied(op, includeInStateVector = true) {
+    this.markOpSeen(op, includeInStateVector);
     for (const callback of this.opAppliedCallbacks) {
       callback(op);
     }
   }
   tryToMove(op) {
-    let targetVertex = this.state.getVertex(op.targetId);
-    if (targetVertex) {
-      this.parentIdBeforeMove.set(op.id, targetVertex.parentId);
+    let targetNode = this.state.getNode(op.targetId);
+    if (targetNode) {
+      this.parentIdBeforeMove.set(op.id, targetNode.parentId);
     }
     if (op.targetId === op.parentId) return;
     if (op.parentId && this.isAncestor(op.parentId, op.targetId)) return;
-    this.state.moveVertex(op.targetId, op.parentId);
-    if (!targetVertex) {
-      const pendingProperties = this.pendingPropertiesWithMissingVertex.get(op.targetId) || [];
-      this.pendingPropertiesWithMissingVertex.delete(op.targetId);
+    this.state.moveNode(op.targetId, op.parentId);
+    if (!targetNode) {
+      const pendingProperties = this.pendingPropertiesWithMissingNode.get(op.targetId) || [];
+      this.pendingPropertiesWithMissingNode.delete(op.targetId);
       for (const prop of pendingProperties) {
         this.applyProperty(prop);
       }
     }
   }
   undoMove(op) {
-    const targetVertex = this.state.getVertex(op.targetId);
-    if (!targetVertex) {
-      console.error(`An attempt to undo move operation ${opIdToString(op.id)} failed because the target vertex ${op.targetId} not found`);
+    const targetNode = this.state.getNode(op.targetId);
+    if (!targetNode) {
+      console.error(`An attempt to undo move operation ${opIdToString(op.id)} failed because the target node ${op.targetId} not found`);
       return;
     }
     const prevParentId = this.parentIdBeforeMove.get(op.id);
     if (prevParentId === void 0) {
       return;
     }
-    this.state.moveVertex(op.targetId, prevParentId);
+    this.state.moveNode(op.targetId, prevParentId);
   }
-  // --- Range-Based State Vector Methods --- 
+  // --- Range-Based State Vector Methods ---
   /**
-   * Returns the current state vector.
-   * Returns a readonly reference to the internal state vector.
+   * Returns the current state vectors for move and property streams.
+   * Returns readonly references to the internal state vectors.
    */
-  getStateVector() {
+  getStateVectors() {
     if (!this._stateVectorEnabled) {
       return null;
     }
-    return this.stateVector.getState();
+    return {
+      move: this.moveStateVector.getState(),
+      prop: this.propStateVector.getState()
+    };
   }
   /**
-   * Determines which operations are needed to synchronize 
+   * Determines which operations are needed to synchronize
    * with the provided state vector.
-   * 
-   * @param theirStateVector The state vector from another peer
-   * @returns Operations that should be sent to the other peer, sorted by OpId.
+   *
+   * @param theirStateVectors The state vectors from another peer
+   * @returns Operations that should be sent to the other peer, sorted by OpId within each stream.
    */
-  getMissingOps(theirStateVector) {
+  getMissingOps(theirStateVectors) {
     if (!this._stateVectorEnabled) {
-      return [...this.moveOps, ...this.setPropertyOps];
-    }
-    const otherStateVector = new StateVector(theirStateVector);
-    const missingRanges = this.stateVector.diff(otherStateVector);
-    const missingOps = [];
-    const allOps = [...this.moveOps, ...this.setPropertyOps];
-    for (const op of allOps) {
-      for (const range of missingRanges) {
-        if (op.id.peerId === range.peerId && op.id.counter >= range.start && op.id.counter <= range.end) {
-          missingOps.push(op);
-          break;
-        }
-      }
-    }
-    missingOps.sort((a, b) => compareOpId(a.id, b.id));
-    return missingOps;
+      return [...this.moveOps, ...this.getPropertyOps()];
+    }
+    const otherMoveStateVector = new StateVector(theirStateVectors.move);
+    const otherPropStateVector = new StateVector(theirStateVectors.prop);
+    const missingMoveRanges = this.moveStateVector.diff(otherMoveStateVector);
+    const missingPropRanges = this.propStateVector.diff(otherPropStateVector);
+    const missingMoveOps = this.filterOpsByRanges(this.moveOps, missingMoveRanges);
+    const missingPropOps = this.filterOpsByRanges(this.getPropertyOps(), missingPropRanges);
+    missingMoveOps.sort((a, b) => compareOpId(a.id, b.id));
+    missingPropOps.sort((a, b) => compareOpId(a.id, b.id));
+    return [...missingMoveOps, ...missingPropOps];
   }
   /**
    * Gets or sets whether state vector tracking is enabled
@@ -1471,42 +1484,69 @@ var _RepTree = class _RepTree {
     if (value === this._stateVectorEnabled) return;
     if (value) {
       this._stateVectorEnabled = true;
-      this.stateVector = StateVector.fromOperations([...this.moveOps, ...this.setPropertyOps]);
+      this.moveStateVector = StateVector.fromOperations(this.moveOps);
+      this.propStateVector = StateVector.fromOperations(this.getPropertyOps());
     } else {
       this._stateVectorEnabled = false;
-      this.stateVector = new StateVector();
+      this.moveStateVector = new StateVector();
+      this.propStateVector = new StateVector();
     }
   }
   /**
-   * Parses the vertex properties with a provided schema that has a `parse` method (e.g., Zod schema)
+   * Parses the node properties with a provided schema that has a `parse` method (e.g., Zod schema)
    */
-  parseVertex(vertexId, schema) {
-    const propsArray = this.getVertexProperties(vertexId);
+  parseNode(nodeId, schema) {
+    const propsArray = this.getNodeProperties(nodeId);
     const propsObject = {};
     for (const { key, value } of propsArray) {
       propsObject[key] = value;
     }
     return schema.parse(propsObject);
   }
+  getPropertyOps() {
+    return Array.from(this.propertyOpsByKey.values());
+  }
+  refreshPropStateVector() {
+    if (!this._stateVectorEnabled) {
+      return;
+    }
+    this.propStateVector = StateVector.fromOperations(this.getPropertyOps());
+  }
+  getOpKey(op) {
+    const stream = isMoveNodeOp(op) ? "move" : "prop";
+    return `${stream}:${opIdToString(op.id)}`;
+  }
+  filterOpsByRanges(ops, ranges) {
+    const missingOps = [];
+    for (const op of ops) {
+      for (const range of ranges) {
+        if (op.id.peerId === range.peerId && op.id.counter >= range.start && op.id.counter <= range.end) {
+          missingOps.push(op);
+          break;
+        }
+      }
+    }
+    return missingOps;
+  }
 };
-_RepTree.NULL_VERTEX_ID = "0";
+_RepTree.NULL_NODE_ID = "0";
 var RepTree = _RepTree;
 export {
+  Node,
+  NodeState,
   RepTree,
   StateVector,
   TreeState,
-  Vertex,
-  VertexState,
-  bindVertex,
+  bindNode,
   compareOpId,
   createOpId,
   equalsOpId,
   isAnyPropertyOp,
-  isMoveVertexOp,
+  isMoveNodeOp,
   isOpIdGreaterThan,
-  newMoveVertexOp,
-  newSetTransientVertexPropertyOp,
-  newSetVertexPropertyOp,
+  newMoveNodeOp,
+  newSetNodePropertyOp,
+  newSetTransientNodePropertyOp,
   opIdToString,
   tryParseOpIdStr,
   uuid