@joe-broadhead/messaging 0.0.0-stage → 0.7.1

package/dist/lib/modules/core/consent.js

@@ -0,0 +1,199 @@
+/**
+ * Consent (spec §6.9), pure: signing and verifying a person's grants, choosing between two copies of one grant,
+ * re-signing the grants of a removed device, and deciding what a receiving person's daemon does with an envelope
+ * from another person. The daemon supplies the facts (the relation, the grants whose signers are current, the
+ * delegation chain) and the clock.
+ */
+import { asMessagingError, parseWith } from "./check.js";
+import { canonicalize } from "./jcs.js";
+import { utf8 } from "./b64u.js";
+import { DOMAIN, LIMITS, PROTOCOL } from "./schema/common.js";
+import { ConsentGrant, grantProblem, } from "./schema/consent.js";
+import { MessagingError } from "./schema/errors.js";
+import { sign, signingInput, verifyInput } from "./sign.js";
+import { ulid } from "./ulid.js";
+/** Signs a new grant with `identity`, a device of `args.person`. Throws `invalid_request` for a grant that breaks a rule. */
+export function signConsentGrant(identity, args) {
+    const unsigned = {
+        v: PROTOCOL,
+        realm: args.realm,
+        id: args.id ?? ulid(args.now),
+        person: args.person,
+        by: identity.machine,
+        ts: args.now,
+        subject: args.subject,
+        ...defined(args.levels),
+    };
+    return finish(identity, unsigned);
+}
+function finish(identity, unsigned) {
+    const problem = grantProblem(unsigned);
+    if (problem)
+        throw new MessagingError("invalid_request", problem);
+    const grant = parseWith(ConsentGrant, { ...unsigned, sig: sign(identity, DOMAIN.grant, unsigned) }, "grant");
+    if (utf8(canonicalize(grant)).length > LIMITS.grantBytes)
+        throw new MessagingError("too_large", `a grant is at most ${LIMITS.grantBytes} bytes`);
+    return grant;
+}
+/**
+ * Checks a grant received from another device: the schema and its rules, the size, the realm, the person when
+ * given, and the signature by `by` over the raw value (so members a newer device adds stay covered). Whether `by`
+ * is a current device of `person` is the caller's: that changes over time (spec §6.9, "Signers"). Throws only
+ * MessagingError: `invalid_request`, `too_large` or `bad_signature`.
+ */
+export function verifyConsentGrant(raw, ctx) {
+    try {
+        const grant = parseWith(ConsentGrant, raw, "grant");
+        // I-JSON within LIMITS.jsonDepth, then the size of the whole grant as received.
+        if (utf8(canonicalize(raw)).length > LIMITS.grantBytes)
+            throw new MessagingError("too_large", `a grant is at most ${LIMITS.grantBytes} bytes`);
+        const { sig, ...unsigned } = raw;
+        const input = signingInput(DOMAIN.grant, unsigned);
+        if (grant.realm !== ctx.realm)
+            throw new MessagingError("invalid_request", "the grant is for another realm");
+        if (ctx.person !== undefined && grant.person !== ctx.person)
+            throw new MessagingError("invalid_request", "the grant is another person's");
+        if (typeof sig !== "string" || !verifyInput(grant.by, input, sig))
+            throw new MessagingError("bad_signature", "the grant's signature is invalid");
+        return grant;
+    }
+    catch (error) {
+        throw asMessagingError(error, "grant");
+    }
+}
+/** The key one grant is stored under: its subject. One grant per subject. */
+export function grantSubjectKey(subject) {
+    return "person" in subject ? `person:${subject.person}` : `channel:${subject.channel}`;
+}
+/**
+ * Of two copies of the grant for one subject, the one that counts (spec §6.9, "Merging"): the newer by `ts`, then
+ * by `id`. Copies that tie on both are one grant signed twice: a copy whose signer is current beats one whose
+ * signer is not; between two current signers (or two removed ones), the signer that sorts first wins, then the
+ * signature. The choice is commutative and idempotent, so devices that see the same copies in any order agree.
+ */
+export function preferGrant(a, b, current) {
+    if (a.ts !== b.ts)
+        return a.ts > b.ts ? a : b;
+    if (a.id !== b.id)
+        return a.id > b.id ? a : b;
+    const ca = current(a.by);
+    const cb = current(b.by);
+    if (ca !== cb)
+        return ca ? a : b;
+    if (a.by !== b.by)
+        return a.by < b.by ? a : b;
+    return a.sig <= b.sig ? a : b;
+}
+/** Levels that narrow reach: blocks never lapse (spec §6.9, "Signers"). */
+export function restrictingLevels(grant) {
+    return defined({
+        chat: grant.chat === "blocked" || grant.chat === "muted" ? grant.chat : undefined,
+        agentMail: grant.agentMail === "blocked" ? grant.agentMail : undefined,
+        ask: grant.ask === "no" ? grant.ask : undefined,
+        discoverable: grant.discoverable === false ? false : undefined,
+    });
+}
+/** Levels that widen reach: they lapse with their signer, into the person's review list. */
+export function wideningLevels(grant) {
+    return defined({
+        chat: grant.chat === "open" ? grant.chat : undefined,
+        agentMail: grant.agentMail === "open" ? grant.agentMail : undefined,
+        ask: grant.ask === "open" || grant.ask === "request" ? grant.ask : undefined,
+        trustedUntil: grant.trustedUntil,
+        discoverable: grant.discoverable === true ? true : undefined,
+    });
+}
+/**
+ * Re-signs a grant whose signer is no longer current with `identity`, a current device of the same person
+ * (spec §6.9, "Signers"). `keep: "all"` (a replacement) keeps every level; `keep: "restricting"` (any other
+ * removal) keeps only the restricting ones, and returns undefined when there are none: the grant lapses whole.
+ * The copy keeps `id` and `ts`, so it never overrides a newer change, and records `resignedAt`.
+ */
+export function resignGrant(identity, grant, opts) {
+    const levels = opts.keep === "all" ? levelsOf(grant) : restrictingLevels(grant);
+    if (opts.keep === "restricting" && Object.keys(levels).length === 0)
+        return undefined;
+    const { v, realm, id, person, ts, subject } = grant;
+    return finish(identity, { v, realm, id, person, by: identity.machine, ts, subject, ...levels, resignedAt: Math.max(opts.now, ts) });
+}
+export function levelsOf(grant) {
+    return defined({ chat: grant.chat, agentMail: grant.agentMail, ask: grant.ask, trustedUntil: grant.trustedUntil, discoverable: grant.discoverable });
+}
+const DEFAULTS = {
+    org: { chat: "open", agentMail: "open", ask: "request" },
+    contact: { chat: "open", agentMail: "blocked", ask: "no" },
+    stranger: { chat: "request_required", agentMail: "blocked", ask: "no" },
+};
+const ASK_RANK = { no: 0, request: 1, open: 2 };
+/**
+ * Spec §6.9, "Effective policy": each level is the person grant's when it sets one; otherwise, for `ask` and
+ * `agentMail`, the most permissive among the grants of channels the sender is in; otherwise the relation's
+ * default. An expired `trustedUntil` reads as absent. The caller passes only grants whose signer is current.
+ */
+export function effectivePolicy(relation, person, channels, now) {
+    const base = DEFAULTS[relation];
+    const channelAsk = channels.map((grant) => grant.ask).filter((level) => level !== undefined);
+    const channelMail = channels.map((grant) => grant.agentMail).filter((level) => level !== undefined);
+    const ask = person?.ask ?? (channelAsk.length > 0 ? channelAsk.reduce((a, b) => (ASK_RANK[b] > ASK_RANK[a] ? b : a)) : undefined);
+    const agentMail = person?.agentMail ?? (channelMail.length > 0 ? (channelMail.includes("open") ? "open" : "blocked") : undefined);
+    const trusted = person?.trustedUntil !== undefined && person.trustedUntil > now && person.ask === "open";
+    return {
+        chat: person?.chat ?? base.chat,
+        agentMail: agentMail ?? base.agentMail,
+        ask: ask ?? base.ask,
+        ...(trusted ? { trustedUntil: person.trustedUntil } : {}),
+        granted: { chat: person?.chat !== undefined, agentMail: agentMail !== undefined, ask: ask !== undefined },
+    };
+}
+/**
+ * Spec §6.9, "Enforcement": step 10 of the receiver order (§5), before the inbound policy of §8.3.
+ * - The person's own traffic is delivered as `self`.
+ * - Answers to the person's own traffic are delivered whatever the grants, so a change never strands a task.
+ * - A `blocked` chat level refuses every other class from the sender.
+ * - A `stranger` reaches the person only through a level a grant opened; otherwise `request_required`.
+ * - Lines follow `chat` (person) or `agentMail` (agent); `muted` delivers silently.
+ * - Asks follow `ask`: `open` delivers guarded, or trusted while the person grant trusts the sender and every person
+ *   in the delegation chain is the sender or the receiver; `request` holds; `no` refuses, `request_required` when
+ *   it is the default of a `contact` or a `stranger`.
+ * - A message request from a `stranger` is held for the person to accept; from anyone else it is a DM line.
+ */
+export function decide(args) {
+    const { inbound } = args;
+    if (args.relation === "self" || args.sender === args.self)
+        return { action: "deliver", consent: "self" };
+    const policy = effectivePolicy(args.relation, args.grant, args.channels, args.now);
+    const trusted = (chain) => policy.trustedUntil !== undefined && chain.every((person) => person === args.sender || person === args.self);
+    if (inbound.kind === "answer")
+        return { action: "deliver", consent: trusted([args.sender]) ? "trusted" : "guarded" };
+    if (policy.chat === "blocked")
+        return { action: "refuse", code: "refused" };
+    const stranger = args.relation === "stranger";
+    switch (inbound.kind) {
+        case "op":
+            if (stranger)
+                return { action: "refuse", code: "request_required" };
+            return { action: "deliver", consent: "guarded" };
+        case "line":
+            if (inbound.agent) {
+                if (policy.agentMail === "open")
+                    return { action: "deliver", consent: "guarded" };
+                return { action: "refuse", code: stranger && !policy.granted.agentMail ? "request_required" : "refused" };
+            }
+            if (policy.chat === "request_required")
+                return { action: "refuse", code: "request_required" };
+            return policy.chat === "muted" ? { action: "deliver", consent: "guarded", silent: true } : { action: "deliver", consent: "guarded" };
+        case "request":
+            if (stranger)
+                return { action: "hold" };
+            return policy.chat === "muted" ? { action: "deliver", consent: "guarded", silent: true } : { action: "deliver", consent: "guarded" };
+        case "ask":
+            if (policy.ask === "open")
+                return { action: "deliver", consent: trusted(inbound.chain) ? "trusted" : "guarded" };
+            if (policy.ask === "request")
+                return { action: "hold" };
+            return { action: "refuse", code: !policy.granted.ask && (stranger || args.relation === "contact") ? "request_required" : "refused" };
+    }
+}
+function defined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined));
+}

package/dist/lib/modules/core/contact-card.js

@@ -0,0 +1,74 @@
+/**
+ * Contact cards (spec §6.9, "Contact cards"), pure: what a person tells another person they may send them, signed by
+ * one of the person's devices. A card is advice for the sender's surfaces; the person's own daemon enforces the
+ * grants, which may be newer.
+ */
+import { utf8 } from "./b64u.js";
+import { asMessagingError, parseWith } from "./check.js";
+import { effectivePolicy } from "./consent.js";
+import { canonicalize } from "./jcs.js";
+import { DOMAIN, LIMITS, PROTOCOL } from "./schema/common.js";
+import { cardProblem, ContactCard } from "./schema/consent.js";
+import { MessagingError } from "./schema/errors.js";
+import { sign, signingInput, verifyInput } from "./sign.js";
+/** Signs a card with `identity`, a device of `args.from`. Throws `invalid_request` or `too_large`. */
+export function signContactCard(identity, args) {
+    const unsigned = {
+        v: PROTOCOL,
+        realm: args.realm,
+        from: args.from,
+        to: args.to,
+        by: identity.machine,
+        seq: args.seq,
+        ts: args.now,
+        ...(args.grantId !== undefined ? { grantId: args.grantId } : {}),
+        can: { chat: args.can.chat, agentMail: args.can.agentMail, ask: args.can.ask, ...(args.can.trustedUntil !== undefined ? { trustedUntil: args.can.trustedUntil } : {}) },
+    };
+    const problem = cardProblem(unsigned);
+    if (problem)
+        throw new MessagingError("invalid_request", problem);
+    const card = parseWith(ContactCard, { ...unsigned, sig: sign(identity, DOMAIN.card, unsigned) }, "card");
+    if (utf8(canonicalize(card)).length > LIMITS.cardBytes)
+        throw new MessagingError("too_large", `a card is at most ${LIMITS.cardBytes} bytes`);
+    return card;
+}
+/**
+ * Checks a card received from another person: the schema and its rules, the size, the realm, its two persons, and
+ * the signature by `by` over the raw value. Whether `by` is a current device of `from` is the caller's: a card
+ * whose signer was removed counts as absent. Throws only MessagingError: `invalid_request`, `too_large` or
+ * `bad_signature`.
+ */
+export function verifyContactCard(raw, ctx) {
+    try {
+        const card = parseWith(ContactCard, raw, "card");
+        if (utf8(canonicalize(raw)).length > LIMITS.cardBytes)
+            throw new MessagingError("too_large", `a card is at most ${LIMITS.cardBytes} bytes`);
+        const { sig, ...unsigned } = raw;
+        const input = signingInput(DOMAIN.card, unsigned);
+        if (card.realm !== ctx.realm)
+            throw new MessagingError("invalid_request", "the card is for another realm");
+        if (card.from !== ctx.from)
+            throw new MessagingError("invalid_request", "the card is not its sender's");
+        if (card.to !== ctx.to)
+            throw new MessagingError("invalid_request", "the card is for another person");
+        if (typeof sig !== "string" || !verifyInput(card.by, input, sig))
+            throw new MessagingError("bad_signature", "the card's signature is invalid");
+        return card;
+    }
+    catch (error) {
+        throw asMessagingError(error, "card");
+    }
+}
+/**
+ * What a card says for a sender of `relation` with the person grant `grant` (spec §6.9, "Contact cards"): the
+ * person grant over the relation's defaults. Channel grants are not on a card: the sender knows its own channels.
+ */
+export function cardCan(relation, grant, now) {
+    const policy = effectivePolicy(relation, grant, [], now);
+    return {
+        chat: policy.chat === "open" || policy.chat === "muted",
+        agentMail: policy.agentMail === "open",
+        ask: policy.ask,
+        ...(policy.trustedUntil !== undefined ? { trustedUntil: policy.trustedUntil } : {}),
+    };
+}

package/dist/lib/modules/core/conversation/context.js

@@ -0,0 +1,80 @@
+/**
+ * History as context (spec §16.8): what one agent of a person may mine of one conversation, from the person's rules,
+ * the defaults, and the conversation's policy. The stricter of the person's rule and the policy wins. Pure.
+ */
+import { parseWith } from "../check.js";
+import { ContextRules, } from "../schema/conversation.js";
+/** The defaults that apply where a person has no rule (decided 2026-11-08). `lookbackDays` absent: the retention. */
+export const CONTEXT_DEFAULTS = Object.freeze({
+    own: Object.freeze({ access: "allow" }),
+    "channel.public": Object.freeze({ access: "allow", lookbackDays: 90 }),
+    "channel.private": Object.freeze({ access: "ask", lookbackDays: 30 }),
+    group: Object.freeze({ access: "ask", lookbackDays: 30 }),
+    dm: Object.freeze({ access: "ask", lookbackDays: 14 }),
+});
+/**
+ * The scope a conversation falls in for `person`: `own` when its participant persons are `person` alone, else its
+ * kind (a channel by its visibility). A `self` conversation has none: no agent mines it.
+ */
+export function contextKindOf(person, conv) {
+    if (conv.kind === "self")
+        return undefined;
+    if (conv.persons.length > 0 && conv.persons.every((p) => p === person))
+        return "own";
+    if (conv.kind === "channel")
+        return conv.visibility === "public" ? "channel.public" : "channel.private";
+    return conv.kind;
+}
+/**
+ * The person's rule for (agent, conversation), most specific first: a `cid` scope over a `kind` scope, then a named
+ * agent over `*`. Undefined when no rule matches; the defaults then apply.
+ */
+export function matchContextRule(rules, agent, cid, kind) {
+    const rank = (r) => {
+        const scope = "cid" in r.scope ? (r.scope.cid === cid ? 2 : 0) : r.scope.kind === kind ? 1 : 0;
+        if (scope === 0)
+            return 0;
+        const who = r.agent === agent ? 2 : r.agent === "*" ? 1 : 0;
+        return who === 0 ? 0 : scope * 2 + who;
+    };
+    let best;
+    let bestRank = 0;
+    for (const rule of rules) {
+        const r = rank(rule);
+        if (r > bestRank) {
+            best = rule;
+            bestRank = r;
+        }
+    }
+    return best;
+}
+/**
+ * The effective rule for agent `agent` of `person` reading `conv` as context (not by its seat):
+ * - the conversation's policy `seats` or `none` forbids it, whatever the person's rule says;
+ * - else the person's rule, or the default: `off` forbids, `ask` holds, `allow` serves;
+ * - the lookback is the smallest of the rule's (or the default's) `lookbackDays`, the conversation's `retainDays`,
+ *   and the person's local retention for it.
+ * Throws `invalid_request` for a rule set that fails `ContextRules`.
+ */
+export function resolveContext(args) {
+    const rules = parseWith(ContextRules, args.rules, "context rules");
+    const kind = contextKindOf(args.person, args.conv);
+    if (kind === undefined)
+        return { access: "forbidden", source: "self" };
+    if (args.conv.agentContext !== "members")
+        return { access: "forbidden", source: "policy" };
+    const rule = matchContextRule(rules, args.agent, args.conv.cid, kind);
+    const chosen = rule ?? CONTEXT_DEFAULTS[kind];
+    if (chosen.access === "off")
+        return { access: "forbidden", source: "rule" };
+    const bounds = [chosen.lookbackDays, args.conv.retainDays, args.localRetentionDays].filter((n) => n !== undefined);
+    return { access: chosen.access, lookbackDays: Math.min(...bounds), source: rule ? "rule" : "default" };
+}
+/**
+ * What a seated agent reads by its seat (spec §16.8): everything from its seat's `seq` on, unless the policy is
+ * `none`, when it reads only the events addressed to it and the threads they are in. The person's rules do not
+ * apply to seat reads.
+ */
+export function seatReads(agentContext) {
+    return agentContext === "none" ? "items" : "conversation";
+}

package/dist/lib/modules/core/conversation/event.js

@@ -0,0 +1,100 @@
+/** Conversation events: admission, signing and the log's hash chain (spec §16.2, §16.4). */
+import { createHash } from "node:crypto";
+import { b64u, utf8 } from "../b64u.js";
+import { asMessagingError, parseWith } from "../check.js";
+import { canonicalize } from "../jcs.js";
+import { assertEd25519PublicKey } from "../keys.js";
+import { DOMAIN, LIMITS } from "../schema/common.js";
+import { ConvEvent as ConvEventSchema, ConvId as ConvIdSchema } from "../schema/conversation.js";
+import { MessagingError } from "../schema/errors.js";
+import { sign, verify } from "../sign.js";
+/** h(0) of `cid`'s log: SHA-256(DOMAIN.convGenesis ‖ JCS(cid)), base64url. */
+export function convGenesisHash(cid) {
+    const id = parseWith(ConvIdSchema, cid, "conversation id");
+    return createHash("sha256").update(utf8(DOMAIN.convGenesis)).update(utf8(canonicalize(id))).digest("base64url");
+}
+/** SHA-256(JCS(event)), the raw digest, as the chain links it. Throws `invalid_request` for non-I-JSON. */
+export function convEventDigest(event) {
+    return createHash("sha256").update(utf8(canonicalize(event))).digest();
+}
+/** h(seq) = SHA-256(h(seq − 1) ‖ SHA-256(JCS(event))), over the raw 32-byte digests, base64url. */
+export function convEntryHash(prev, event) {
+    return convLinkHash(prev, convEventDigest(event));
+}
+/** `convEntryHash` from the event's digest: what a member checks for an entry whose content has expired. */
+export function convLinkHash(prev, digest) {
+    const previous = b64u.decode(prev);
+    if (previous.length !== 32 || digest.length !== 32)
+        throw new MessagingError("invalid_request", "a chain link joins two 32-byte digests");
+    return createHash("sha256").update(previous).update(digest).digest("base64url");
+}
+/** The header of an event: everything but `body` and `sig`. JCS of it is the AAD of a sealed body. */
+export function convEventHeader(event) {
+    const { body: _body, sig: _sig, ...header } = event;
+    return header;
+}
+/**
+ * Checks that `raw` is I-JSON within `LIMITS.jsonDepth` and at most `LIMITS.convEventBytes` (`too_large`), that it
+ * matches `ConvEvent`, and that `by.device` is a usable Ed25519 key. Returns a frozen JSON copy of the raw value, so
+ * the signature and the hash cover exactly what was received. The signature is not checked.
+ */
+export function admitConvEvent(raw) {
+    const json = canonicalize(raw);
+    if (Buffer.byteLength(json, "utf8") > LIMITS.convEventBytes)
+        throw new MessagingError("too_large", "conversation event is over LIMITS.convEventBytes");
+    parseWith(ConvEventSchema, raw, "conversation event");
+    const event = deepFreeze(JSON.parse(json));
+    assertEd25519PublicKey(event.by.device, "event device");
+    return event;
+}
+/**
+ * Signs an event (spec §16.4): `sig = Ed25519(by.device, DOMAIN.convEvent ‖ JCS(event without sig))`. `by.device`
+ * must be `identity`'s machine. Refuses an event that fails the schema (`invalid_request`) or is over
+ * `LIMITS.convEventBytes` once signed (`too_large`). Authority is checked when the event is applied.
+ */
+export function signConvEvent(identity, unsigned) {
+    try {
+        const value = JSON.parse(canonicalize(unsigned));
+        if (value.by?.device !== identity.machine)
+            throw new MessagingError("invalid_request", "by.device must be the signing machine");
+        const signed = { ...value, sig: sign(identity, DOMAIN.convEvent, value) };
+        admitConvEvent(signed);
+        return signed;
+    }
+    catch (error) {
+        throw asMessagingError(error, "conversation event");
+    }
+}
+/** True only for a valid signature by `event.by.device` over the event without `sig`. Never throws. */
+export function convEventSigned(event) {
+    const { sig, ...unsigned } = event;
+    return verify(event.by.device, DOMAIN.convEvent, unsigned, sig);
+}
+/**
+ * Admits `raw` (`admitConvEvent`) and checks its signature over the raw value (`bad_signature`). Membership and
+ * authority are `ConvLog.apply`'s. Throws only MessagingError.
+ */
+export function verifyConvEvent(raw) {
+    try {
+        const event = admitConvEvent(raw);
+        if (!convEventSigned(event))
+            throw new MessagingError("bad_signature", "conversation event signature is invalid");
+        return event;
+    }
+    catch (error) {
+        throw asMessagingError(error, "conversation event");
+    }
+}
+/** Freezes a JSON value and everything in it, iteratively. */
+export function deepFreeze(value) {
+    const pending = [value];
+    while (pending.length > 0) {
+        const next = pending.pop();
+        if (typeof next !== "object" || next === null || Object.isFrozen(next))
+            continue;
+        Object.freeze(next);
+        for (const child of Object.values(next))
+            pending.push(child);
+    }
+    return value;
+}

package/dist/lib/modules/core/conversation/ids.js

@@ -0,0 +1,38 @@
+/** Conversation and participant identifiers (spec §16.1). */
+import { createHash } from "node:crypto";
+import { utf8 } from "../b64u.js";
+import { parseWith } from "../check.js";
+import { base32Lower } from "../directory/person.js";
+import { canonicalize } from "../jcs.js";
+import { DOMAIN, PersonId } from "../schema/common.js";
+import { ParticipantId } from "../schema/conversation.js";
+function derived(prefix, domain, value) {
+    const digest = createHash("sha256").update(utf8(domain)).update(utf8(canonicalize(value))).digest();
+    return prefix + base32Lower(digest).slice(0, 26);
+}
+/**
+ * The id of the dm between `a` and `b`: `"d_" + base32lower(SHA-256(DOMAIN.dm ‖ JCS([a, b] sorted)))[0..26]`. Both
+ * ends derive the same id, so a dm has no create race. `a` may equal `b`: a person's note to themselves.
+ */
+export function dmConvId(a, b) {
+    const pair = [parseWith(ParticipantId, a, "participant"), parseWith(ParticipantId, b, "participant")].sort();
+    return derived("d_", DOMAIN.dm, pair);
+}
+/** The id of `person`'s own `self` conversation: `"s_" + base32lower(SHA-256(DOMAIN.self ‖ JCS(person)))[0..26]`. */
+export function selfConvId(person) {
+    return derived("s_", DOMAIN.self, parseWith(PersonId, person, "person"));
+}
+/** The person a participant is, or belongs to. */
+export function participantPerson(p) {
+    const slash = p.indexOf("/");
+    return slash < 0 ? p : p.slice(0, slash);
+}
+/** The agent's session name, for an agent participant. */
+export function participantAgent(p) {
+    const slash = p.indexOf("/");
+    return slash < 0 ? undefined : p.slice(slash + 1);
+}
+/** The participant an event's `by` names: `person`, or `person/agent`. */
+export function participantOf(by) {
+    return by.agent === undefined ? by.person : `${by.person}/${by.agent}`;
+}

package/dist/lib/modules/core/conversation/link.js

@@ -0,0 +1,35 @@
+/**
+ * Linked channels (spec §16.10), reserved: the checks a person's own devices make on `via` lines against the link
+ * records of the person's `self` conversation. No daemon uses them yet. Pure.
+ */
+import { parseWith } from "../check.js";
+import { LinkRecord as LinkRecordSchema } from "../schema/conversation.js";
+import { MessagingError } from "../schema/errors.js";
+/** The links in force: for each link id the record written last (records are in `seq` order), unless revoked. */
+export function currentLinks(records) {
+    const last = new Map();
+    for (const raw of records) {
+        const record = parseWith(LinkRecordSchema, raw, "link record");
+        last.set(record.id, record);
+    }
+    return [...last.values()].filter((r) => r.revokedAt === undefined);
+}
+/**
+ * Checks a line's `via` against the author's links, as the author's own devices can (other members cannot see the
+ * person's links): only a person writes from a linked channel, never an agent, and only through a link of that
+ * channel that the authoring device hosts and that is in force. Throws `forbidden`.
+ */
+export function checkVia(body, by, links) {
+    if (body.t !== "line" || body.via === undefined)
+        return;
+    if (by.agent !== undefined)
+        throw new MessagingError("forbidden", "only a person writes from a linked channel");
+    const channel = body.via.channel;
+    if (!currentLinks(links).some((l) => l.channel === channel && l.host === by.device)) {
+        throw new MessagingError("forbidden", "no link of this channel is in force on the authoring device");
+    }
+}
+/** The reader id of a link's channel provider, for the audience guard: `ext:<channel>:<link id>`. */
+export function linkReader(link) {
+    return `ext:${link.channel}:${link.id}`;
+}