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

package/dist/sections/data-profile.js

@@ -0,0 +1,383 @@
+import { LfcpError, toHex, } from "@openlfcp/core";
+import { checkChangeActor } from "../admission/actor.js";
+import { checkChange, frameChange, frameSnapshot, unframeChange, unframeSnapshot, } from "../admission/framing.js";
+import { SectionReplica } from "./replica.js";
+import { deriveSectionActorId, SECTIONS_PROFILE_ID } from "./values.js";
+/** Each node's (and the title's) projected state, to tell which ones a merge changed. */
+function fingerprints(s) {
+    const out = new Map();
+    for (const [id, n] of Object.entries(s.nodes))
+        out.set(id, JSON.stringify(n));
+    out.set("", JSON.stringify(s.title));
+    s.order.forEach((e, i) => {
+        out.set(e.id, `${out.get(e.id) ?? ""}|${i}:${e.parent}:${e.depth}`);
+    });
+    return out;
+}
+function changed(before, after) {
+    const ids = new Set([...before.keys(), ...after.keys()]);
+    return [...ids].filter((id) => id !== "" && before.get(id) !== after.get(id)).sort();
+}
+const stateOf = (replica) => ({
+    replica,
+    revision: replica.revision(),
+    fingerprints: fingerprints(replica.snapshot()),
+});
+/**
+ * The nodes that changed from `before` to `to`, by the rule of a receipt's
+ * affectedNodeIds (SDK-SECTIONS-INTEGRATION-01 §3): a node whose fields,
+ * Text, placement or lifecycle changed, a task node whose Task's fields
+ * changed (they live in the Task object, not in the node), and the section
+ * when its title changed.
+ */
+function nodesChanged(before, to) {
+    const after = fingerprints(to.snapshot());
+    const ids = new Set(changed(before.fingerprints, after));
+    if (before.fingerprints.get("") !== after.get("")) {
+        const section = to.validate().sectionId ?? before.replica.validate().sectionId;
+        if (section !== undefined)
+            ids.add(section);
+    }
+    // A task node's ID is its Task's (§4.2): the Tasks the changes wrote, by A.diff where the
+    // document still holds the earlier revision, else (a rebuild) by comparing each Task.
+    const isNode = (id) => before.fingerprints.has(id) || after.has(id);
+    const nodes = [...new Set([...before.fingerprints.keys(), ...after.keys()])].filter((id) => id !== "");
+    const tasks = to.objectsTouchedSince(before.revision) ??
+        // The same replica changed in place without its earlier revision: no state
+        // to compare with, so every task node is reported, never one missed.
+        (before.replica === to
+            ? nodes.filter((id) => to.task(id) !== undefined)
+            : nodes.filter((id) => JSON.stringify(before.replica.task(id) ?? null) !== JSON.stringify(to.task(id) ?? null)));
+    for (const id of tasks)
+        if (isNode(id))
+            ids.add(id);
+    return [...ids].sort();
+}
+export class SharedSectionsDataProfile {
+    dataProfile = SECTIONS_PROFILE_ID;
+    #replica;
+    /** Merged units: unit ID hex → change hash. */
+    #merged = new Map();
+    /** LFCP-accepted units waiting for Automerge dependencies, by unit ID hex. */
+    #pending = new Map();
+    /** LFCP-accepted units whose actor sequence a different change has (SOP §14.1), by unit ID hex. */
+    #held = new Map();
+    #listeners = new Set();
+    constructor(replica) {
+        this.#replica = replica;
+    }
+    /** The current replica (a rebuild replaces it). */
+    get replica() {
+        return this.#replica;
+    }
+    /** §5 nodes-changed for remote merges, rebuilds and recorded local changes. */
+    onNodesChanged(listener) {
+        this.#listeners.add(listener);
+        return () => this.#listeners.delete(listener);
+    }
+    #emit(nodeIds, origin) {
+        if (nodeIds.length === 0)
+            return;
+        const event = Object.freeze({ nodeIds, origin, modelRevision: this.#replica.revision() });
+        for (const l of this.#listeners)
+            l(event);
+    }
+    /** The codec of one unit, bound to its signer's section actor (§2). */
+    codecFor(unit) {
+        const actor = toHex(deriveSectionActorId(unit.resourceId, unit.actor));
+        const bound = (c) => checkChangeActor(c, actor);
+        return {
+            dataProfile: SECTIONS_PROFILE_ID,
+            encode: (change) => frameChange(bound(change).bytes),
+            decode: (plaintext) => bound(unframeChange(plaintext)),
+        };
+    }
+    /**
+     * SDK-SECTIONS-INTEGRATION-01 §3.1: the binding through which a sync
+     * client commits this Principal's batches (structurally the client's
+     * CommitBinding): `stage` validates the intents and changes a copy of the
+     * replica, splitting what one change cannot carry (§12); the staged
+     * operation adopts it, writes the checkpoint with the new units and
+     * records them once committed.
+     */
+    commitBinding(principal) {
+        const codec = this.codecFor({ resourceId: this.#replica.resource, actor: principal });
+        return {
+            codec,
+            section: () => this.#replica.sectionState(),
+            stage: (intents) => {
+                const staged = this.#replica.stage(intents);
+                if (staged === null)
+                    return null;
+                const parts = staged.change.parts;
+                return {
+                    values: parts.map((p) => checkChange(p.change)),
+                    affectedNodeIds: staged.change.affectedNodeIds,
+                    modelRevision: staged.change.modelRevision,
+                    apply: () => staged.apply(),
+                    revert: () => staged.revert(),
+                    writes: (units) => [
+                        {
+                            op: "put-profile-checkpoint",
+                            checkpoint: this.checkpoint(units.map((u, i) => ({
+                                unitId: u.unitId,
+                                ref: parts[i].hash,
+                            }))),
+                        },
+                    ],
+                    committed: (unitIds) => {
+                        unitIds.forEach((unitId, i) => {
+                            const part = parts[i];
+                            if (part !== undefined)
+                                this.#merged.set(toHex(unitId), { unitId, hash: part.hash });
+                        });
+                        this.#emit(staged.change.affectedNodeIds, "local");
+                    },
+                };
+            },
+        };
+    }
+    /**
+     * Records which change one of this client's own units carries: the change
+     * is in the replica already (SectionReplica.stage, then apply). A later
+     * exclusion of the unit rebuilds without it, and the checkpoint keeps it.
+     */
+    recordLocal(unitId, change) {
+        if (!this.#replica.hasChange(change.hash))
+            throw new LfcpError("PROFILE_INVALID", "the change is not in this replica; record only local changes");
+        this.#merged.set(toHex(unitId), { unitId, hash: change.hash });
+        if (change.affectedNodeIds !== undefined)
+            this.#emit(change.affectedNodeIds, "local");
+    }
+    /** Merges one accepted unit's change; throws when the section admission refuses it. */
+    apply(unit, change) {
+        const key = toHex(unit.unitId);
+        const r = this.applyBatch([{ unit, value: change }]);
+        const own = r.rejected.find((x) => toHex(x.unitId) === key);
+        if (own !== undefined) {
+            const e = new LfcpError("PROFILE_INVALID", own.message);
+            e.diagnostic = own.diagnostic;
+            throw e;
+        }
+        const base = { objects: r.objects, diagnostics: r.diagnostics };
+        if (this.#held.has(key))
+            return Object.freeze({
+                merged: r.merged,
+                ...base,
+                held: `held: a different change has actor ${change.actor} sequence ${change.seq} (SOP §14.1)`,
+            });
+        if (!r.merged.some((id) => toHex(id) === key))
+            return Object.freeze({
+                merged: r.merged,
+                ...base,
+                pending: "waiting for the changes it depends on",
+            });
+        return Object.freeze({
+            merged: [unit.unitId, ...r.merged.filter((id) => toHex(id) !== key)],
+            ...base,
+        });
+    }
+    /**
+     * Merges many accepted units at once, with every unit still waiting: one
+     * admission and one engine call for a catch-up. A refused change rejects
+     * only its unit; the units that depend on it wait.
+     */
+    applyBatch(units) {
+        for (const { unit, value } of units)
+            this.#pending.set(toHex(unit.unitId), { unitId: unit.unitId, change: value });
+        return this.#offer(false);
+    }
+    /** Offers every waiting (and, with `retryHeld`, held) unit to the replica. */
+    #offer(retryHeld) {
+        if (retryHeld) {
+            for (const [key, b] of this.#held)
+                this.#pending.set(key, b);
+            this.#held.clear();
+        }
+        const offered = [...this.#pending.values()];
+        const unitsOf = new Map();
+        for (const b of offered)
+            unitsOf.set(b.change.hash, [...(unitsOf.get(b.change.hash) ?? []), b]);
+        const before = stateOf(this.#replica);
+        const out = this.#replica.receiveChanges(offered.map((b) => b.change.bytes));
+        const merged = [];
+        const settle = (hash, to) => {
+            for (const b of unitsOf.get(hash) ?? []) {
+                const key = toHex(b.unitId);
+                this.#pending.delete(key);
+                if (to === "merged") {
+                    this.#merged.set(key, { unitId: b.unitId, hash });
+                    merged.push(b.unitId);
+                }
+                else if (to === "held")
+                    this.#held.set(key, b);
+                else
+                    this.#pending.set(key, b);
+            }
+        };
+        for (const h of [...out.admitted, ...out.duplicates])
+            settle(h, "merged");
+        const rejected = [];
+        for (const r of out.refused) {
+            const hash = r.hash ?? offered[r.index]?.change.hash;
+            if (hash === undefined)
+                continue;
+            if (r.held)
+                settle(hash, "held");
+            else
+                for (const b of unitsOf.get(hash) ?? []) {
+                    this.#pending.delete(toHex(b.unitId));
+                    rejected.push({
+                        unitId: b.unitId,
+                        code: "PROFILE_INVALID",
+                        diagnostic: r.diagnostic,
+                        message: r.message,
+                    });
+                }
+        }
+        const objects = merged.length > 0 ? nodesChanged(before, this.#replica) : [];
+        this.#emit(objects, "remote");
+        return Object.freeze({
+            merged: Object.freeze(merged),
+            pending: Object.freeze([...this.#pending.values()].map((b) => b.unitId)),
+            held: Object.freeze([...this.#held.values()].map((b) => b.unitId)),
+            rejected: Object.freeze(rejected),
+            objects: Object.freeze(objects),
+            diagnostics: Object.freeze([]),
+        });
+    }
+    /**
+     * G-EP7: the state without `unitIds`, rebuilt from the remaining changes.
+     * Merged units whose changes build on an excluded one wait again; held
+     * units are retried, since the rebuild may free their actor sequence.
+     */
+    exclude(unitIds) {
+        const hashes = [];
+        for (const id of unitIds) {
+            const key = toHex(id);
+            this.#pending.delete(key);
+            this.#held.delete(key);
+            const m = this.#merged.get(key);
+            if (m !== undefined) {
+                hashes.push(m.hash);
+                this.#merged.delete(key);
+            }
+        }
+        if (hashes.length === 0)
+            return Object.freeze({ objects: [], pending: [], released: [] });
+        const before = stateOf(this.#replica);
+        const { replica, unapplied } = this.#replica.rebuildWithout(hashes);
+        this.#replica = replica;
+        const waiting = new Set(unapplied);
+        const pending = [];
+        for (const [key, m] of [...this.#merged]) {
+            if (!waiting.has(m.hash))
+                continue;
+            this.#merged.delete(key);
+            pending.push(m.unitId);
+        }
+        const objects = nodesChanged(before, this.#replica);
+        this.#emit(objects, "rebuild");
+        const heldBefore = new Set(this.#held.keys());
+        const retried = heldBefore.size > 0 ? this.#offer(true) : undefined;
+        const released = (retried?.merged ?? []).filter((id) => heldBefore.has(toHex(id)));
+        return Object.freeze({
+            objects: Object.freeze(objects),
+            pending: Object.freeze(pending),
+            released: Object.freeze(released),
+        });
+    }
+    /** Whether this handler holds the unit's change (merged, recorded, waiting or held). */
+    has(unitId) {
+        const key = toHex(unitId);
+        return this.#merged.has(key) || this.#pending.has(key) || this.#held.has(key);
+    }
+    heldUnits() {
+        return [...this.#held.values()].map((b) => b.unitId);
+    }
+    pendingUnits() {
+        return [...this.#pending.values()].map((b) => b.unitId);
+    }
+    /** The Snapshot codec (SOP §13): the full save, framed. */
+    snapshotCodec() {
+        return {
+            dataProfile: SECTIONS_PROFILE_ID,
+            encode: (save) => frameSnapshot(save),
+            decode: (plaintext) => unframeSnapshot(plaintext),
+        };
+    }
+    /** The state to publish as a Snapshot: the replica's full save. */
+    snapshotState() {
+        return this.#replica.save();
+    }
+    /**
+     * Loads a received Snapshot's full save (SOP §13, §14; LFCP-02-028):
+     * every change it holds passes the section admission (§14.1), so a
+     * Snapshot holding a refused change is rejected and nothing changes;
+     * this replica's changes, local work the Snapshot lacks included, are
+     * kept on top. Buffered units whose dependencies it brings are merged.
+     * Returns the nodes that changed and the units merged from the buffer.
+     */
+    loadSnapshot(save) {
+        const before = stateOf(this.#replica);
+        this.#replica = this.#replica.mergeSave(save);
+        const merged = [...this.#offer(false).merged];
+        const nodeIds = nodesChanged(before, this.#replica);
+        this.#emit(nodeIds, "remote");
+        return Object.freeze({ nodeIds: Object.freeze(nodeIds), merged: Object.freeze(merged) });
+    }
+    /** The binding through which a sync client loads and publishes Snapshots. */
+    snapshotBinding() {
+        return {
+            codec: this.snapshotCodec(),
+            load: (save) => {
+                this.loadSnapshot(save);
+            },
+            current: () => this.snapshotState(),
+        };
+    }
+    /** Forgets the whole state, keeping the §9 sequence (SNAP-EP). */
+    reset() {
+        const before = stateOf(this.#replica);
+        this.#replica = this.#replica.emptied();
+        this.#merged.clear();
+        this.#pending.clear();
+        this.#held.clear();
+        this.#emit(nodesChanged(before, this.#replica), "rebuild");
+    }
+    /**
+     * The state to persist: the full save, this actor's sequence and each
+     * merged unit's change, with `local`, this client's units committed in
+     * the same transaction as the checkpoint.
+     */
+    checkpoint(local = []) {
+        const units = new Map([...this.#merged.values()].map((m) => [toHex(m.unitId), { unitId: m.unitId, ref: m.hash }]));
+        // Own units being committed with this checkpoint (recordLocal once committed).
+        for (const u of local)
+            units.set(toHex(u.unitId), { unitId: u.unitId, ref: u.ref });
+        return Object.freeze({
+            resourceId: this.#replica.resource,
+            dataProfile: SECTIONS_PROFILE_ID,
+            state: this.#replica.save(),
+            actorSeq: this.#replica.actorSeq,
+            units: Object.freeze([...units.values()]
+                .map((m) => Object.freeze({ unitId: m.unitId, ref: m.ref }))
+                .sort((a, b) => (toHex(a.unitId) < toHex(b.unitId) ? -1 : 1))),
+        });
+    }
+    /** The handler of a persisted checkpoint; its replica writes nothing below the checkpoint's sequence (§9). */
+    static restore(checkpoint, options) {
+        if (checkpoint.dataProfile !== SECTIONS_PROFILE_ID)
+            throw new LfcpError("DATA_PROFILE_MISMATCH", `a ${checkpoint.dataProfile} checkpoint is not ${SECTIONS_PROFILE_ID}`);
+        // This device's own persisted state: not held to the Snapshot limits (SOP §13.1).
+        const replica = SectionReplica.fromSave(checkpoint.state, { ...options, minSeq: checkpoint.actorSeq }, "local-state");
+        const profile = new SharedSectionsDataProfile(replica);
+        for (const u of checkpoint.units) {
+            if (!replica.hasChange(u.ref))
+                throw new LfcpError("PROFILE_INVALID", `the checkpoint names change ${u.ref}, which its state lacks`);
+            profile.#merged.set(toHex(u.unitId), { unitId: u.unitId, hash: u.ref });
+        }
+        return profile;
+    }
+}
+//# sourceMappingURL=data-profile.js.map

package/dist/sections/dispatch.d.ts

@@ -0,0 +1,41 @@
+import { PROFILE_ID } from "../values.js";
+import { SECTIONS_PROFILE_ID } from "./values.js";
+/**
+ * Profile dispatch (SHARED-SECTIONS-PROFILE-01 §1, §17): a Resource's
+ * Genesis names its Data Profile, and that profile alone selects the model
+ * that reads and writes it. A Resource created as Shared Objects stays one;
+ * nothing is inferred from the document's contents, and a Task reference
+ * (`#task:`) is read with the model of the Resource it names, not by its
+ * textual shape.
+ */
+/** The models this package implements, by Data Profile. */
+export declare const SUPPORTED_DATA_PROFILES: readonly ["org.openlfcp.shared-objects.v1", "org.openlfcp.shared-sections.v1"];
+export type ProfileModel = {
+    readonly kind: "shared-objects";
+    readonly dataProfile: typeof PROFILE_ID;
+} | {
+    readonly kind: "shared-sections";
+    readonly dataProfile: typeof SECTIONS_PROFILE_ID;
+}
+/**
+ * LFCP-WIRE-01 §62: no model here reads this profile. The Resource is
+ * neither interpreted nor written; nothing is created or changed.
+ */
+ | {
+    readonly kind: "profile-unsupported";
+    readonly code: "PROFILE_UNSUPPORTED";
+    readonly dataProfile: string;
+};
+/**
+ * The model of a Resource whose validated Genesis (its Control Chain state)
+ * names `dataProfile`. Exact match only: no prefix, version or case folding.
+ */
+export declare function profileModel(dataProfile: string): ProfileModel;
+/**
+ * §17: the model that reads a Task reference into a Resource, chosen by that
+ * Resource's Data Profile. A standalone Task in a section Resource is a
+ * section Task; the same reference shape in a Shared Objects Resource is a
+ * Shared Objects Task.
+ */
+export declare function taskRefModel(resourceDataProfile: string): ProfileModel;
+//# sourceMappingURL=dispatch.d.ts.map

package/dist/sections/dispatch.js

@@ -0,0 +1,33 @@
+import { PROFILE_ID } from "../values.js";
+import { SECTIONS_PROFILE_ID } from "./values.js";
+/**
+ * Profile dispatch (SHARED-SECTIONS-PROFILE-01 §1, §17): a Resource's
+ * Genesis names its Data Profile, and that profile alone selects the model
+ * that reads and writes it. A Resource created as Shared Objects stays one;
+ * nothing is inferred from the document's contents, and a Task reference
+ * (`#task:`) is read with the model of the Resource it names, not by its
+ * textual shape.
+ */
+/** The models this package implements, by Data Profile. */
+export const SUPPORTED_DATA_PROFILES = Object.freeze([PROFILE_ID, SECTIONS_PROFILE_ID]);
+/**
+ * The model of a Resource whose validated Genesis (its Control Chain state)
+ * names `dataProfile`. Exact match only: no prefix, version or case folding.
+ */
+export function profileModel(dataProfile) {
+    if (dataProfile === PROFILE_ID)
+        return Object.freeze({ kind: "shared-objects", dataProfile });
+    if (dataProfile === SECTIONS_PROFILE_ID)
+        return Object.freeze({ kind: "shared-sections", dataProfile });
+    return Object.freeze({ kind: "profile-unsupported", code: "PROFILE_UNSUPPORTED", dataProfile });
+}
+/**
+ * §17: the model that reads a Task reference into a Resource, chosen by that
+ * Resource's Data Profile. A standalone Task in a section Resource is a
+ * section Task; the same reference shape in a Shared Objects Resource is a
+ * Shared Objects Task.
+ */
+export function taskRefModel(resourceDataProfile) {
+    return profileModel(resourceDataProfile);
+}
+//# sourceMappingURL=dispatch.js.map

package/dist/sections/document.d.ts

@@ -0,0 +1,54 @@
+import { type SnapshotLimits } from "../admission/limits.js";
+import type { Json } from "../validate.js";
+import { type SectionValidation } from "./schema.js";
+import { type SectionTree } from "./tree.js";
+/**
+ * A loaded SHARED-SECTIONS-PROFILE-01 document, read-only: what a Resource
+ * whose Genesis names org.openlfcp.shared-sections.v1 is read as (§1,
+ * profileModel). Loading checks the inherited SOP framing and limits before
+ * the engine sees any byte (§2, §16.1).
+ *
+ * Not yet here: the section admission rules A1–A5 (§14.1), the effective
+ * tree (§7) and the intents (§11), which later tasks add. fromChanges
+ * therefore loads changes a receiver has already admitted, such as its own
+ * persisted history; it is not a receive path.
+ */
+/** An Automerge datatype as the backend reports it: "str", "text", "map", "list", "boolean", "int", … */
+export type ValueType = string;
+export declare class SectionDocument {
+    #private;
+    private constructor();
+    /**
+     * Loads an Automerge full save: a Snapshot image checked against `limits`
+     * (SOP §13.1, at least the floor), or this device's own persisted state
+     * ("local-state"). Throws PROFILE_INVALID / INVALID_AUTOMERGE_BYTES.
+     */
+    static fromSave(save: Uint8Array, limits?: SnapshotLimits | "local-state"): SectionDocument;
+    /**
+     * The document of exactly an admitted change set, in any order. Each
+     * change passes the SOP §11 and §11.1 byte checks first (throws
+     * PROFILE_INVALID / INVALID_AUTOMERGE_BYTES). Changes whose dependencies
+     * are not in the set are returned by hash as unapplied.
+     */
+    static fromChanges(changes: Iterable<Uint8Array>): {
+        readonly document: SectionDocument;
+        readonly unapplied: readonly string[];
+    };
+    /** The current heads, sorted. */
+    heads(): string[];
+    /** The full save of the document. */
+    save(): Uint8Array;
+    /** §3, §4, §14.2: the schema validation of the current state. */
+    validate(): SectionValidation;
+    /** §7, §9, §14.3: the effective tree, hidden nodes and structural facts. */
+    tree(): SectionTree;
+    /**
+     * The datatype of every concurrent value at `path` from the root (map
+     * keys and list indexes), none when absent. Tells a scalar string ("str")
+     * from collaborative Text ("text"), which a JSON reading cannot (§2).
+     */
+    valueTypes(path: readonly (string | number)[]): ValueType[];
+    /** The current state as JSON: scalar strings and Text both read as strings. */
+    toJSON(): Json;
+}
+//# sourceMappingURL=document.d.ts.map

package/dist/sections/document.js

@@ -0,0 +1,101 @@
+import * as A from "@automerge/automerge";
+import { LfcpError } from "@openlfcp/core";
+import { checkChange, checkSaveHeader } from "../admission/framing.js";
+import { checkChangeExpansion, checkSnapshotExpansion, SNAPSHOT_LIMITS_FLOOR, } from "../admission/limits.js";
+import { ProfileInvalidError } from "../profile-invalid.js";
+import { validateSection } from "./schema.js";
+import { deriveTree } from "./tree.js";
+export class SectionDocument {
+    #doc;
+    constructor(doc) {
+        this.#doc = doc;
+    }
+    /**
+     * Loads an Automerge full save: a Snapshot image checked against `limits`
+     * (SOP §13.1, at least the floor), or this device's own persisted state
+     * ("local-state"). Throws PROFILE_INVALID / INVALID_AUTOMERGE_BYTES.
+     */
+    static fromSave(save, limits = SNAPSHOT_LIMITS_FLOOR) {
+        checkSaveHeader(save);
+        if (limits !== "local-state")
+            checkSnapshotExpansion(save, limits);
+        try {
+            return new SectionDocument(A.load(save));
+        }
+        catch (e) {
+            if (e instanceof LfcpError)
+                throw e;
+            throw new ProfileInvalidError("INVALID_AUTOMERGE_BYTES", `invalid Automerge save (SOP §13): ${e.message}`);
+        }
+    }
+    /**
+     * The document of exactly an admitted change set, in any order. Each
+     * change passes the SOP §11 and §11.1 byte checks first (throws
+     * PROFILE_INVALID / INVALID_AUTOMERGE_BYTES). Changes whose dependencies
+     * are not in the set are returned by hash as unapplied.
+     */
+    static fromChanges(changes) {
+        const checked = [...changes].map((bytes) => {
+            checkChangeExpansion(bytes);
+            return checkChange(bytes);
+        });
+        const [doc] = A.applyChanges(A.init(), checked.map((c) => c.bytes));
+        const unapplied = checked.filter((c) => !A.hasHeads(doc, [c.hash])).map((c) => c.hash);
+        return Object.freeze({
+            document: new SectionDocument(doc),
+            unapplied: Object.freeze(unapplied),
+        });
+    }
+    /** The current heads, sorted. */
+    heads() {
+        return [...A.getHeads(this.#doc)].sort();
+    }
+    /** The full save of the document. */
+    save() {
+        return A.save(this.#doc);
+    }
+    /** §3, §4, §14.2: the schema validation of the current state. */
+    validate() {
+        return validateSection(this.#doc);
+    }
+    /** §7, §9, §14.3: the effective tree, hidden nodes and structural facts. */
+    tree() {
+        return deriveTree(this.#doc);
+    }
+    /**
+     * The datatype of every concurrent value at `path` from the root (map
+     * keys and list indexes), none when absent. Tells a scalar string ("str")
+     * from collaborative Text ("text"), which a JSON reading cannot (§2).
+     */
+    valueTypes(path) {
+        const backend = A.getBackend(this.#doc);
+        const heads = A.getHeads(this.#doc);
+        let obj = "_root";
+        for (const [i, prop] of path.entries()) {
+            const values = backend.getAll(obj, prop, heads);
+            if (i === path.length - 1)
+                return values.map((v) => v[0]);
+            const only = values.length === 1 ? values[0] : undefined;
+            if (only === undefined || !["map", "list", "text"].includes(only[0]))
+                return [];
+            obj = only[1];
+        }
+        return ["map"];
+    }
+    /** The current state as JSON: scalar strings and Text both read as strings. */
+    toJSON() {
+        return plain(this.#doc);
+    }
+}
+function plain(value) {
+    if (A.isImmutableString(value))
+        return value.toString();
+    if (value instanceof A.Counter)
+        return value.value;
+    if (Array.isArray(value))
+        return value.map(plain);
+    if (value !== null && typeof value === "object" && !(value instanceof Uint8Array))
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, plain(v)]));
+    return value;
+}
+//# sourceMappingURL=document.js.map

package/dist/sections/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * SHARED-SECTIONS-PROFILE-01 (org.openlfcp.shared-sections.v1, Working
+ * Draft 0.3): profile dispatch, the profile's values and actor binding,
+ * schema validation of a section document (LFCP-02-011), and its writer
+ * with the section and creation intents (LFCP-02-012 to 016), and the
+ * admission of received changes (LFCP-02-017).
+ * `@openlfcp/shared-objects/sections`. Its admission (SOP §§7–18) is the
+ * shared `@openlfcp/shared-objects/admission` with SECTIONS_ACTOR_DOMAIN.
+ */
+export { ADMISSION_ORDER, type AdmissionDiagnostic, SectionAdmissionError, } from "./admission.js";
+export { type SectionsApplyResult, type SectionsBatchResult, type SectionsCheckpoint, type SectionsCodec, type SectionsCommitBinding, type SectionsExcludeResult, type SectionsNodesChanged, type SectionsSnapshotBinding, type SectionsSnapshotCodec, type SectionsStagedOperation, type SectionsUnit, SharedSectionsDataProfile, } from "./data-profile.js";
+export { type ProfileModel, profileModel, SUPPORTED_DATA_PROFILES, taskRefModel, } from "./dispatch.js";
+export { SectionDocument, type ValueType } from "./document.js";
+export { AUTHORING_BUDGET, type SectionIntent, type SectionIntentCode, SectionIntentError, type SectionLocalChange, type SectionReceiveResult, type SectionRefusal, SectionReplica, type SectionReplicaOptions, type SectionSnapshot, type SectionSnapshotNode, type SectionUnit, type StagedSectionChange, type TextEdit, } from "./replica.js";
+export { SECTION_DIAGNOSTIC_ORDER, type SectionDiagnostic, type SectionProblem, type SectionValidation, validateSection, } from "./schema.js";
+export { deriveTree, type SectionTree, type StructuralFact, type TreeEntry, } from "./tree.js";
+export { deriveSectionActorId, LIST_STYLES, type ListStyle, NODE_KINDS, type NodeKind, PARENT_KINDS, ROOT_MAPS, SECTIONS_ACTOR_DOMAIN, SECTIONS_PROFILE_ID, TEXT_KINDS, } from "./values.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/sections/index.js

@@ -0,0 +1,18 @@
+/**
+ * SHARED-SECTIONS-PROFILE-01 (org.openlfcp.shared-sections.v1, Working
+ * Draft 0.3): profile dispatch, the profile's values and actor binding,
+ * schema validation of a section document (LFCP-02-011), and its writer
+ * with the section and creation intents (LFCP-02-012 to 016), and the
+ * admission of received changes (LFCP-02-017).
+ * `@openlfcp/shared-objects/sections`. Its admission (SOP §§7–18) is the
+ * shared `@openlfcp/shared-objects/admission` with SECTIONS_ACTOR_DOMAIN.
+ */
+export { ADMISSION_ORDER, SectionAdmissionError, } from "./admission.js";
+export { SharedSectionsDataProfile, } from "./data-profile.js";
+export { profileModel, SUPPORTED_DATA_PROFILES, taskRefModel, } from "./dispatch.js";
+export { SectionDocument } from "./document.js";
+export { AUTHORING_BUDGET, SectionIntentError, SectionReplica, } from "./replica.js";
+export { SECTION_DIAGNOSTIC_ORDER, validateSection, } from "./schema.js";
+export { deriveTree, } from "./tree.js";
+export { deriveSectionActorId, LIST_STYLES, NODE_KINDS, PARENT_KINDS, ROOT_MAPS, SECTIONS_ACTOR_DOMAIN, SECTIONS_PROFILE_ID, TEXT_KINDS, } from "./values.js";
+//# sourceMappingURL=index.js.map