@joe-broadhead/messaging 0.0.0-stage → 0.7.1

package/dist/lib/modules/core/schema/directory.js

@@ -0,0 +1,169 @@
+/**
+ * Hosted realms: the key directory's signed and hashed objects (spec §15). Every object here is hashed or
+ * signed as JCS, so each is strict: an unknown member is refused rather than carried unsigned.
+ */
+import { z } from "../../vendor/zod/index.js";
+import { Base64Url, EncKey, Hash, HostedPersonId, Key32, LIMITS, MachineId, MachineLabel, Millis, PROTOCOL } from "./common.js";
+import { Jws } from "./jelly.js";
+import { RealmId } from "./realm.js";
+/** A map proof (§15.5): a 256-bit bitmap of the non-empty siblings, and those siblings, bottom up. */
+export const MapProof = z.strictObject({
+    bitmap: Base64Url.length(43),
+    siblings: z.array(Hash).max(256),
+});
+/** What a live person's map leaf commits to (§15.5): their log head, and the hashes of their current keys statements. */
+export const MapValue = z.strictObject({
+    log: z.strictObject({ seq: z.number().int().nonnegative(), hash: Hash }),
+    keys: z.array(Hash).max(LIMITS.devicesPerPerson),
+});
+/** A device's id: its Ed25519 public key, as a machine's (§3). */
+export const DeviceId = MachineId.describe("Ed25519 public key of a device, base64url");
+/** What kind of device it is; informational. */
+export const DeviceKind = z.enum(["jelly-host", "laptop", "server", "other"]);
+/** Why a device was unbound (§15.3). */
+export const UnbindReason = z.enum(["self", "removed", "lost", "replaced", "account_deleted"]);
+/** An Ed25519 signature: 64 bytes, base64url. */
+const Signature = z.string().regex(/^[A-Za-z0-9_-]{86}$/, "64 bytes, base64url without padding");
+/**
+ * A new device's request to be approved by one of its person's devices (§15.3): shown as
+ * `messaging-link.<base64url(JCS(request))>`. `sig` is the new device's, over JCS(request without sig).
+ */
+export const LinkRequest = z.strictObject({
+    v: z.literal(PROTOCOL),
+    realm: RealmId,
+    device: DeviceId,
+    enc: EncKey,
+    label: MachineLabel,
+    kind: DeviceKind,
+    nonce: z.string().regex(/^[A-Za-z0-9_-]{22}$/, "16 bytes, base64url"),
+    ts: Millis,
+    sig: Signature,
+});
+/** Who vouches for a device-log entry (§15.3). */
+export const Authority = z.discriminatedUnion("kind", [
+    /** Jelly ID, by a resource token bound (`cnf`) to the signing device. */
+    z.strictObject({ kind: z.literal("jelly"), token: Jws }),
+    /** One of the person's Jelly-vouched devices, approving the link request of a new one; the entry's `by`. */
+    z.strictObject({ kind: z.literal("device"), approver: DeviceId, link: LinkRequest }),
+    /** The directory, by its epoch key: only the unbinds of an erased account. */
+    z.strictObject({ kind: z.literal("service") }),
+    /** The device itself: only its own unbind. */
+    z.strictObject({ kind: z.literal("self") }),
+]);
+/**
+ * One entry of a hosted person's device log (§15.3), hash-chained by `prev` and signed by `by` over
+ * JCS(entry without sig) with `DOMAIN.deviceLog`. `bind` names the device's `label` and `kind`; `attest` may
+ * change them; `unbind` gives a `reason` and nothing else.
+ */
+export const LogEntry = z
+    .strictObject({
+    v: z.literal(PROTOCOL),
+    realm: RealmId,
+    person: HostedPersonId,
+    seq: z.number().int().nonnegative(),
+    prev: Hash.nullable(),
+    ts: Millis,
+    op: z.enum(["bind", "attest", "unbind"]),
+    device: DeviceId,
+    label: MachineLabel.optional(),
+    kind: DeviceKind.optional(),
+    reason: UnbindReason.optional(),
+    authority: Authority,
+    by: Key32,
+    sig: Signature,
+})
+    .refine((entry) => (entry.seq === 0) === (entry.prev === null), { message: "prev is null exactly at seq 0", path: ["prev"] })
+    .refine((entry) => entry.op !== "bind" || (entry.label !== undefined && entry.kind !== undefined), { message: "a bind names label and kind", path: ["label"] })
+    .refine((entry) => (entry.op === "unbind") === (entry.reason !== undefined), { message: "an unbind, and only an unbind, gives a reason", path: ["reason"] })
+    .refine((entry) => entry.op !== "unbind" || (entry.label === undefined && entry.kind === undefined), { message: "an unbind names no label or kind", path: ["label"] });
+/**
+ * A device's self-signed encryption key (§15.4): the directory keeps the latest per device (`seq` strictly
+ * increases). `sig` is the device's, over JCS(statement without sig) with `DOMAIN.deviceKeys`.
+ */
+export const KeysStatement = z.strictObject({
+    v: z.literal(PROTOCOL),
+    realm: RealmId,
+    person: HostedPersonId,
+    device: DeviceId,
+    enc: EncKey,
+    seq: z.number().int().nonnegative(),
+    ts: Millis,
+    sig: Signature,
+});
+/**
+ * One leaf of the epoch log (§15.6): the map root of epoch `epoch` and of the epoch before it (`E[256]`, the
+ * empty map's root, before epoch 0). The leaf's data is UTF-8(JCS(leaf)).
+ */
+export const EpochLeaf = z.strictObject({
+    epoch: z.number().int().nonnegative(),
+    ts: Millis,
+    mapRoot: Hash,
+    prevMapRoot: Hash,
+});
+/** An epoch-log leaf and its RFC 9162 audit path in the tree of the STH it is sent with (§15.6). */
+export const EpochProof = z.strictObject({
+    index: z.number().int().nonnegative(),
+    leaf: EpochLeaf,
+    inclusion: z.array(Hash).max(64),
+});
+/**
+ * A signed tree head of the epoch log (§15.6): `size` leaves with root `root`, at `ts`. `sig` is the directory's
+ * epoch key's, over JCS(head without sig) with `DOMAIN.epoch`.
+ */
+export const STH = z.strictObject({
+    v: z.literal(PROTOCOL),
+    realm: RealmId,
+    size: z.number().int().positive(),
+    root: Hash,
+    ts: Millis,
+    sig: Signature,
+});
+/**
+ * The directory's epoch key moving from `old` to `new` (§15.6): STHs of `fromSize` leaves and more are signed by
+ * `new`. Each key signs JCS(rotation without its two signatures) with `DOMAIN.dirKey`.
+ */
+export const KeyRotation = z.strictObject({
+    v: z.literal(PROTOCOL),
+    realm: RealmId,
+    old: Key32,
+    new: Key32,
+    fromSize: z.number().int().positive(),
+    sigOld: Signature,
+    sigNew: Signature,
+});
+/**
+ * Evidence that log entry `seq` was in the directory by an epoch (§15.7): that epoch's leaf in the view's STH,
+ * and the person's map value there, which commits to a log head at or after `seq`.
+ */
+export const EntryEpoch = z.strictObject({
+    seq: z.number().int().nonnegative(),
+    epoch: EpochProof,
+    value: MapValue,
+    mapProof: MapProof,
+});
+/**
+ * One person's head as the directory serves it at an STH (§7, "Directory frames"; §15.7): the map proof of their value
+ * at the STH's last epoch, and that value's preimage (`value`: their log head and the hashes of their current devices'
+ * keys statements), or none for a person the map does not hold, or `tombstone: true` for an erased one. It holds no
+ * log entry, so no Jelly token and nothing of a profile: what a device about to bind needs, and what anyone may read.
+ */
+export const PersonHead = z.strictObject({
+    person: HostedPersonId,
+    mapProof: MapProof,
+    value: MapValue.optional(),
+    tombstone: z.literal(true).optional(),
+});
+/**
+ * One person as the directory serves them at an STH (§15.7): their log after the asker's `knownSeq` (all of it
+ * without one), the keys statements of their current devices, the map proof of their value at the STH's last
+ * epoch, and for every entry of `log` with a `jelly` authority, an `EntryEpoch` (its first epoch, from the
+ * directory's records). An erased person is `tombstone: true` with an empty log and no keys.
+ */
+export const PersonView = z.strictObject({
+    person: HostedPersonId,
+    log: z.array(LogEntry).max(1024),
+    keys: z.array(KeysStatement).max(LIMITS.devicesPerPerson),
+    mapProof: MapProof,
+    epochs: z.array(EntryEpoch).max(1024).optional(),
+    tombstone: z.literal(true).optional(),
+});

package/dist/lib/modules/core/schema/envelope.js

@@ -0,0 +1,211 @@
+/**
+ * The Messaging envelope: the end-to-end unit between machines. The sender signs it;
+ * every body except presence is sealed to the recipient machine's X25519 key.
+ * The relay can read the header (routing) but not the body.
+ */
+import { z } from "../../vendor/zod/index.js";
+import { Message, TaskArtifactUpdateEvent, TaskStatusUpdateEvent } from "./a2a.js";
+import { AgentKind, Base64Url, ChannelName, DeliveryTier, MachineId, MachineLabel, Millis, PersonId, PROTOCOL, SessionAddress, SessionName, SessionState, Ulid, LIMITS, } from "./common.js";
+import { CardData, CardGetData, GrantSync } from "./consent.js";
+import { DelegationChain } from "./delegation.js";
+import { ErrorCode } from "./errors.js";
+import { Anchor, RealmId } from "./realm.js";
+export const EnvelopeType = z.enum(["message", "task.status", "task.artifact", "task.cancel", "receipt", "presence"]);
+export const SEAL_ALG = "x25519-hkdf-sha256-a256gcm";
+/**
+ * What the envelope is to its recipient's person (spec §5, "Class"), in the header so the signature and the AAD
+ * cover it: `self` between two devices of one person (`from.person` = `to.person`), `contact` between two persons,
+ * and `request` for a message request (spec §6.9, "Message requests"): a person's first line to a person of another
+ * org, which a directory relay paces by this header alone. Every sealed envelope carries it; presence does not.
+ */
+export const EnvelopeClass = z.enum(["self", "contact", "request"]);
+/**
+ * One end of an envelope (spec §5, "Ends"): a person, one of their devices, and optionally an agent (a session) on
+ * that device. With no `agent`, the end is the person (or, for receipts and task control, the device acting for them).
+ */
+export const Party = z.object({
+    person: PersonId,
+    device: MachineId,
+    agent: SessionName.optional(),
+});
+/** Sender: the signing device, its person, and the agent that wrote the envelope, if an agent did. */
+export const Sender = Party;
+/** Recipient: one device of a person, and optionally an agent on it; presence alone goes to the whole team. */
+export const Recipient = z.union([
+    Party,
+    z.object({ team: z.literal(true) }), // presence broadcast
+]);
+/**
+ * Wire form. `sig` = Ed25519(from.device, DOMAIN.envelope + JCS(envelope without `sig`)).
+ * Sealed: enc = SEAL_ALG, epk + nonce present, body = base64url(ciphertext||tag),
+ *   AAD = UTF-8(JCS(header)), header = envelope without body and sig.
+ * Plain (presence only): enc = "none", body = payload object, no epk/nonce.
+ * `realm` is the sender's realm, and `anchor` its view of the realm when it sealed the envelope (spec §5,
+ * "Realm and anchor"): the signature covers both, and so does the AAD of a sealed envelope.
+ */
+export const Envelope = z.object({
+    v: z.literal(PROTOCOL),
+    id: Ulid,
+    realm: RealmId,
+    type: EnvelopeType,
+    from: Sender,
+    to: Recipient,
+    ts: Millis,
+    exp: Millis,
+    anchor: Anchor,
+    class: EnvelopeClass.optional(),
+    replyTo: Ulid.optional(),
+    enc: z.enum([SEAL_ALG, "none"]),
+    epk: Base64Url.optional(),
+    nonce: Base64Url.optional(),
+    body: z.unknown(),
+    sig: Base64Url,
+});
+// ---- Decrypted body payloads, by envelope type ----
+/** A channel's persons: roster person names, or hosted `p_…` ids in a directory realm (spec §6.8). */
+const ChannelPersons = z.array(PersonId).min(1).max(LIMITS.channelPersons);
+/**
+ * A channel change or post (spec §6.8), on a `kind: "message"` envelope sealed to a device with no recipient agent.
+ * `create`: the full channel record with the person who created it, to every member device and to each later
+ * invitee. `invite`: persons added, to the existing members. `leave`: the sender left. `remove`: persons removed by
+ * the creator or an admin, to every member device. `post`: a line in the channel. `name` is always the channel's own
+ * name. A DM line has no `conv` (spec §5, "Meaning").
+ */
+export const ChannelConv = z.discriminatedUnion("op", [
+    z.object({ kind: z.literal("channel"), op: z.literal("create"), id: Ulid, name: ChannelName, persons: ChannelPersons, creator: PersonId }),
+    z.object({ kind: z.literal("channel"), op: z.literal("invite"), id: Ulid, name: ChannelName, persons: ChannelPersons }),
+    z.object({ kind: z.literal("channel"), op: z.literal("leave"), id: Ulid, name: ChannelName }),
+    z.object({ kind: z.literal("channel"), op: z.literal("remove"), id: Ulid, name: ChannelName, persons: ChannelPersons }),
+    z.object({ kind: z.literal("channel"), op: z.literal("post"), id: Ulid, name: ChannelName }),
+]);
+/**
+ * Sync between two devices of one person (spec §6.9, "Sync"): `grant` carries grants the person set or re-signed,
+ * `snapshot` every current grant, for a device of the person that is new to the sender. The message carries exactly
+ * one data part, a `GrantSync`.
+ */
+export const SelfConv = z.object({ kind: z.literal("self"), what: z.enum(["grant", "snapshot"]) });
+/**
+ * A message request (spec §6.9, "Message requests"), on an envelope of class `request` from a person to a person:
+ * its message carries exactly one text part of at most `LIMITS.requestChars`.
+ */
+export const RequestConv = z.object({ kind: z.literal("request") });
+/**
+ * A contact card between two persons (spec §6.9, "Contact cards"): `card` carries one data part `{card}`, the signed
+ * card; `get` asks for the receiver's card and carries one data part `{get: true}`.
+ */
+export const CardConv = z.object({ kind: z.literal("card"), what: z.enum(["card", "get"]) });
+/** The conversation a `message` belongs to when its ends alone do not say (spec §5, "Meaning"). */
+export const Conv = z.discriminatedUnion("kind", [ChannelConv, SelfConv, RequestConv, CardConv]);
+/**
+ * type "message". `kind: "task"` asks the recipient to run `message` as a new A2A task;
+ * the sender assigns `message.taskId` (a ULID) and `message.contextId`.
+ * Replies to a task are task.status/task.artifact envelopes, not messages.
+ */
+export const MessagePayload = z
+    .object({
+    kind: z.enum(["message", "task"]),
+    message: Message,
+    /** Sender's hint that the recipient may wake an idle session. Recipient policy decides. */
+    wake: z.boolean().optional(),
+    /** Required on `kind: "task"`, absent otherwise: the signed chain from the root requester to this hop (spec §6.7). Receivers run `verifyChain`. */
+    delegation: DelegationChain.optional(),
+    /**
+     * The conversation, when the ends do not say it (spec §5, "Meaning"): a channel change or post (§6.8).
+     * `message.messageId` is a ULID shared by every copy; `message.contextId`, when set, is the ULID `messageId` of
+     * the thread's first line.
+     */
+    conv: Conv.optional(),
+})
+    .refine((p) => (p.kind === "task" ? p.message.taskId !== undefined : true), { message: "a task message needs message.taskId" })
+    .refine((p) => (p.kind === "task") === (p.delegation !== undefined), { message: "a task request carries a delegation chain, and only a task request" })
+    .refine((p) => p.conv?.kind !== "self" || (p.message.parts.length === 1 && GrantSync.safeParse(p.message.parts[0].data).success), {
+    message: "a self sync message carries exactly one data part with its grants",
+})
+    .refine((p) => p.conv?.kind !== "request" || requestMessage(p.message), {
+    message: `a message request carries one text part of 1 to ${LIMITS.requestChars} characters, and nothing else`,
+})
+    .refine((p) => p.conv?.kind !== "card" || cardMessage(p.message, p.conv.what), {
+    message: "a card message carries one data part, the card or the request for one, and nothing else",
+})
+    .refine((p) => p.message.taskId === undefined || Ulid.safeParse(p.message.taskId).success, {
+    message: "Messaging task ids are ULIDs",
+});
+/** The members a message request or card message may have: no metadata, extensions or other text beside its one part. */
+const BARE_MESSAGE = new Set(["messageId", "role", "parts"]);
+const bare = (message, part) => Object.keys(message).every((key) => BARE_MESSAGE.has(key)) && message.parts.length === 1 && Object.keys(message.parts[0]).join() === part;
+/** Spec §6.9, "Message requests": exactly one text part of 1 to `LIMITS.requestChars` UTF-16 code units, and nothing else. */
+function requestMessage(message) {
+    const text = message.parts[0]?.text;
+    return bare(message, "text") && typeof text === "string" && text.length >= 1 && text.length <= LIMITS.requestChars;
+}
+/** Spec §6.9, "Contact cards": exactly one data part, `{card}` or `{get: true}`, and nothing else. */
+function cardMessage(message, what) {
+    return bare(message, "data") && (what === "card" ? CardData : CardGetData).safeParse(message.parts[0].data).success;
+}
+/** type "task.status": executor → requester. */
+export const TaskStatusPayload = TaskStatusUpdateEvent;
+/** type "task.artifact": executor → requester. */
+export const TaskArtifactPayload = TaskArtifactUpdateEvent;
+/** type "task.cancel": requester → executor. The executor daemon moves the task to CANCELED if not terminal. */
+export const TaskCancelPayload = z.object({
+    taskId: Ulid,
+    reason: z.string().max(1000).optional(),
+});
+/** type "receipt": recipient → sender, signed proof of a delivery stage for envelope `ref`. */
+export const ReceiptPayload = z.object({
+    ref: Ulid,
+    stage: z.enum(["delivered", "held", "handed_to_agent", "read", "rejected"]),
+    code: ErrorCode.optional(),
+    note: z.string().max(500).optional(),
+});
+export const SessionInfo = z.object({
+    session: SessionName,
+    agent: AgentKind,
+    repo: z.string().max(200).optional(),
+    branch: z.string().max(200).optional(),
+    state: SessionState,
+    doing: z.string().max(200).optional(),
+    tier: DeliveryTier,
+    since: Millis,
+    /** No client holds the session: it is kept (spec §8.2) and its mail waits for it. */
+    kept: z.literal(true).optional(),
+    /** This machine would act on a sender's wake hint for the session now (spec §6.5, §8.3, §8.6). */
+    wake: z.literal(true).optional(),
+});
+/** type "presence": plain (not sealed), to {team:true}. Latest `seq` per machine wins. */
+export const PresencePayload = z.object({
+    seq: z.number().int().nonnegative(),
+    label: MachineLabel,
+    sessions: z.array(SessionInfo).max(LIMITS.presenceSessions),
+    /** Optional protocol features this machine supports, e.g. "tasks". Unknown features are ignored. */
+    features: z.array(z.string().max(64)).max(32).optional(),
+    /**
+     * Under a Jelly host: no window of this device's person is visible on it (`person.attached`, spec §6.5, §8.11). Its
+     * agents still run; the person is away from this device. Absent: the person may be at it.
+     */
+    away: z.literal(true).optional(),
+});
+export const PAYLOAD_BY_TYPE = {
+    message: MessagePayload,
+    "task.status": TaskStatusPayload,
+    "task.artifact": TaskArtifactPayload,
+    "task.cancel": TaskCancelPayload,
+    receipt: ReceiptPayload,
+    presence: PresencePayload,
+};
+/**
+ * Provenance the receiving daemon attaches at `Message.metadata[URI.provenance]` before
+ * handing a message to any client. Clients show it; peers can never set it (the daemon overwrites it).
+ */
+export const Provenance = z.object({
+    envelopeId: Ulid,
+    from: SessionAddress.describe("sender address person/agent@label"),
+    person: PersonId,
+    /** The sending agent; absent when the person wrote it. */
+    agent: SessionName.optional(),
+    /** The sending device. */
+    device: MachineId,
+    label: MachineLabel,
+    verified: z.literal("signature"),
+    receivedAt: Millis,
+});

package/dist/lib/modules/core/schema/errors.js

@@ -0,0 +1,104 @@
+import { z } from "../../vendor/zod/index.js";
+/** The closed set of Messaging error codes. Every emitted code must be documented in docs/spec/messaging-v1.md. */
+export const ErrorCode = z.enum([
+    "invalid_request", // malformed input or schema violation
+    "not_member", // sender or recipient machine is not a current team member
+    "bad_signature", // signature or seal failed verification
+    "unknown_session", // recipient session does not exist on the target machine
+    "ambiguous_address", // address matches more than one session
+    "no_recipients", // address resolved to nothing
+    "unknown_address", // an agent tool's address names no person, agent or channel this machine knows (client-side; never on the wire)
+    "refused", // recipient policy refuses this sender
+    "declined", // the recipient's person declined a held request (spec §6.9)
+    "request_required", // the recipient's person has not accepted this sender: a message request comes first (spec §6.9)
+    "rate_limited", // too many envelopes; retry later
+    "loop_guard", // agent-to-agent loop guard tripped
+    "too_large", // size limit exceeded
+    "secret_refused", // the sending daemon found a credential in outbound text; nothing was stored or sent
+    "expired", // envelope TTL passed, or ts outside the skew window
+    "duplicate", // envelope id already seen (receivers treat as success)
+    "relay_unavailable", // no relay connection
+    "not_found", // unknown id
+    "invalid_state", // illegal task transition or wrong role for the operation
+    "forbidden", // caller lacks authority (e.g. non-admin roster change)
+    "guarded_turn", // a guarded peer turn tried to send outside its allowance (client-side; never on the wire)
+    "roster_conflict", // roster entry does not extend the current head; resync and retry
+    "invite_invalid", // unknown, expired, revoked, used or mismatched invite
+    "no_identity", // daemon has no identity/team yet
+    "binding_invalid", // a device binding, log entry or its authority failed verification (hosted realms)
+    "jelly_unavailable", // Jelly ID's key set or key history could not be fetched; never reported as invalid
+    "log_conflict", // a device-log entry does not extend the log's head; resync and retry
+    "conv_conflict", // a conversation event does not extend the log, or its op head is not the current one; re-read and retry
+    "stale_epoch", // a conversation message is sealed under an epoch that is not the current one, or a rekey is due; re-seal and retry
+    "device_limit", // the person already has LIMITS.devicesPerPerson current devices
+    "admission_required", // dir.bind without a Jelly-vouched bind of the connecting device
+    "admission_invalid", // dir.bind whose Jelly token is not live, or not for this directory's issuer and resource
+    "directory_inconsistent", // the directory showed a split view, a fork or an inconsistent tree head; evidence kept, alarm raised
+    "unknown_device", // a directory realm: the sender's device is not a current device of its person
+    "directory_unavailable", // the key directory could not be reached to verify a person's devices within the freshness bound
+    "login_unsupported", // Jelly ID offers no device sign-in for this realm's resource (no v1.2 device sign-in in its metadata)
+    "login_denied", // the person denied the sign-in at Jelly ID, or the account is disabled or being deleted
+    "grant_required", // deployment "jelly": a human- or admin-tier call carried no action grant (spec §8.11)
+    "grant_invalid", // deployment "jelly": the action grant did not verify, is for another call, expired or was spent
+    "ticket_required", // deployment "jelly": session.register carried no session ticket
+    "ticket_invalid", // deployment "jelly": the session ticket did not verify, expired, or names another session or agent
+    "daemon_unavailable", // client could not reach the local daemon socket
+    "daemon_mismatch", // the daemon on the socket is another version or IPC protocol than the client (spec §8.2)
+    "store_refused", // messagingd refused the home's store and changed nothing; StoreRefusedError.reason says why: pre-reset or newer (spec §8.8)
+    "internal", // unexpected failure; details are logged locally, never sent
+]);
+/**
+ * The exit status of a messagingd or messaging-relay that refuses its store and changes nothing (spec §8.8): `EX_CONFIG`
+ * of sysexits(3), for either reason. messagingd also prints one stderr line,
+ * `messagingd: store_refused: <reason>: <why and how to start over>`. A client matches this status, the code and the
+ * reason, never the wording.
+ */
+export const STORE_REFUSED_EXIT = 78;
+/**
+ * Why a store is refused (spec §8.8):
+ * - `pre-reset`: it records no store generation, or another one. Starting over (moving the home aside) is the remedy.
+ * - `newer`: its `min_reader` is above this reader's schema: a newer messagingd wrote it. Upgrading is the remedy;
+ *   moving the home aside would set a newer home aside.
+ */
+export const StoreRefusedReason = z.enum(["pre-reset", "newer"]);
+export const ErrorBody = z.object({
+    code: ErrorCode,
+    message: z.string().max(500),
+});
+/** Error carrying a Messaging code. Messages must never contain bodies, keys or secrets. */
+export class MessagingError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = "MessagingError";
+        this.code = code;
+    }
+    toBody() {
+        return { code: this.code, message: this.message.slice(0, 500) };
+    }
+}
+/** `store_refused`, with its reason as a field: clients branch on `reason`, never on the message. */
+export class StoreRefusedError extends MessagingError {
+    reason;
+    constructor(reason, message, options) {
+        super("store_refused", message, options);
+        this.name = "StoreRefusedError";
+        this.reason = reason;
+    }
+}
+/** The stderr line of a messagingd that refuses its store: `messagingd: store_refused: <reason>: <text>`. */
+export function storeRefusedLine(reason, text) {
+    return `messagingd: store_refused: ${reason}: ${text}`;
+}
+/**
+ * The reason on a messagingd refusal line, or undefined for any other line. Reads the tokens only; the text after
+ * them may change between releases.
+ */
+export function storeRefusedReason(line) {
+    const match = /^messagingd: store_refused: ([a-z-]+): /.exec(line);
+    const parsed = StoreRefusedReason.safeParse(match?.[1]);
+    return parsed.success ? parsed.data : undefined;
+}
+export function isMessagingError(value) {
+    return value instanceof MessagingError;
+}

package/dist/lib/modules/core/schema/index.js

@@ -0,0 +1,16 @@
+export * from "./common.js";
+export * from "./errors.js";
+export * from "./realm.js";
+export * from "./jelly.js";
+export * from "./directory.js";
+export * as A2A from "./a2a.js";
+export * from "./envelope.js";
+export * from "./delegation.js";
+export * from "./consent.js";
+export * from "./roster.js";
+export * from "./relay.js";
+export * from "./directory-frames.js";
+export * from "./ipc.js";
+export * from "./ipc/device.js";
+export * from "./ipc/consent.js";
+export * from "./conversation.js";