@openlfcp/shared-objects 0.2.0-beta.3 → 0.2.0-beta.4

package/dist/sections/tree.js

@@ -192,6 +192,10 @@ export function deriveTree(doc, validation = validateSection(doc)) {
  * operation on its Text, a Task's title or status, or a move of the node
  * (a write to its `placement` register — node.move or node.resolve_placement,
  * §8). Two changes are concurrent when neither is in the other's dependencies.
+ * Only a deletion the lifecycle register still holds counts: one a later write
+ * to the same register depends on is superseded (deleting the node again clears
+ * the attention a concurrent edit raised), while two concurrent deletions both
+ * count (baseline.9).
  */
 function retainedEdits(doc, hidden, parentOf, sectionId) {
     const root = doc;
@@ -225,6 +229,8 @@ function retainedEdits(doc, hidden, parentOf, sectionId) {
     }
     const deps = new Map();
     const deletes = [];
+    // Every lifecycle write (any value), to tell whether a deletion is still held.
+    const lifecycleWrites = [];
     const edits = [];
     for (const bytes of A.getAllChanges(doc)) {
         const change = A.decodeChange(bytes);
@@ -252,9 +258,11 @@ function retainedEdits(doc, hidden, parentOf, sectionId) {
             if (owner !== undefined && key === "lifecycle")
                 lastLifecycle.set(owner, value);
         }
-        for (const [owner, value] of lastLifecycle)
+        for (const [owner, value] of lastLifecycle) {
+            lifecycleWrites.push({ hash: change.hash, node: owner });
             if (value === "deleted")
                 deletes.push({ hash: change.hash, node: owner });
+        }
         for (const node of touched)
             edits.push({ hash: change.hash, node });
     }
@@ -281,8 +289,15 @@ function retainedEdits(doc, hidden, parentOf, sectionId) {
         return out;
     };
     const concurrent = (a, b) => a !== b && !ancestorsOf(a).has(b) && !ancestorsOf(b).has(a);
+    // §9 (baseline.9): a deletion counts only while the lifecycle register still
+    // holds it. A later write to the same register — one that has the deletion in
+    // its dependencies — supersedes it, so deleting a node again clears the
+    // attention a concurrent edit raised. Two concurrent deletions supersede
+    // neither, so both still count (SS86); the writes come from each change's
+    // operations, which also keeps a deletion merged after a concurrent one.
+    const heldDeletes = deletes.filter((d) => !lifecycleWrites.some((w) => w.node === d.node && w.hash !== d.hash && ancestorsOf(w.hash).has(d.hash)));
     const deletesOf = new Map();
-    for (const d of deletes)
+    for (const d of heldDeletes)
         deletesOf.set(d.node, [...(deletesOf.get(d.node) ?? []), d.hash]);
     const attention = new Set();
     for (const edit of edits) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openlfcp/shared-objects",
-  "version": "0.2.0-beta.3",
+  "version": "0.2.0-beta.4",
   "description": "SHARED-OBJECTS-PROFILE-01 (org.openlfcp.shared-objects.v1) implementation.",
   "keywords": [
     "openlfcp",
@@ -53,8 +53,8 @@
   "dependencies": {
     "@automerge/automerge": "3.5.0",
     "fflate": "0.8.3",
-    "@openlfcp/core": "^0.2.0-beta.3",
-    "@openlfcp/crypto": "^0.2.0-beta.3"
+    "@openlfcp/core": "^0.2.0-beta.4",
+    "@openlfcp/crypto": "^0.2.0-beta.4"
   },
   "devDependencies": {
     "fast-check": "4.10.2"