@openlfcp/shared-objects 0.2.0-beta.6 → 0.2.0-beta.8

package/dist/concurrent.d.ts

@@ -0,0 +1,15 @@
+import * as A from "@automerge/automerge";
+type AMap = Record<string, unknown>;
+/**
+ * The distinct concurrent values of `map[key]` in `doc` (SOP §45,
+ * mvp-0.2-baseline.12): none when absent, one when it is not conflicted or
+ * when every concurrent value is equal. Two values are equal when they have
+ * the same Automerge scalar type and the same value (strings code point by
+ * code point); an object (a map, a list or Text) equals no other value. In
+ * Automerge's order of the concurrent values, the first of each equal group.
+ */
+export declare function distinctValues(doc: A.Doc<unknown>, map: AMap | undefined, key: string): unknown[];
+/** Whether `map[key]` has two or more distinct concurrent values (a conflict, SOP §45). */
+export declare function isConflicted(doc: A.Doc<unknown>, map: AMap, key: string): boolean;
+export {};
+//# sourceMappingURL=concurrent.d.ts.map

package/dist/concurrent.js

@@ -0,0 +1,55 @@
+import * as A from "@automerge/automerge";
+/** Automerge object types: an object value equals no other value (SOP §45). */
+const OBJECTS = new Set(["map", "list", "text", "table"]);
+/** A scalar's identity for equality: its Automerge type and its value. */
+function scalarKey(type, value) {
+    if (value instanceof Uint8Array)
+        return `${type}:${Array.from(value, (b) => b.toString(16).padStart(2, "0")).join("")}`;
+    if (value instanceof Date)
+        return `${type}:${value.getTime()}`;
+    if (typeof value === "bigint")
+        return `${type}:${value}`;
+    return `${type}:${JSON.stringify(value)}`;
+}
+/**
+ * The distinct concurrent values of `map[key]` in `doc` (SOP §45,
+ * mvp-0.2-baseline.12): none when absent, one when it is not conflicted or
+ * when every concurrent value is equal. Two values are equal when they have
+ * the same Automerge scalar type and the same value (strings code point by
+ * code point); an object (a map, a list or Text) equals no other value. In
+ * Automerge's order of the concurrent values, the first of each equal group.
+ */
+export function distinctValues(doc, map, key) {
+    if (map === undefined || !(key in map))
+        return [];
+    const conflicts = A.getConflicts(map, key);
+    if (conflicts === undefined)
+        return [map[key]];
+    const obj = A.getObjectId(map);
+    const all = obj === null ? [] : A.getBackend(doc).getAll(obj, key, A.getHeads(doc));
+    const typeOf = new Map();
+    for (const e of all) {
+        const type = e[0];
+        if (OBJECTS.has(type))
+            typeOf.set(e[1], { type, value: undefined });
+        else
+            typeOf.set(e[2], { type, value: e[1] });
+    }
+    const seen = new Set();
+    const out = [];
+    for (const [opId, value] of Object.entries(conflicts)) {
+        const t = typeOf.get(opId);
+        const k = t === undefined || OBJECTS.has(t.type) ? `object:${opId}` : scalarKey(t.type, t.value);
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        out.push(value);
+    }
+    return out;
+}
+/** Whether `map[key]` has two or more distinct concurrent values (a conflict, SOP §45). */
+export function isConflicted(doc, map, key) {
+    return (A.getConflicts(map, key) !== undefined &&
+        distinctValues(doc, map, key).length > 1);
+}
+//# sourceMappingURL=concurrent.js.map

package/dist/replica.js

@@ -4,6 +4,7 @@ import { checkChange, checkSaveHeader, parsedOf, unframeChange, unframeSnapshot,
 import { checkSnapshotExpansion, MAX_DOCUMENT_DEPTH, SNAPSHOT_LIMITS_FLOOR, } from "./admission/limits.js";
 import { referenceHistoryOf } from "./admission/references.js";
 import { admitBatch, admitChange } from "./admission/sequence.js";
+import { distinctValues, isConflicted } from "./concurrent.js";
 /** The decoded actions that create an object (§11.2). */
 const MAKE_ACTIONS = new Set(["makeMap", "makeList", "makeText", "makeTable"]);
 import { ProfileInvalidError } from "./profile-invalid.js";
@@ -153,17 +154,13 @@ function canonical(value) {
             .map((k) => [k, canonical(value[k])]));
     return value;
 }
-/** Every concurrent value of `map[key]`: none if absent, one if not conflicted. */
-function valuesOf(map, key) {
-    if (!(key in map))
-        return [];
-    const conflicts = A.getConflicts(map, key);
-    return conflicts === undefined ? [map[key]] : Object.values(conflicts);
-}
-/** Top-level fields of `object` with more than one concurrent value. */
-function conflictedFields(object) {
+/**
+ * Top-level fields of `object` in conflict: two or more distinct concurrent
+ * values (§45; concurrent equal values agree).
+ */
+function conflictedFields(doc, object) {
     return Object.keys(object)
-        .filter((f) => A.getConflicts(object, f) !== undefined)
+        .filter((f) => isConflicted(doc, object, f))
         .sort();
 }
 const problem = (diagnostic, pointer, message) => Object.freeze({ code: "PROFILE_INVALID", diagnostic, pointer, message });
@@ -236,7 +233,7 @@ export function taskView(doc, objects, id) {
     const problems = storedObjectProblems(doc, object, id);
     const parsed = parseTask(plain(object), id);
     const field = (f) => {
-        const values = valuesOf(object, f).map(plain).sort(byJson);
+        const values = distinctValues(doc, object, f).map(plain).sort(byJson);
         return Object.freeze({
             value: f in object ? plain(object[f]) : undefined,
             values: Object.freeze(values),
@@ -525,7 +522,7 @@ export class SharedObjectsReplica {
             this.#noteSeq(meta.actor, meta.seq);
         for (const [id, object] of Object.entries(this.#objects() ?? {}))
             if (isMap(object))
-                this.#conflicted.set(id, conflictedFields(object));
+                this.#conflicted.set(id, conflictedFields(doc, object));
     }
     /**
      * §11.2: the depths of the objects `change` creates (object ID → depth),
@@ -749,9 +746,9 @@ export class SharedObjectsReplica {
         for (const [id, object] of Object.entries(objects)) {
             if (!isMap(object))
                 continue;
-            for (const field of conflictedFields(object)) {
+            for (const field of conflictedFields(this.#doc, object)) {
                 out[id] ??= {};
-                out[id][field] = valuesOf(object, field)
+                out[id][field] = distinctValues(this.#doc, object, field)
                     .map(plain)
                     .sort(byJson);
             }
@@ -1008,7 +1005,7 @@ export class SharedObjectsReplica {
             if (set.size === 0)
                 for (const f of Object.keys(now))
                     set.add(f);
-            const nowConflicts = conflictedFields(now);
+            const nowConflicts = conflictedFields(this.#doc, now);
             const wasConflicts = this.#conflicted.get(id) ?? [];
             this.#conflicted.set(id, nowConflicts);
             out.push(Object.freeze({

package/dist/sections/replica.js

@@ -4,6 +4,7 @@ import { checkChange, checkSaveHeader, parsedOf, refusedChangeHash, } from "../a
 import { checkChangeExpansion, checkSnapshotExpansion, SNAPSHOT_LIMITS_FLOOR, } from "../admission/limits.js";
 import { referenceHistoryOf } from "../admission/references.js";
 import { admitBatch } from "../admission/sequence.js";
+import { distinctValues } from "../concurrent.js";
 import { ProfileInvalidError } from "../profile-invalid.js";
 import { isWasmTrap, prepareTaskIntent, taskView, } from "../replica.js";
 import { frameProfilePayload, isUtcTimestamp, principalRef } from "../values.js";
@@ -138,12 +139,9 @@ function applyIsolating(doc, changes) {
     }
     return { doc: work, applied, poisoned };
 }
-/** Every concurrent value of `map[key]`. */
-function values(map, key) {
-    if (!(key in map))
-        return [];
-    const c = A.getConflicts(map, key);
-    return c === undefined ? [map[key]] : Object.values(c);
+/** The distinct concurrent values of `map[key]` in `doc` (SOP §45: equal values agree). */
+function values(doc, map, key) {
+    return distinctValues(doc, map, key);
 }
 /** PROFILE_INVALID for a Snapshot, with the diagnostic of what refused it. */
 function snapshotRefused(diagnostic, message) {
@@ -401,7 +399,7 @@ export class SectionReplica {
         const objects = (root.objects ?? {});
         const placements = (root.placements ?? {});
         const hidden = new Set(tree.hidden);
-        const titles = values(section, "title").map(str);
+        const titles = values(this.#doc, section, "title").map(str);
         const out = {};
         for (const id of Object.keys(nodes).sort()) {
             if (tree.collisions.includes(id))
@@ -844,7 +842,8 @@ export class SectionReplica {
                     refuse("NODE_IN_CONFLICT", `${second} is invalid or collides (§14.2)`, second);
                 const otherKind = str(other.kind);
                 const sameStyle = kind === "paragraph" ||
-                    values(node, "list_style").join() === values(other, "list_style").join();
+                    values(doc, node, "list_style").join() ===
+                        values(doc, other, "list_style").join();
                 if (otherKind !== kind || (kind !== "paragraph" && kind !== "item") || !sameStyle)
                     refuse("INVALID_INTENT", "only two paragraphs, or two items of one list style, join (§10)", id);
                 const kids = (n) => (n.children ?? []).length;
@@ -871,8 +870,8 @@ export class SectionReplica {
             // split: a deletion of the suffix and a new node after this one.
             if (intent.intent.slice(0, intent.intent.indexOf(".")) !== kind)
                 refuse("INVALID_INTENT", `${intent.intent} on a ${kind} node (§10)`, id);
-            if (values(node, "placement").length !== 1 ||
-                new Set(values(node, "lifecycle")).size !== 1)
+            if (values(doc, node, "placement").length !== 1 ||
+                new Set(values(doc, node, "lifecycle")).size !== 1)
                 refuse("NODE_IN_CONFLICT", `${id} has unresolved structure (§10)`, id);
             const cut = rebase(doc, path, intent.base, [{ index: intent.at, deleteCount: 0, insert: "" }], refuse, id)[0];
             const suffix = current.slice(cut.from);
@@ -939,7 +938,7 @@ export class SectionReplica {
                     n.list_style = S(style);
                 };
             }
-            if (intent.intent === "node.move" && values(node, "placement").length !== 1)
+            if (intent.intent === "node.move" && values(doc, node, "placement").length !== 1)
                 refuse("NODE_IN_CONFLICT", `${id} has concurrent placements: use node.resolve_placement (§7, §8)`, id);
             const placementId = intent.placementId ?? generateObjectId();
             if (!isObjectId(placementId))
@@ -1086,12 +1085,12 @@ chainOk) {
             return { why: "is invalid (§14.2)" };
         const kind = str(node.kind);
         const owner = kind === "task" ? objects[id] : node;
-        const life = values(owner, "lifecycle").map(str);
+        const life = values(doc, owner, "lifecycle").map(str);
         if (life.length !== 1)
             return { why: "has a lifecycle conflict (§9)" };
         if (life[0] !== "active")
             return { why: "is deleted (§9)" };
-        const selected = values(node, "placement").map(str);
+        const selected = values(doc, node, "placement").map(str);
         if (selected.length !== 1)
             return { why: "has a placement conflict (§7)" };
         const placement = placements[selected[0]];
@@ -1131,7 +1130,7 @@ chainOk) {
     const e = eligible(after);
     if ("why" in e || e.parent !== parent)
         refuse("INVALID_PREDECESSOR", `${after} is not a visible child of ${parent} (§6)`, after);
-    const slot = str(values(nodes[after], "placement")[0]);
+    const slot = str(values(doc, nodes[after], "placement")[0]);
     const at = lane.findIndex((x) => str(x) === slot);
     if (at < 0)
         refuse("INVALID_PREDECESSOR", `${after}'s placement is not in the parent's list (§4.3)`, after);

package/dist/sections/tree.js

@@ -1,14 +1,12 @@
 import * as A from "@automerge/automerge";
+import { distinctValues } from "../concurrent.js";
 import { validateSection } from "./schema.js";
 /** The Task scalar fields whose concurrent values tree() reports. */
 const CONFLICT_FIELDS = ["title", "status", "lifecycle", "due", "priority"];
 const str = (v) => A.isImmutableString(v) ? v.toString() : typeof v === "string" ? v : undefined;
-/** Every concurrent value of `map[key]`, as strings. */
-function values(map, key) {
-    if (map === undefined || !(key in map))
-        return [];
-    const c = A.getConflicts(map, key);
-    return (c === undefined ? [map[key]] : Object.values(c)).map(str);
+/** The distinct concurrent values of `map[key]` in `doc`, as strings (SOP §45: equal values agree). */
+function values(doc, map, key) {
+    return distinctValues(doc, map, key).map(str);
 }
 const byId = (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
 /** §7: the effective tree and structural facts of `doc`. Reads only. */
@@ -32,13 +30,13 @@ export function deriveTree(doc, validation = validateSection(doc)) {
         // §7.6: a lifecycle conflict has no winner. It blocks the branch (below)
         // instead of the provisional value hiding it: the node is not deleted,
         // and edits under it are not under a deleted ancestor.
-        const lifecycles = new Set(values(owner(id), "lifecycle"));
+        const lifecycles = new Set(values(doc, owner(id), "lifecycle"));
         if (lifecycles.size === 1 && lifecycles.has("deleted"))
             deleted.add(id);
         if (collided.has(id))
             continue;
         const n = node(id);
-        const selected = values(n, "placement");
+        const selected = values(doc, n, "placement");
         const parentOf = (p) => p === undefined ? undefined : str(placements[p]?.parent_id);
         // The default value selects the parent used for hiding and for the walk below.
         const parent = parentOf(str(n.placement));
@@ -177,7 +175,7 @@ export function deriveTree(doc, validation = validateSection(doc)) {
         collisions: validation.collisions,
         retainedConcurrentEdits: Object.freeze(retained),
         scalarConflicts: Object.freeze(Object.keys(objects).flatMap((id) => CONFLICT_FIELDS.flatMap((field) => {
-            const vs = values(objects[id], field);
+            const vs = values(doc, objects[id], field);
             return vs.length > 1 ? [{ id, field, values: vs.map((v) => v ?? "").sort() }] : [];
         }))),
         candidates,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openlfcp/shared-objects",
-  "version": "0.2.0-beta.6",
+  "version": "0.2.0-beta.8",
   "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.6",
-    "@openlfcp/crypto": "^0.2.0-beta.6"
+    "@openlfcp/core": "^0.2.0-beta.8",
+    "@openlfcp/crypto": "^0.2.0-beta.8"
   },
   "devDependencies": {
     "fast-check": "4.10.2"