@openlfcp/shared-objects 0.1.4 → 0.2.0-beta.1

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,290 @@
+import * as A from "@automerge/automerge";
+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);
+}
+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(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 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(objects[id], field);
+            return vs.length > 1 ? [{ id, field, values: vs.map((v) => v ?? "").sort() }] : [];
+        }))),
+        candidates,
+        validation,
+    });
+}
+/**
+ * §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, or a Task's title or status. Two changes are
+ * concurrent when neither is in the other's dependencies.
+ */
+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();
+    for (const id of Object.keys(nodes)) {
+        const n = nodes[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();
+    const deletes = [];
+    const edits = [];
+    for (const bytes of A.getAllChanges(doc)) {
+        const change = A.decodeChange(bytes);
+        deps.set(change.hash, change.deps);
+        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);
+            const owner = ownerOf.get(op.obj);
+            if (owner !== undefined && key === "lifecycle")
+                lastLifecycle.set(owner, value);
+        }
+        for (const [owner, value] of lastLifecycle)
+            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 [];
+    /** Every change `hash` depends on, transitively, memoized. */
+    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;
+    };
+    const concurrent = (a, b) => a !== b && !ancestorsOf(a).has(b) && !ancestorsOf(b).has(a);
+    const deletesOf = new Map();
+    for (const d of deletes)
+        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

package/dist/values.js

@@ -1,6 +1,5 @@
 import { fromBase64url, ID32_LENGTH, LfcpError, principalId, toBase64url, } from "@openlfcp/core";
-import { sha256 } from "@openlfcp/crypto";
-import { ProfileInvalidError } from "./profile-invalid.js";
+import { deriveDomainActorId } from "./admission/actor.js";
 /**
  * Value-level rules of SHARED-OBJECTS-PROFILE-01: Principal references,
  * Local Dates, timestamps, reverse-domain names, namespaced values, the
@@ -60,104 +59,17 @@ const NAMESPACED = new RegExp(`^x/${LABEL}(?:\\.${LABEL})+/[^/]+$`, "u");
 export const isReverseDomain = (text) => typeof text === "string" && REVERSE_DOMAIN.test(text);
 /** §33 ABNF namespaced-value: x/<reverse-domain>/<value>, value non-empty without "/". */
 export const isNamespacedValue = (text) => typeof text === "string" && NAMESPACED.test(text);
-const ACTOR_DOMAIN = Uint8Array.from("OPENLFCP-SHARED-OBJECTS-ACTOR-v1", (c) => c.charCodeAt(0));
+/** §8: the actor domain of this profile. */
+export 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 function deriveActorId(resource, principal) {
-    for (const [what, id] of [
-        ["the Resource ID", resource],
-        ["the Principal ID", principal],
-    ]) {
-        if (!(id instanceof Uint8Array) || id.length !== ID32_LENGTH)
-            throw new LfcpError("INVALID_LENGTH", `${what} must be the raw 32-byte ID`);
-    }
-    const input = new Uint8Array(ACTOR_DOMAIN.length + 2 * ID32_LENGTH);
-    input.set(ACTOR_DOMAIN, 0);
-    input.set(resource, ACTOR_DOMAIN.length);
-    input.set(principal, ACTOR_DOMAIN.length + ID32_LENGTH);
-    return sha256(input);
-}
-/** §11, §13: the only framing version. */
-export const FRAMING_VERSION = 1;
-/** The deterministic CBOR head of a byte string of `length` bytes (major type 2, shortest form). */
-function bstrHead(length) {
-    if (length < 24)
-        return [0x40 | length];
-    if (length < 0x100)
-        return [0x58, length];
-    if (length < 0x10000)
-        return [0x59, length >> 8, length & 0xff];
-    if (length <= 0xffffffff)
-        return [
-            0x5a,
-            (length >>> 24) & 0xff,
-            (length >>> 16) & 0xff,
-            (length >>> 8) & 0xff,
-            length & 0xff,
-        ];
-    throw new LfcpError("OUT_OF_RANGE", "the framed bytes are too long");
-}
-/**
- * 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 function frameProfilePayload(bytes) {
-    if (!(bytes instanceof Uint8Array))
-        throw new LfcpError("INVALID_LENGTH", "framing takes bytes");
-    const head = bstrHead(bytes.length);
-    const out = new Uint8Array(2 + head.length + bytes.length);
-    out.set([0x82, FRAMING_VERSION, ...head], 0);
-    out.set(bytes, 2 + head.length);
-    return out;
-}
-/**
- * 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 function unframeProfilePayload(framed) {
-    const fail = (why) => {
-        throw new ProfileInvalidError("INVALID_AUTOMERGE_BYTES", `invalid profile framing: ${why}`);
-    };
-    if (!(framed instanceof Uint8Array) || framed.length < 3)
-        return fail("too short");
-    if (framed[0] !== 0x82)
-        return fail("not a two-element array");
-    if (framed[1] !== FRAMING_VERSION)
-        return fail("unsupported framing version");
-    const first = framed[2];
-    if (first >> 5 !== 2)
-        return fail("the second element is not a byte string");
-    const info = first & 0x1f;
-    let length;
-    let offset;
-    const at = (i) => framed[i];
-    if (info < 24)
-        [length, offset] = [info, 3];
-    else if (info === 24)
-        [length, offset] = [at(3), 4];
-    else if (info === 25)
-        [length, offset] = [(at(3) << 8) | at(4), 5];
-    else if (info === 26)
-        [length, offset] = [((at(3) << 24) >>> 0) + (at(4) << 16) + (at(5) << 8) + at(6), 7];
-    else
-        return fail("unsupported byte string length");
-    if (offset > framed.length)
-        return fail("truncated");
-    const bytes = framed.subarray(offset);
-    if (bytes.length !== length)
-        return fail(bytes.length < length ? "truncated" : "trailing bytes");
-    const canonical = bstrHead(length);
-    if (canonical.length !== offset - 2)
-        return fail("non-shortest byte string length");
-    return Uint8Array.from(bytes);
+    return deriveDomainActorId(ACTOR_DOMAIN, resource, principal);
 }
+// §11, §13: the profile framing [1, bytes] is part of the admission module
+// both profiles share (./admission/framing.ts); re-exported here unchanged.
+export { FRAMING_VERSION, frameProfilePayload, unframeProfilePayload, } from "./admission/framing.js";
 //# sourceMappingURL=values.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openlfcp/shared-objects",
-  "version": "0.1.4",
+  "version": "0.2.0-beta.1",
   "description": "SHARED-OBJECTS-PROFILE-01 (org.openlfcp.shared-objects.v1) implementation.",
   "keywords": [
     "openlfcp",
@@ -31,6 +31,14 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./admission": {
+      "types": "./dist/admission/index.d.ts",
+      "import": "./dist/admission/index.js"
+    },
+    "./sections": {
+      "types": "./dist/sections/index.d.ts",
+      "import": "./dist/sections/index.js"
     }
   },
   "files": [
@@ -40,13 +48,13 @@
   ],
   "publishConfig": {
     "access": "public",
-    "tag": "latest"
+    "tag": "beta"
   },
   "dependencies": {
     "@automerge/automerge": "3.5.0",
     "fflate": "0.8.3",
-    "@openlfcp/crypto": "^0.1.4",
-    "@openlfcp/core": "^0.1.4"
+    "@openlfcp/core": "^0.2.0-beta.1",
+    "@openlfcp/crypto": "^0.2.0-beta.1"
   },
   "devDependencies": {
     "fast-check": "4.10.2"