@openlfcp/shared-objects 0.1.5 → 0.2.0-beta.10

package/dist/sections/tree.d.ts

@@ -0,0 +1,83 @@
+import * as A from "@automerge/automerge";
+import { type SectionValidation } from "./schema.js";
+/**
+ * The effective tree of a section and its structural facts
+ * (SHARED-SECTIONS-PROFILE-01 §7, §9, §14.3; LFCP-02-014), derived from the
+ * fully merged state, never from arrival order:
+ *
+ * - a node with more than one concurrent placement is PLACEMENT_CONFLICT;
+ *   its lifecycle (a Task node's: its Task's) with concurrent different
+ *   values is LIFECYCLE_CONFLICT (equal values agree);
+ * - every member of a cycle of the selected parent graph is PARENT_CYCLE;
+ * - every node under a conflicted, cyclic, invalid or collided node is
+ *   BLOCKED_PARENT, to a fixed point;
+ * - a deleted node, and every node under one, is hidden; a node whose
+ *   lifecycle is in conflict is not: its branch is blocked (§7.6);
+ * - the tree scans each children list in its merged order and emits a node
+ *   only when it is eligible, visible and selects exactly that entry.
+ *
+ * No winner is chosen and nothing is rewritten: blocked and hidden content
+ * stays in the document, and recovery lists it. Traversals are iterative,
+ * so deep or adversarial graphs do not depend on the call stack (§16.4).
+ */
+export type StructuralFact = "PLACEMENT_CONFLICT" | "PARENT_CYCLE" | "BLOCKED_PARENT" | "LIFECYCLE_CONFLICT";
+export interface TreeEntry {
+    readonly id: string;
+    /** The section ID or the parent node's ID. */
+    readonly parent: string;
+    /** 0 under the section. */
+    readonly depth: number;
+    readonly kind: string;
+}
+export interface SectionTree {
+    /**
+     * PROFILE_INVALID: section-level problems, nothing projected; IMPORTING:
+     * no `ready` (§12.1), nothing projected; STRUCTURAL_ATTENTION: a
+     * recovery fact, an invalid node or a collision; VALID otherwise.
+     */
+    readonly classification: "PROFILE_INVALID" | "IMPORTING" | "STRUCTURAL_ATTENTION" | "VALID";
+    /** The visible nodes in projection order (preorder). */
+    readonly tree: readonly TreeEntry[];
+    /** Nodes hidden by their own or an ancestor's deletion, sorted. */
+    readonly hidden: readonly string[];
+    /** Blocked nodes with their fact, sorted by node ID for presentation only. */
+    readonly recovery: readonly {
+        readonly id: string;
+        readonly code: StructuralFact;
+    }[];
+    /** Invalid nodes with their §14.2 diagnostic, sorted. */
+    readonly invalid: readonly {
+        readonly id: string;
+        readonly diagnostic: string;
+    }[];
+    /** Colliding IDs (§14.2), sorted. */
+    readonly collisions: readonly string[];
+    /**
+     * §9, §14.3 EDIT_UNDER_DELETED_ANCESTOR: hidden nodes whose content (the
+     * node created, its Text edited, its Task's title or status set) changed
+     * concurrently with the deletion of the node or an ancestor; sorted. The
+     * edit is retained, not visibly applied: it needs the user's attention.
+     */
+    readonly retainedConcurrentEdits: readonly string[];
+    /**
+     * SOP §44–§47: the Task scalar fields with concurrent values (title,
+     * status, lifecycle, due, priority), each with its values sorted. A
+     * provisional value may show; the conflict stays visible until a user
+     * resolves it.
+     */
+    readonly scalarConflicts: readonly {
+        readonly id: string;
+        readonly field: string;
+        readonly values: readonly string[];
+    }[];
+    /** Each blocked node's candidate placements and their parents (§7 recovery information). */
+    readonly candidates: ReadonlyMap<string, readonly {
+        readonly placement: string;
+        readonly parent: string;
+    }[]>;
+    /** The schema validation the tree was derived from. */
+    readonly validation: SectionValidation;
+}
+/** §7: the effective tree and structural facts of `doc`. Reads only. */
+export declare function deriveTree(doc: A.Doc<unknown>, validation?: SectionValidation): SectionTree;
+//# sourceMappingURL=tree.d.ts.map

package/dist/sections/tree.js

@@ -0,0 +1,401 @@
+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;
+/** 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. */
+export function deriveTree(doc, validation = validateSection(doc)) {
+    const root = doc;
+    const nodes = (root.nodes ?? {});
+    const placements = (root.placements ?? {});
+    const objects = (root.objects ?? {});
+    const sectionId = validation.sectionId;
+    const invalid = validation.nodes;
+    const collided = new Set(validation.collided);
+    const blocked = new Map();
+    const parents = new Map();
+    const candidates = new Map();
+    const keys = Object.keys(nodes).sort();
+    const node = (id) => nodes[id];
+    const owner = (id) => (str(node(id)?.kind) === "task" ? objects[id] : node(id));
+    // One pass over the nodes: selected parent, deletion, conflicts.
+    const deleted = new Set();
+    for (const id of keys) {
+        // §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(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(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));
+        if (parent !== undefined)
+            parents.set(id, parent);
+        if (selected.length > 1) {
+            blocked.set(id, "PLACEMENT_CONFLICT");
+            candidates.set(id, selected.map((p) => ({ placement: p ?? "", parent: parentOf(p) ?? "" })));
+        }
+        if (lifecycles.size > 1)
+            blocked.set(id, "LIFECYCLE_CONFLICT");
+    }
+    for (const id of invalid.keys())
+        blocked.delete(id);
+    // Every member of a cycle of the selected parent graph (§7.4), whatever
+    // the start: each node has one parent, so one coloured walk per start
+    // that stops at any node already done finds them all in linear time.
+    const done = new Set();
+    for (const start of keys) {
+        const path = [];
+        const onPath = new Map();
+        let n = start;
+        while (n !== undefined &&
+            n !== sectionId &&
+            node(n) !== undefined &&
+            !done.has(n) &&
+            !blocked.has(n) &&
+            !collided.has(n) &&
+            !invalid.has(n)) {
+            const at = onPath.get(n);
+            if (at !== undefined) {
+                for (const c of path.slice(at))
+                    blocked.set(c, "PARENT_CYCLE");
+                break;
+            }
+            onPath.set(n, path.length);
+            path.push(n);
+            n = parents.get(n);
+        }
+        for (const c of path)
+            done.add(c);
+    }
+    /**
+     * Resolves `fact(id)` = own(id) || fact(parent) along the parent chain,
+     * iteratively and memoized; a walk that comes back to a node of its own
+     * path stops there, with what the loop holds.
+     */
+    const chained = (own) => {
+        const memo = new Map();
+        return (id) => {
+            const path = [];
+            const onPath = new Set();
+            let tail = false;
+            let n = id;
+            while (n !== undefined && n !== sectionId && node(n) !== undefined) {
+                const known = memo.get(n);
+                if (known !== undefined) {
+                    tail = known;
+                    break;
+                }
+                if (onPath.has(n)) {
+                    // A loop: every node of it sees all of it.
+                    tail = path.slice(path.indexOf(n)).some(own);
+                    break;
+                }
+                onPath.add(n);
+                path.push(n);
+                n = parents.get(n);
+            }
+            for (let k = path.length - 1; k >= 0; k--) {
+                tail = tail || own(path[k]);
+                memo.set(path[k], tail);
+            }
+            return memo.get(id) ?? tail;
+        };
+    };
+    // §7.5: blocked structure propagates to every descendant.
+    const out = (id) => id !== undefined && (blocked.has(id) || invalid.has(id) || collided.has(id));
+    const isOut = new Set(keys.filter((id) => out(id)));
+    const blockedAbove = chained((id) => isOut.has(id));
+    for (const id of keys) {
+        const parent = parents.get(id);
+        if (!isOut.has(id) && parent !== undefined && blockedAbove(parent))
+            blocked.set(id, "BLOCKED_PARENT");
+    }
+    // §9: a deleted node or a descendant of one is hidden, not removed.
+    const isHidden = chained((id) => deleted.has(id));
+    const hidden = new Set(keys.filter((id) => isHidden(id)));
+    const retained = hidden.size === 0 ? [] : retainedEdits(doc, hidden, (id) => parents.get(id), sectionId);
+    const tree = [];
+    const projectable = validation.state === "ready" && sectionId !== undefined;
+    if (projectable) {
+        const laneOf = (p) => ((p === sectionId ? root.section.children : node(p)?.children) ?? []);
+        // An explicit stack of (parent, depth, next index) instead of recursion.
+        const stack = [
+            { parent: sectionId, depth: 0, lane: laneOf(sectionId), i: 0 },
+        ];
+        const emitted = new Set();
+        while (stack.length > 0) {
+            const top = stack[stack.length - 1];
+            if (top.i >= top.lane.length) {
+                stack.pop();
+                continue;
+            }
+            const slot = str(top.lane[top.i++]);
+            if (slot === undefined || collided.has(slot))
+                continue;
+            const id = str(placements[slot]?.node_id);
+            if (id === undefined || node(id) === undefined || out(id) || hidden.has(id))
+                continue;
+            if (str(node(id)?.placement) !== slot || emitted.has(id))
+                continue;
+            emitted.add(id);
+            tree.push(Object.freeze({
+                id,
+                parent: top.parent,
+                depth: top.depth,
+                kind: str(node(id)?.kind) ?? "",
+            }));
+            stack.push({ parent: id, depth: top.depth + 1, lane: laneOf(id), i: 0 });
+        }
+    }
+    const classification = validation.state === "invalid"
+        ? "PROFILE_INVALID"
+        : validation.state === "importing"
+            ? "IMPORTING"
+            : blocked.size > 0 || invalid.size > 0 || validation.collisions.length > 0
+                ? "STRUCTURAL_ATTENTION"
+                : "VALID";
+    return Object.freeze({
+        classification,
+        tree: Object.freeze(tree),
+        hidden: Object.freeze([...hidden].sort()),
+        recovery: Object.freeze([...blocked].map(([id, code]) => ({ id, code })).sort(byId)),
+        invalid: Object.freeze([...invalid].map(([id, p]) => ({ id, diagnostic: p.diagnostic })).sort(byId)),
+        collisions: validation.collisions,
+        retainedConcurrentEdits: Object.freeze(retained),
+        scalarConflicts: Object.freeze(Object.keys(objects).flatMap((id) => CONFLICT_FIELDS.flatMap((field) => {
+            const vs = values(doc, objects[id], field);
+            return vs.length > 1 ? [{ id, field, values: vs.map((v) => v ?? "").sort() }] : [];
+        }))),
+        candidates,
+        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 };
+        }),
+    };
+};
+/**
+ * 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 ?? {});
+    const objects = (root.objects ?? {});
+    const nodesObj = A.getObjectId(root, "nodes");
+    // Object IDs to the node whose content or lifecycle they hold.
+    const textOf = new Map();
+    const ownerOf = new Map();
+    const taskOf = new Map();
+    // The object ID of each node's own map, for a move written to its `placement`.
+    const nodeMapOf = new Map();
+    for (const id of Object.keys(nodes)) {
+        const n = nodes[id];
+        const nodeMap = A.getObjectId(n);
+        if (nodeMap !== null)
+            nodeMapOf.set(nodeMap, id);
+        const text = A.getObjectId(n, "text");
+        if (text !== null)
+            textOf.set(text, id);
+        const isTask = str(n.kind) === "task";
+        const task = isTask ? objects[id] : undefined;
+        const owner = isTask ? (task === undefined ? null : A.getObjectId(task)) : A.getObjectId(n);
+        if (owner !== null)
+            ownerOf.set(owner, id);
+        if (task !== undefined) {
+            const t = A.getObjectId(task);
+            if (t !== null)
+                taskOf.set(t, id);
+        }
+    }
+    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 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) {
+            const key = op.key;
+            const value = op.value;
+            if (op.obj === nodesObj && op.action === "makeMap" && key !== undefined && hidden.has(key))
+                touched.add(key);
+            const text = textOf.get(op.obj);
+            if (text !== undefined && hidden.has(text))
+                touched.add(text);
+            const task = taskOf.get(op.obj);
+            if (task !== undefined && hidden.has(task) && (key === "title" || key === "status"))
+                touched.add(task);
+            // §8, §9: a move writes the node's `placement` register (node.move or
+            // node.resolve_placement). A creation also writes it and is already
+            // counted above; what this adds is a move of an existing node.
+            const moved = nodeMapOf.get(op.obj);
+            if (moved !== undefined && key === "placement" && hidden.has(moved))
+                touched.add(moved);
+            const owner = ownerOf.get(op.obj);
+            if (owner !== undefined && key === "lifecycle")
+                lastLifecycle.set(owner, value);
+        }
+        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 });
+    }
+    if (deletes.length === 0 || edits.length === 0)
+        return [];
+    /**
+     * 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);
+        if (known !== undefined)
+            return known;
+        const out = new Set();
+        const todo = [...(deps.get(hash) ?? [])];
+        while (todo.length > 0) {
+            const h = todo.pop();
+            if (out.has(h))
+                continue;
+            out.add(h);
+            for (const d of deps.get(h) ?? [])
+                if (!out.has(d))
+                    todo.push(d);
+        }
+        ancestry.set(hash, out);
+        return out;
+    };
+    /** 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 && before(d.hash, w.hash)));
+    const deletesOf = new Map();
+    for (const d of heldDeletes)
+        deletesOf.set(d.node, [...(deletesOf.get(d.node) ?? []), d.hash]);
+    const attention = new Set();
+    for (const edit of edits) {
+        if (attention.has(edit.node))
+            continue;
+        const seen = new Set();
+        for (let p = edit.node; p !== undefined && p !== sectionId && nodes[p] !== undefined && !seen.has(p); p = parentOf(p)) {
+            seen.add(p);
+            if ((deletesOf.get(p) ?? []).some((d) => concurrent(d, edit.hash))) {
+                attention.add(edit.node);
+                break;
+            }
+        }
+    }
+    return [...attention].sort();
+}
+//# sourceMappingURL=tree.js.map

package/dist/sections/values.d.ts

@@ -0,0 +1,30 @@
+import type { PrincipalId, ResourceId } from "@openlfcp/core";
+/**
+ * Identifiers and value domains of SHARED-SECTIONS-PROFILE-01 (Working
+ * Draft 0.3): the profile identifier, the actor domain of its §2 binding,
+ * and the enumerations of §4.
+ */
+/** The profile identifier, as a Resource's Genesis names it. */
+export declare const SECTIONS_PROFILE_ID = "org.openlfcp.shared-sections.v1";
+/** §2: the actor domain this profile gives the inherited SOP §8 binding. */
+export declare const SECTIONS_ACTOR_DOMAIN = "OPENLFCP-SHARED-SECTIONS-ACTOR-v1";
+/**
+ * §2: the Automerge actor ID of `principal` editing the section `resource`:
+ * SHA-256(ASCII("OPENLFCP-SHARED-SECTIONS-ACTOR-v1") || resource_id || principal_id),
+ * from the raw 32-byte IDs. It differs from the Shared Objects actor of the
+ * same pair, so a change of one profile never passes as the other's.
+ */
+export declare function deriveSectionActorId(resource: ResourceId, principal: PrincipalId): Uint8Array;
+/** §4.2: the kinds of a node. */
+export declare const NODE_KINDS: readonly ["task", "paragraph", "item", "raw"];
+export type NodeKind = (typeof NODE_KINDS)[number];
+/** §4.2: the kinds that hold collaborative Text. */
+export declare const TEXT_KINDS: ReadonlySet<NodeKind>;
+/** §4.2: the kinds that can parent content; paragraph and raw nodes cannot. */
+export declare const PARENT_KINDS: ReadonlySet<NodeKind>;
+/** §4.2: list_style, on task and item nodes only. */
+export declare const LIST_STYLES: readonly ["bullet", "ordered"];
+export type ListStyle = (typeof LIST_STYLES)[number];
+/** §3: the root containers, each a map. */
+export declare const ROOT_MAPS: readonly ["section", "objects", "nodes", "placements", "extensions"];
+//# sourceMappingURL=values.d.ts.map

package/dist/sections/values.js

@@ -0,0 +1,36 @@
+import { deriveDomainActorId } from "../admission/actor.js";
+/**
+ * Identifiers and value domains of SHARED-SECTIONS-PROFILE-01 (Working
+ * Draft 0.3): the profile identifier, the actor domain of its §2 binding,
+ * and the enumerations of §4.
+ */
+/** The profile identifier, as a Resource's Genesis names it. */
+export const SECTIONS_PROFILE_ID = "org.openlfcp.shared-sections.v1";
+/** §2: the actor domain this profile gives the inherited SOP §8 binding. */
+export const SECTIONS_ACTOR_DOMAIN = "OPENLFCP-SHARED-SECTIONS-ACTOR-v1";
+/**
+ * §2: the Automerge actor ID of `principal` editing the section `resource`:
+ * SHA-256(ASCII("OPENLFCP-SHARED-SECTIONS-ACTOR-v1") || resource_id || principal_id),
+ * from the raw 32-byte IDs. It differs from the Shared Objects actor of the
+ * same pair, so a change of one profile never passes as the other's.
+ */
+export function deriveSectionActorId(resource, principal) {
+    return deriveDomainActorId(SECTIONS_ACTOR_DOMAIN, resource, principal);
+}
+/** §4.2: the kinds of a node. */
+export const NODE_KINDS = Object.freeze(["task", "paragraph", "item", "raw"]);
+/** §4.2: the kinds that hold collaborative Text. */
+export const TEXT_KINDS = new Set(["paragraph", "item", "raw"]);
+/** §4.2: the kinds that can parent content; paragraph and raw nodes cannot. */
+export const PARENT_KINDS = new Set(["task", "item"]);
+/** §4.2: list_style, on task and item nodes only. */
+export const LIST_STYLES = Object.freeze(["bullet", "ordered"]);
+/** §3: the root containers, each a map. */
+export const ROOT_MAPS = Object.freeze([
+    "section",
+    "objects",
+    "nodes",
+    "placements",
+    "extensions",
+]);
+//# sourceMappingURL=values.js.map

package/dist/values.d.ts

@@ -25,28 +25,13 @@ export declare function isUtcTimestamp(text: unknown): text is string;
 export declare const isReverseDomain: (text: unknown) => text is string;
 /** §33 ABNF namespaced-value: x/<reverse-domain>/<value>, value non-empty without "/". */
 export declare const isNamespacedValue: (text: unknown) => text is string;
+/** §8: the actor domain of this profile. */
+export declare const ACTOR_DOMAIN = "OPENLFCP-SHARED-OBJECTS-ACTOR-v1";
 /**
  * §8: the Automerge actor ID of `principal` editing `resource`:
  * SHA-256(ASCII("OPENLFCP-SHARED-OBJECTS-ACTOR-v1") || resource_id || principal_id),
  * from the raw 32-byte IDs.
  */
 export declare function deriveActorId(resource: ResourceId, principal: PrincipalId): Uint8Array;
-/** §11, §13: the only framing version. */
-export declare const FRAMING_VERSION = 1;
-/**
- * Deterministic CBOR of [1, bstr] (§11 shared-objects-change, §13
- * shared-objects-snapshot): the profile plaintext of a Data Unit (one
- * Automerge change) or a Snapshot (one Automerge full save). The bytes are
- * framed as given; checking that they are a valid Automerge change or save
- * is the Automerge binding (LFCP-031).
- */
-export declare function frameProfilePayload(bytes: Uint8Array): Uint8Array;
-/**
- * The inner bytes of a framed profile plaintext. §11: a receiver MUST
- * reject plaintext that is not valid CBOR, not a two-element array, or
- * uses an unsupported framing version; this also requires the
- * deterministic encoding and no trailing bytes. Throws PROFILE_INVALID /
- * INVALID_AUTOMERGE_BYTES (§74.1).
- */
-export declare function unframeProfilePayload(framed: Uint8Array): Uint8Array;
+export { FRAMING_VERSION, frameProfilePayload, unframeProfilePayload, } from "./admission/framing.js";
 //# sourceMappingURL=values.d.ts.map