@openlfcp/shared-objects 0.2.0-beta.9 → 0.2.0

package/dist/sections/replica.d.ts

@@ -361,12 +361,6 @@ export declare class SectionReplica {
      * never merged; the changes that depend on it wait.
      */
     receiveChanges(items: readonly (Uint8Array | SectionUnit)[]): SectionReceiveResult;
-    /**
-     * Everything an editor projects, in one synchronous read of one revision:
-     * the title (and its concurrent values), each node, the visible order,
-     * and the problems to show. `revision` is the modelRevision of a commit
-     * receipt and the `base` of text.edit.
-     */
     snapshot(): SectionSnapshot;
     /**
      * The Task of a task node (§4.2: stored under `/objects/<id>`, the node's

package/dist/sections/replica.js

@@ -393,8 +393,29 @@ export class SectionReplica {
      * and the problems to show. `revision` is the modelRevision of a commit
      * receipt and the `base` of text.edit.
      */
+    /**
+     * The tree and snapshot derived from the document at one revision (its
+     * heads): both are frozen and depend on the document alone, so a read at
+     * the same revision returns them again. Any change to the document
+     * changes its heads, so every path that changes it (commit, apply,
+     * revert, receive, a rebuild) gives a new revision and a new derivation
+     * (soak #11: the status was derived again on every refresh).
+     */
+    #derived;
+    #derivedNow() {
+        const revision = revisionOf(this.#doc);
+        if (this.#derived?.revision !== revision)
+            this.#derived = { revision, tree: deriveTree(this.#doc) };
+        return this.#derived;
+    }
     snapshot() {
-        const tree = deriveTree(this.#doc);
+        const derived = this.#derivedNow();
+        if (derived.snapshot !== undefined)
+            return derived.snapshot;
+        derived.snapshot = this.#snapshotOf(derived.tree);
+        return derived.snapshot;
+    }
+    #snapshotOf(tree) {
         const root = this.#doc;
         const section = (root.section ?? {});
         const nodes = (root.nodes ?? {});
@@ -456,7 +477,7 @@ export class SectionReplica {
     }
     /** §7, §9, §14.3: the effective tree, hidden nodes and structural facts. */
     tree() {
-        return deriveTree(this.#doc);
+        return this.#derivedNow().tree;
     }
     /** The document heads, sorted, as one string. */
     revision() {

package/dist/sections/tree.js

@@ -182,19 +182,50 @@ export function deriveTree(doc, validation = validateSection(doc)) {
         validation,
     });
 }
+const summarise = (bytes) => {
+    const c = A.decodeChange(bytes);
+    return {
+        hash: c.hash,
+        deps: c.deps,
+        actor: c.actor,
+        seq: c.seq,
+        ops: c.ops.map((op) => {
+            const o = op;
+            return { obj: o.obj, action: o.action, key: o.key, value: o.value };
+        }),
+    };
+};
 /**
- * §9: the hidden nodes with content changes concurrent with a deletion of
- * the node or of an ancestor, from the change history. A change deletes
- * when the last lifecycle value it writes to an owner (a Task node's Task,
- * another node itself) is "deleted"; content is a node's creation, an
- * 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).
+ * The decoded history of the documents read last, by their heads (a few,
+ * least recently used last out). A change is the same wherever it is, so a
+ * later revision of the same document decodes only the changes since a
+ * revision read before, whose heads it has: decoding the whole history on
+ * every new revision was linear in it, per pass (soak #11).
  */
+const histories = new Map();
+const HISTORIES = 16;
+function historyOf(doc) {
+    const key = [...A.getHeads(doc)].sort().join(",");
+    const known = histories.get(key);
+    if (known !== undefined) {
+        histories.delete(key);
+        histories.set(key, known);
+        return known;
+    }
+    let out;
+    for (const [k, list] of [...histories].reverse()) {
+        const heads = k === "" ? [] : k.split(",");
+        if (A.getMissingDeps(doc, heads).length > 0)
+            continue;
+        out = [...list, ...A.getChangesSince(doc, heads).map(summarise)];
+        break;
+    }
+    out ??= A.getAllChanges(doc).map(summarise);
+    histories.set(key, out);
+    while (histories.size > HISTORIES)
+        histories.delete(histories.keys().next().value);
+    return out;
+}
 function retainedEdits(doc, hidden, parentOf, sectionId) {
     const root = doc;
     const nodes = (root.nodes ?? {});
@@ -226,13 +257,15 @@ function retainedEdits(doc, hidden, parentOf, sectionId) {
         }
     }
     const deps = new Map();
+    // Each change's actor and sequence number, for its vector clock below.
+    const author = 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);
+    for (const change of historyOf(doc)) {
         deps.set(change.hash, change.deps);
+        author.set(change.hash, { actor: change.actor, seq: change.seq });
         const lastLifecycle = new Map();
         const touched = new Set();
         for (const op of change.ops) {
@@ -266,7 +299,51 @@ function retainedEdits(doc, hidden, parentOf, sectionId) {
     }
     if (deletes.length === 0 || edits.length === 0)
         return [];
-    /** Every change `hash` depends on, transitively, memoized. */
+    /**
+     * Each change's vector clock: the highest sequence number of every actor
+     * in its causal history, itself included. When each change of an actor
+     * has that actor's previous change in its history (as Automerge writes
+     * them), `a` is in the history of `b` exactly when b's clock has a's actor
+     * at a's sequence or later: O(history × actors), where a set of ancestors
+     * per change was O(history²) (soak #11: seconds per pass after ~3,000
+     * changes in a section with deleted Tasks). A history where that does not
+     * hold (a change made without its actor's previous one), or one with more
+     * than 32 actors, falls back to the exact sets.
+     */
+    const clocks = new Map();
+    // A clock holds an entry per actor: with many actors (a hostile or unusual
+    // history), the exact sets are cheaper.
+    let regular = new Set([...author.values()].map((x) => x.actor)).size <= 32;
+    for (const start of regular ? deps.keys() : []) {
+        const stack = [start];
+        while (stack.length > 0) {
+            const h = stack[stack.length - 1];
+            if (clocks.has(h)) {
+                stack.pop();
+                continue;
+            }
+            const pending = (deps.get(h) ?? []).filter((d) => deps.has(d) && !clocks.has(d));
+            if (pending.length > 0) {
+                stack.push(...pending);
+                continue;
+            }
+            stack.pop();
+            const clock = new Map();
+            for (const d of deps.get(h) ?? [])
+                for (const [actor, seq] of clocks.get(d) ?? [])
+                    if (seq > (clock.get(actor) ?? 0))
+                        clock.set(actor, seq);
+            const me = author.get(h);
+            if (me !== undefined) {
+                if ((clock.get(me.actor) ?? 0) !== me.seq - 1)
+                    regular = false;
+                if (me.seq > (clock.get(me.actor) ?? 0))
+                    clock.set(me.actor, me.seq);
+            }
+            clocks.set(h, clock);
+        }
+    }
+    /** Every change `hash` depends on, transitively, memoized (the exact fallback). */
     const ancestry = new Map();
     const ancestorsOf = (hash) => {
         const known = ancestry.get(hash);
@@ -286,14 +363,23 @@ function retainedEdits(doc, hidden, parentOf, sectionId) {
         ancestry.set(hash, out);
         return out;
     };
-    const concurrent = (a, b) => a !== b && !ancestorsOf(a).has(b) && !ancestorsOf(b).has(a);
+    /** Whether change `a` is in the causal history of change `b` (a ≠ b). */
+    const before = (a, b) => {
+        if (a === b)
+            return false;
+        if (!regular)
+            return ancestorsOf(b).has(a);
+        const me = author.get(a);
+        return me !== undefined && (clocks.get(b)?.get(me.actor) ?? 0) >= me.seq;
+    };
+    const concurrent = (a, b) => a !== b && !before(a, b) && !before(b, 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 heldDeletes = deletes.filter((d) => !lifecycleWrites.some((w) => w.node === d.node && w.hash !== d.hash && before(d.hash, w.hash)));
     const deletesOf = new Map();
     for (const d of heldDeletes)
         deletesOf.set(d.node, [...(deletesOf.get(d.node) ?? []), d.hash]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openlfcp/shared-objects",
-  "version": "0.2.0-beta.9",
+  "version": "0.2.0",
   "description": "SHARED-OBJECTS-PROFILE-01 (org.openlfcp.shared-objects.v1) implementation.",
   "keywords": [
     "openlfcp",
@@ -48,13 +48,13 @@
   ],
   "publishConfig": {
     "access": "public",
-    "tag": "beta"
+    "tag": "latest"
   },
   "dependencies": {
     "@automerge/automerge": "3.5.0",
     "fflate": "0.8.3",
-    "@openlfcp/core": "^0.2.0-beta.9",
-    "@openlfcp/crypto": "^0.2.0-beta.9"
+    "@openlfcp/core": "^0.2.0",
+    "@openlfcp/crypto": "^0.2.0"
   },
   "devDependencies": {
     "fast-check": "4.10.2"