@joe-broadhead/messaging 0.7.0 → 0.8.0

package/dist/types/core/conversation/context.d.ts

@@ -0,0 +1,56 @@
+import type { PersonId, SessionName } from "../schema/common.js";
+import { type AgentContext, type ContextAccess, type ContextKind, type ContextRule, type ConvId, type ConvKind, type Visibility } from "../schema/conversation.js";
+/** The defaults that apply where a person has no rule (decided 2026-11-08). `lookbackDays` absent: the retention. */
+export declare const CONTEXT_DEFAULTS: Readonly<Record<ContextKind, {
+    access: ContextAccess;
+    lookbackDays?: number;
+}>>;
+/** The facts about a conversation that resolution reads. `persons` are its participant persons at the read. */
+export interface ContextConv {
+    cid: ConvId;
+    kind: ConvKind;
+    visibility?: Visibility;
+    persons: readonly PersonId[];
+    retainDays: number;
+    agentContext: AgentContext;
+}
+/**
+ * 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 declare function contextKindOf(person: PersonId, conv: Pick<ContextConv, "kind" | "visibility" | "persons">): ContextKind | undefined;
+/**
+ * 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 declare function matchContextRule(rules: readonly ContextRule[], agent: SessionName, cid: ConvId, kind: ContextKind): ContextRule | undefined;
+/** The outcome of a context read: served, held for the person (`ask`), or refused. */
+export type ContextDecision = {
+    access: "allow" | "ask";
+    lookbackDays: number;
+    source: "rule" | "default";
+} | {
+    access: "forbidden";
+    source: "policy" | "rule" | "self";
+};
+/**
+ * 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 declare function resolveContext(args: {
+    person: PersonId;
+    agent: SessionName;
+    conv: ContextConv;
+    rules: readonly ContextRule[];
+    localRetentionDays?: number;
+}): ContextDecision;
+/**
+ * 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 declare function seatReads(agentContext: AgentContext): "conversation" | "items";

package/dist/types/core/conversation/event.d.ts

@@ -0,0 +1,36 @@
+import type { Identity } from "../identity.js";
+import { type Hash } from "../schema/common.js";
+import { type ConvAnyEvent, type ConvEventHeader, type ConvId, type UnsignedConvEvent } from "../schema/conversation.js";
+/** h(0) of `cid`'s log: SHA-256(DOMAIN.convGenesis ‖ JCS(cid)), base64url. */
+export declare function convGenesisHash(cid: ConvId): Hash;
+/** SHA-256(JCS(event)), the raw digest, as the chain links it. Throws `invalid_request` for non-I-JSON. */
+export declare function convEventDigest(event: unknown): Uint8Array;
+/** h(seq) = SHA-256(h(seq − 1) ‖ SHA-256(JCS(event))), over the raw 32-byte digests, base64url. */
+export declare function convEntryHash(prev: Hash, event: unknown): Hash;
+/** `convEntryHash` from the event's digest: what a member checks for an entry whose content has expired. */
+export declare function convLinkHash(prev: Hash, digest: Uint8Array): Hash;
+/** The header of an event: everything but `body` and `sig`. JCS of it is the AAD of a sealed body. */
+export declare function convEventHeader(event: ConvAnyEvent | Omit<ConvAnyEvent, "sig"> | ConvEventHeader): ConvEventHeader;
+/**
+ * Checks that `raw` is I-JSON within `LIMITS.jsonDepth` and at most `LIMITS.convEventBytes` (`too_large`), that it
+ * matches `ConvAnyEvent` (an op, a msg or a key share), 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 declare function admitConvEvent(raw: unknown): ConvAnyEvent;
+/**
+ * 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 declare function signConvEvent<E extends UnsignedConvEvent>(identity: Identity, unsigned: E): E & {
+    sig: string;
+};
+/** True only for a valid signature by `event.by.device` over the event without `sig`. Never throws. */
+export declare function convEventSigned(event: ConvAnyEvent): boolean;
+/**
+ * Admits `raw` (`admitConvEvent`) and checks its signature over the raw value (`bad_signature`). Membership and
+ * authority are `ConvLog.apply`'s. Throws only MessagingError.
+ */
+export declare function verifyConvEvent(raw: unknown): ConvAnyEvent;
+/** Freezes a JSON value and everything in it, iteratively. */
+export declare function deepFreeze<T>(value: T): T;

package/dist/types/core/conversation/guest-invitation.d.ts

@@ -0,0 +1,8 @@
+import type { Identity } from "../identity.js";
+import { GuestInvitation } from "../schema/guest-invitation.js";
+import type { ConvLog } from "./log.js";
+/** The inviting device seals this preview to the invitee. No history or sender keys accompany it. */
+export declare function createGuestInvitation(log: ConvLog, to: string, identity: Identity, issuedAt: number, expiresAt: number): GuestInvitation;
+/** The accept event signs this same preview. Changed audience/policy/head requires a fresh preview. */
+export declare function verifyGuestInvitation(log: ConvLog, raw: unknown, to: string, at: number): GuestInvitation;
+export declare function guestHistoryExposure(history: "none" | "shared"): string;

package/dist/types/core/conversation/ids.d.ts

@@ -0,0 +1,18 @@
+import { PersonId } from "../schema/common.js";
+import { type ConvId, ParticipantId } from "../schema/conversation.js";
+/**
+ * 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 declare function dmConvId(a: ParticipantId, b: ParticipantId): ConvId;
+/** The id of `person`'s own `self` conversation: `"s_" + base32lower(SHA-256(DOMAIN.self ‖ JCS(person)))[0..26]`. */
+export declare function selfConvId(person: PersonId): ConvId;
+/** The person a participant is, or belongs to. */
+export declare function participantPerson(p: ParticipantId): PersonId;
+/** The agent's session name, for an agent participant. */
+export declare function participantAgent(p: ParticipantId): string | undefined;
+/** The participant an event's `by` names: `person`, or `person/agent`. */
+export declare function participantOf(by: {
+    person: PersonId;
+    agent?: string | undefined;
+}): ParticipantId;

package/dist/types/core/conversation/link.d.ts

@@ -0,0 +1,16 @@
+import type { MachineId, PersonId } from "../schema/common.js";
+import { type LinkRecord, type MsgBody, type ReaderId } from "../schema/conversation.js";
+/** The links in force: for each link id the record written last (records are in `seq` order), unless revoked. */
+export declare function currentLinks(records: readonly LinkRecord[]): LinkRecord[];
+/**
+ * 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 declare function checkVia(body: MsgBody, by: {
+    person: PersonId;
+    device: MachineId;
+    agent?: string;
+}, links: readonly LinkRecord[]): void;
+/** The reader id of a link's channel provider, for the audience guard: `ext:<channel>:<link id>`. */
+export declare function linkReader(link: Pick<LinkRecord, "channel" | "id">): ReaderId;

package/dist/types/core/conversation/log.d.ts

@@ -0,0 +1,157 @@
+import type { AnchorRelation } from "../realm.js";
+import { type Hash, type MachineId, type PersonId } from "../schema/common.js";
+import { type AgentContext, type BridgePolicy, type ConvEvent, type ConvExpiredEntry, type ConvHead, type ConvId, type ConvKeysEvent, type ConvKind, type ConvLogEntry, type ConvRole, type HistoryPolicy, type MsgKind, type ParticipantId, type Permit, type RekeyCause, type RespondTo, type Visibility } from "../schema/conversation.js";
+import type { RealmId } from "../schema/realm.js";
+import type { RequestBinding } from "./requests.js";
+/** A participant at one position. */
+export interface ConvParticipant {
+    p: ParticipantId;
+    person: PersonId;
+    /** The agent's session name, for an agent participant. */
+    agent?: string;
+    role: ConvRole;
+    /** `invited` until the person accepts, or until the agent's person seats it. */
+    state: "member" | "invited";
+    device?: MachineId;
+    respondTo?: RespondTo;
+    /** The seq at which it became a participant. */
+    since: number;
+}
+/** Everything the log decides at one position. Frozen. */
+export interface ConvSnapshot {
+    cid: ConvId;
+    kind: ConvKind;
+    visibility?: Visibility;
+    history: HistoryPolicy;
+    retainDays: number;
+    org?: string;
+    post: Permit;
+    invite: Permit;
+    pins: Permit;
+    archived: boolean;
+    epoch: number;
+    /** The seq and `ts` of the op that started the epoch. */
+    epochSince: number;
+    epochTs: number;
+    /** Causes that need a `rekey` before the next message (spec §16.7). Sorted. */
+    rekeyDue: RekeyCause[];
+    /** Sorted by `p`. */
+    participants: ConvParticipant[];
+    /** The effective policy. In a channel the owners' and admins'; in a dm or a group the strictest vote. */
+    agentContext: AgentContext;
+    /**
+     * Who may mirror the conversation to a linked channel (reserved: no daemon acts on it yet). In a channel the
+     * owners' and admins'; in a dm or a group the strictest vote, where a person who has not voted counts as `none`.
+     */
+    bridges: BridgePolicy;
+    /** dm and group: each participant person's votes, sorted by person. */
+    votes: ConvVote[];
+    /** The seq of the entry that last changed any of the above. */
+    changed: number;
+}
+/** One participant person's policy votes in a dm or group. */
+export interface ConvVote {
+    person: PersonId;
+    agentContext?: AgentContext;
+    bridges?: BridgePolicy;
+}
+/** What a member knows of one event, by id. */
+export interface ConvMessage {
+    id: string;
+    seq: number;
+    class: ConvEvent["class"];
+    author: ParticipantId;
+    /** Known when the body was opened. */
+    t?: MsgKind;
+    deleted: boolean;
+    pinned: boolean;
+    reactions: {
+        key: string;
+        by: ParticipantId[];
+    }[];
+    /** For a task request: its executor. */
+    taskTo?: ParticipantId;
+    /** For a task request: true. */
+    taskRoot?: boolean;
+}
+/** Checks only a live append can make: they depend on the realm now, not on the log. */
+export interface ConvLiveChecks {
+    /** Wall-clock time; the event's `ts` must be within `skewMs` (default `LIMITS.clockSkewMs`) of it (`expired`). */
+    now?: number;
+    skewMs?: number;
+    /** True when `device` is a current device of `person` in the realm (`unknown_device` otherwise). */
+    isDevice?: (person: PersonId, device: MachineId) => boolean;
+    /** True only when the verified realm has removed this device. */
+    isRemovedDevice?: (device: MachineId) => boolean;
+    /** Retained identity history for portable request proofs, including historical devices. */
+    requestBinding?: RequestBinding;
+    /** The org of `person`, for `join`, and for an add of a person who is not a guest (`forbidden`). */
+    orgOf?: (person: PersonId) => string | undefined;
+}
+export interface ConvApplyOptions {
+    /** The opened body of a `msg` entry; the message rules run only with it. */
+    body?: unknown;
+    live?: ConvLiveChecks;
+}
+/** Local admission metadata, never part of an entry's signed wire representation. */
+interface ReplayEntry {
+    entry: unknown;
+    body?: unknown;
+    held?: boolean;
+}
+/**
+ * A verified conversation log. Every method throws only MessagingError. Entries are kept as frozen copies of the
+ * received JSON, so hashes cover exactly what was received.
+ */
+export declare class ConvLog {
+    #private;
+    readonly cid: ConvId;
+    readonly realm: RealmId;
+    private constructor();
+    /** An empty log of `cid` in `realm`: its head is {0, h(0)}. */
+    static open(cid: ConvId, realm: RealmId): ConvLog;
+    /** Replays a prefix; callers with a verified realm supply its removed-device check for every device rekey. */
+    static fromEntries(cid: ConvId, realm: RealmId, entries: ReplayEntry[], checks?: Pick<ConvLiveChecks, "isRemovedDevice" | "requestBinding">, onInvalidBody?: (seq: number) => void): ConvLog;
+    head(): ConvHead;
+    /** The last op's seq and hash, or {0, h(0)}: what an author puts in `opHead`. */
+    opHead(): ConvHead;
+    /** h(seq), for 0 ≤ seq ≤ head. */
+    hashAt(seq: number): Hash | undefined;
+    entries(): (ConvLogEntry | ConvExpiredEntry)[];
+    /** Held links are in the hash chain, but contribute neither state nor messages. */
+    held(): number[];
+    /** The state at the head; undefined before `create`. */
+    state(): ConvSnapshot | undefined;
+    /** The state after the entry at `seq`, as a log holding only entries 1..seq has it. */
+    at(seq: number): ConvSnapshot | undefined;
+    /** What a member knows of the event `id`. */
+    message(id: string): ConvMessage | undefined;
+    /**
+     * Gossip (spec §16.4): `ahead` past the head (fetch up to it first); `consistent` when h(seq) is ours; `diverged`
+     * when this log has another hash at that seq, a fork whose evidence is the signed event that named it.
+     */
+    relate(head: ConvHead): AnchorRelation;
+    /**
+     * Checks one entry and appends it, in order: I-JSON and size (`invalid_request`, `too_large`); schema, realm and
+     * cid (`invalid_request`); the chain, seq = head + 1 and prev = h(head) (`conv_conflict`); the signature
+     * (`bad_signature`); the live checks given (`expired`, `unknown_device`); a reused id (`duplicate`); then the
+     * authority rules of spec §16.7. Returns the entry's h(seq).
+     */
+    apply(raw: unknown, options?: ConvApplyOptions): Hash;
+    /**
+     * Appends a `msg` entry whose content the relay expired (spec §16.4, "Retention"), by its digest: the chain stays
+     * verifiable and the state does not change. The create (seq 1) never expires (`invalid_request`), nor does any op:
+     * a later op head that names this seq fails.
+     */
+    applyExpired(raw: ConvExpiredEntry): Hash;
+    /**
+     * Checks a key share against this log (spec §16.6); a share is not an entry, so nothing changes. In order: I-JSON,
+     * size and schema, realm and cid (`invalid_request`, `too_large`); the signature (`bad_signature`); the live checks
+     * given (`expired`, `unknown_device`); `by.agent` absent (`forbidden`); `opHead` names an op of this log
+     * (`conv_conflict`); then, in the state at `opHead`, the author's person is a member participant person
+     * (`not_member`) and the recipient's person a participant person (`forbidden`), and live, the recipient device is a
+     * current device of that person (`unknown_device`). Returns the frozen event.
+     */
+    checkShare(raw: unknown, live?: ConvLiveChecks): ConvKeysEvent;
+}
+export {};

package/dist/types/core/conversation/ratchet.d.ts

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import { type MachineId } from "../schema/common.js";
+import { type KeyShare } from "../schema/conversation.js";
+/** One ratchet step: the message key for this index and the chain key for the next. */
+export declare function chainStep(ck: Uint8Array): {
+    mk: Uint8Array;
+    next: Uint8Array;
+};
+/** A sender chain as a device stores it. */
+export declare const SenderChainState: z.ZodObject<{
+    epoch: z.ZodNumber;
+    device: z.ZodString;
+    start: z.ZodNumber;
+    origin: z.ZodString;
+    idx: z.ZodNumber;
+    ck: z.ZodString;
+    startedAt: z.ZodNumber;
+}, z.core.$strict>;
+export type SenderChainState = z.infer<typeof SenderChainState>;
+/** The sending side of one chain. `next()` hands out each message key once. */
+export declare class SenderChain {
+    #private;
+    readonly epoch: number;
+    readonly device: MachineId;
+    /** The index this chain starts at. */
+    readonly start: number;
+    readonly startedAt: number;
+    private constructor();
+    /** A new chain at `idx` (default 0) of `epoch`, from a fresh random chain key. */
+    static start(args: {
+        epoch: number;
+        device: MachineId;
+        idx?: number;
+        now: number;
+    }): SenderChain;
+    /** `start` with a caller-chosen chain key: for test vectors, and for a device restoring its own state. */
+    static startWith(args: {
+        epoch: number;
+        device: MachineId;
+        idx?: number;
+        now: number;
+    }, ck: Uint8Array): SenderChain;
+    static restore(raw: unknown): SenderChain;
+    export(): SenderChainState;
+    /** The index the next message gets. */
+    get idx(): number;
+    /** The share that lets a receiver open every message of this chain: its chain key at its start. */
+    share(): KeyShare;
+    /** The key for the next message, and its index. The chain moves past it. */
+    next(): {
+        idx: number;
+        mk: Uint8Array;
+    };
+    /** True once the chain has sent `LIMITS.chainMessages` messages or is `LIMITS.chainMaxMs` old: rotate before the next. */
+    due(now: number): boolean;
+    /** A fresh chain in the same epoch, starting at this chain's next index. Share it before sending on it. */
+    rotate(now: number): SenderChain;
+    /** `rotate` with a caller-chosen chain key, for test vectors. */
+    rotateWith(now: number, ck: Uint8Array): SenderChain;
+}
+export declare const ReceiverChainsState: z.ZodObject<{
+    chains: z.ZodArray<z.ZodObject<{
+        epoch: z.ZodNumber;
+        device: z.ZodString;
+        start: z.ZodNumber;
+        origin: z.ZodString;
+        pos: z.ZodNumber;
+        ck: z.ZodString;
+        skipped: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodString], null>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ReceiverChainsState = z.infer<typeof ReceiverChainsState>;
+/**
+ * The receiving side: every chain this device holds for one conversation, by (epoch, sender device). It derives
+ * forward only and hands out each message key once; a message that arrives out of order uses a key kept from an
+ * earlier derivation, at most `LIMITS.skippedKeys` per sender and epoch. The chain keys at each share's index are
+ * kept, so the device can share them with a late joiner (history `shared`).
+ */
+export declare class ReceiverChains {
+    #private;
+    static restore(raw: unknown): ReceiverChains;
+    export(): ReceiverChainsState;
+    /**
+     * Adds a share. The first share at a given (epoch, device, idx) wins: a later one with another key changes
+     * nothing, and `add` returns false. Returns true when the share was new.
+     */
+    add(raw: KeyShare): boolean;
+    /** Every share this device holds, from each chain's start: what it shares with a late joiner. */
+    shares(): KeyShare[];
+    /**
+     * The message key for (`epoch`, `device`, `idx`), used once. `not_found` when no share covers it, or its key was
+     * already used or dropped; `too_large` when it is more than `LIMITS.skippedKeys` past the chain's position.
+     */
+    messageKey(epoch: number, device: MachineId, idx: number): Uint8Array;
+}

package/dist/types/core/conversation/request-log.d.ts

@@ -0,0 +1,24 @@
+import { type RequestActivation } from "../schema/contact-request.js";
+import { type ConvLogEntry } from "../schema/conversation.js";
+import { type ConvApplyOptions, type ConvLog } from "./log.js";
+import { type RequestBinding } from "./requests.js";
+export interface RequestReservation {
+    proof: RequestActivation;
+    completed?: {
+        seq: number;
+        digest: string;
+    };
+}
+export interface RequestLogState {
+    required: boolean;
+    active: boolean;
+    reservations: Map<string, RequestReservation>;
+}
+/** Rebuilds permanent activation state even when imported messages have expired. */
+export declare function requestLogState(log: ConvLog, binding: RequestBinding): RequestLogState;
+/** Checks before appending. The relay also checks live org admission on create. No mutation on failure. */
+export declare function checkRequestEvent(log: ConvLog, raw: unknown, binding: RequestBinding, body?: unknown): void;
+/** Member admission seam for the cut-over engine; preserves wrapper authorship and verifies source separately. */
+export declare function applyRequestEntry(log: ConvLog, entry: ConvLogEntry, binding: RequestBinding, options?: ConvApplyOptions): string;
+/** Public author for a verified import, never the importing device. The renderer uses this only after admission. */
+export declare function importedRequestAuthor(log: ConvLog, id: string, binding: RequestBinding): string | undefined;

package/dist/types/core/conversation/request-seal.d.ts

@@ -0,0 +1,6 @@
+import type { Identity } from "../identity.js";
+import { RequestImport } from "../schema/contact-request.js";
+import { type ConvMsgEvent } from "../schema/conversation.js";
+import type { UnsealedMsg } from "./seal.js";
+export declare function sealRequestImport(identity: Identity, header: UnsealedMsg, body: RequestImport, mk: Uint8Array): ConvMsgEvent;
+export declare function openRequestImport(raw: unknown, mk: Uint8Array): RequestImport;

package/dist/types/core/conversation/requests.d.ts

@@ -0,0 +1,14 @@
+import type { Identity } from "../identity.js";
+import { ContactAuthorization, PortableRequest, RequestActivation, RequestDecision, RequestDescriptor, RequestOpening } from "../schema/contact-request.js";
+/** Retained, verified identity history must bind every proof's device to its person; absence fails closed. */
+export type RequestBinding = (person: string, device: string) => boolean;
+export declare const requestCommitment: (opening: RequestOpening) => string;
+export declare const requestDigest: (descriptor: RequestDescriptor) => string;
+export declare function verifyRequestDescriptor(raw: unknown, binding: RequestBinding): RequestDescriptor;
+export declare function verifyPortableRequest(raw: unknown, binding: RequestBinding): PortableRequest;
+export declare function createPortableRequest(identity: Identity, args: Omit<RequestDescriptor, "by" | "sig" | "commitment">, text: string): PortableRequest;
+export declare function verifyRequestDecision(raw: unknown, descriptor: RequestDescriptor, binding: RequestBinding): RequestDecision;
+export declare function signRequestDecision(identity: Identity, d: RequestDescriptor, answer: RequestDecision["answer"], at: number): RequestDecision;
+export declare function verifyRequestActivation(raw: unknown, binding: RequestBinding): RequestActivation;
+export declare function signContactAuthorization(identity: Identity, args: Omit<ContactAuthorization, "sig" | "by">): ContactAuthorization;
+export declare function verifyContactAuthorization(raw: unknown, binding: RequestBinding): ContactAuthorization;

package/dist/types/core/conversation/seal.d.ts

@@ -0,0 +1,70 @@
+import type { Identity } from "../identity.js";
+import { type EncKey, type MachineId, type PersonId } from "../schema/common.js";
+import { type ConvKeysEvent, ConvMeta, type ConvMsgEvent, type ConvOp, type ConvOpEvent, type KeyShare, MsgBody, SettingBody } from "../schema/conversation.js";
+/** A message event before its body: the header its author signs, with `class: "msg"`. */
+export type UnsealedMsg = Omit<ConvMsgEvent, "body" | "sig">;
+/** A keys event before its body. */
+export type UnsealedKeys = Omit<ConvKeysEvent, "body" | "sig">;
+/** A recipient device of a key share: its person, its machine and its X25519 key, as the realm verified them. */
+export interface ShareRecipient {
+    person: PersonId;
+    device: MachineId;
+    enc: EncKey;
+}
+/** Fixed randomness of one sealed share, for test vectors: the ephemeral X25519 private key and the nonce. */
+export interface ShareRandomness {
+    ephemeral: Uint8Array;
+    nonce: Uint8Array;
+}
+/** Seals `body` under `mk` as the body of `unsealed` and signs the event. Throws only MessagingError. */
+export declare function sealConvMsg(identity: Identity, unsealed: UnsealedMsg, body: MsgBody, mk: Uint8Array): ConvMsgEvent;
+/** `sealConvMsg` with a caller-chosen nonce: for test vectors only (`@messaging/core/testing`). */
+export declare function sealConvMsgWith(identity: Identity, unsealed: UnsealedMsg, body: MsgBody, mk: Uint8Array, nonce: Uint8Array): ConvMsgEvent;
+/**
+ * Opens a `msg` event's body with its message key: `bad_signature` when it fails to open, `too_large` over
+ * `LIMITS.convPlaintextBytes`, `invalid_request` when the plaintext is not a `MsgBody` (parsed with `parseWire`).
+ * The caller has verified the event's signature.
+ */
+export declare function openConvMsg(event: ConvMsgEvent, mk: Uint8Array): MsgBody;
+/** `create.sealedMeta`: JCS(meta) sealed under the creator's epoch-0 key 0, with the create event's header as AAD. */
+export declare function sealConvMeta(header: Omit<ConvOpEvent, "body" | "sig">, meta: ConvMeta, mk0: Uint8Array): string;
+/** `sealConvMeta` with a caller-chosen nonce: for test vectors only. */
+export declare function sealConvMetaWith(header: Omit<ConvOpEvent, "body" | "sig">, meta: ConvMeta, mk0: Uint8Array, nonce: Uint8Array): string;
+/** Opens a `create` event's `sealedMeta`. Errors as for `openConvMsg`; `not_found` when it has none. */
+export declare function openConvMeta(event: ConvOpEvent, mk0: Uint8Array): ConvMeta;
+/**
+ * Seals `shares` to one recipient device as the body of `unsealed`, and signs the event: one `keys` event per
+ * recipient device (spec §16.6), at most `LIMITS.keyShares` chain keys. Throws only MessagingError.
+ */
+export declare function sealKeyShare(identity: Identity, unsealed: UnsealedKeys, recipient: ShareRecipient, shares: KeyShare[]): ConvKeysEvent;
+/** `sealKeyShare` with fixed randomness: for test vectors only. */
+export declare function sealKeyShareWith(identity: Identity, unsealed: UnsealedKeys, recipient: ShareRecipient, shares: KeyShare[], randomness: ShareRandomness): ConvKeysEvent;
+/**
+ * Opens a `keys` event sealed to `identity`'s device: `not_found` when it is another device's, `bad_signature` when it
+ * fails to open, `invalid_request` when the plaintext is not a share payload. The caller has checked the event
+ * (`ConvLog.checkShare`).
+ */
+export declare function openKeyShares(event: ConvKeysEvent, identity: Identity): KeyShare[];
+/** A sealed op as its author builds it: the op without `sealed`. */
+export type UnsealedStateOp = Omit<Extract<ConvOp, {
+    op: "meta";
+}>, "sealed"> | Omit<Extract<ConvOp, {
+    op: "setting";
+}>, "sealed">;
+/** An op event before its body is sealed: the header and the op without `sealed`. */
+export type UnsealedOpEvent = Omit<ConvOpEvent, "body" | "sig"> & {
+    body: UnsealedStateOp;
+};
+/**
+ * Seals `content` (a `ConvMeta` for `meta`, a `SettingBody` of the op's kind for `setting`) under `mk`, the author's
+ * message key at the op's (`epoch`, `idx`), and signs the op event. Throws only MessagingError.
+ */
+export declare function sealConvState(identity: Identity, unsealed: UnsealedOpEvent, content: unknown, mk: Uint8Array): ConvOpEvent;
+/** `sealConvState` with a caller-chosen nonce: for test vectors only. */
+export declare function sealConvStateWith(identity: Identity, unsealed: UnsealedOpEvent, content: unknown, mk: Uint8Array, nonce: Uint8Array): ConvOpEvent;
+/**
+ * Opens a `meta` or `setting` op with the author's message key at its (`epoch`, `idx`): a `ConvMeta`, or a
+ * `SettingBody` whose `s` is the op's `kind` (`invalid_request` otherwise). `not_found` for another op; errors as
+ * for `openConvMsg`. The caller has applied the event to the log.
+ */
+export declare function openConvState(event: ConvOpEvent, mk: Uint8Array): ConvMeta | SettingBody;