@joe-broadhead/messaging 0.0.0-stage → 0.7.1

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

@@ -0,0 +1,310 @@
+import { z } from "../../vendor/zod/index.js";
+/** Protocol identifier carried in every envelope and roster entry. A breaking change gets a new value. */
+export const PROTOCOL = "messaging/1";
+/** Relay WebSocket sub-protocol identifier. */
+export const RELAY_PROTOCOL = "messaging-relay/1";
+/**
+ * Domain-separation prefixes. Every signature covers `prefix + JCS(value)` as UTF-8,
+ * so a signature made for one purpose can never verify for another.
+ */
+export const DOMAIN = {
+    envelope: "messaging/1/envelope\n",
+    roster: "messaging/1/roster\n",
+    relayAuth: "messaging/1/relay-auth\n",
+    /** An invite redeem proof, signed with the invite seed over JCS({team, inviteId, member}). */
+    invite: "messaging/1/invite\n",
+    /** A pre-auth `join` proof, signed with the invite seed over JCS({relay, team, inviteId, nonce}). */
+    inviteJoin: "messaging/1/invite-join\n",
+    /** A delegation grant, signed by the delegating machine over JCS(grant without sig). */
+    delegation: "messaging/1/delegation\n",
+    /** A consent grant (spec §6.9), signed by a device of its person over JCS(grant without sig). */
+    grant: "messaging/1/grant\n",
+    /** A contact card (spec §6.9, "Contact cards"), signed by a device of the person it speaks for over JCS(card without sig). */
+    card: "messaging/1/card\n",
+    /** HKDF `info` for sealing envelope bodies. */
+    seal: "messaging/1/seal",
+    /** Hosted realms (spec §15.1): the prefix of the hash that turns a Jelly account into a `PersonId`. */
+    person: "messaging/1/person\n",
+    /** Hosted realms (spec §15.5): an erased person's map value is the SHA-256 of this text. */
+    tombstone: "messaging/1/tombstone",
+    /**
+     * Hosted realms (spec §7, "Directory frames"): a device's proof, before `hello`, that it holds its key on this
+     * connection, signed over JCS(`dirReadPayload`), so it may read its own person's log.
+     */
+    dirRead: "messaging/1/dir-read\n",
+    /** Hosted realms (spec §15.3): a device-log entry, signed by `by` over JCS(entry without sig). */
+    deviceLog: "messaging/1/device-log\n",
+    /** Hosted realms (spec §15.4): a keys statement, signed by its device over JCS(statement without sig). */
+    deviceKeys: "messaging/1/device-keys\n",
+    /** Hosted realms (spec §15.3): a link request, signed by the new device over JCS(request without sig). */
+    deviceLink: "messaging/1/device-link\n",
+    /** Hosted realms (spec §15.6): a signed tree head, signed by the directory's epoch key over JCS(head without sig). */
+    epoch: "messaging/1/epoch\n",
+    /** Hosted realms (spec §15.6): an epoch-key rotation, signed by the old key and by the new over JCS(rotation without sigs). */
+    dirKey: "messaging/1/dir-key\n",
+    /** Conversations (spec §16.4): a conversation event, signed by `by.device` over JCS(event without sig). */
+    convEvent: "messaging/1/conv-event\n",
+    /** Conversations (spec §16.4): the prefix of a conversation log's genesis hash h(0), over JCS(cid). */
+    convGenesis: "messaging/1/conv-genesis\n",
+    /** Conversations (spec §16.1): the prefix of the hash that derives a dm's id, over JCS of its two sorted participants. */
+    dm: "messaging/1/dm\n",
+    /** Conversations (spec §16.1): the prefix of the hash that derives a person's `self` conversation id, over JCS(person). */
+    self: "messaging/1/self\n",
+    /** Conversations (spec §16.5): HKDF `info` for a sender chain's message key. */
+    convMsg: "messaging/1/conv-msg",
+    /** Conversations (spec §16.5): HKDF `info` for a sender chain's next chain key. */
+    convChain: "messaging/1/conv-chain",
+};
+/** A2A extension and binding URIs owned by Messaging. */
+export const URI = {
+    binding: "urn:messaging:binding:relay:v1",
+    provenance: "urn:messaging:ext:provenance:v1",
+    presence: "urn:messaging:ext:presence:v1",
+};
+export const Base64Url = z.string().regex(/^[A-Za-z0-9_-]*$/, "base64url without padding");
+/** Any 32-byte value in base64url, e.g. a raw public key. */
+export const Key32 = z.string().regex(/^[A-Za-z0-9_-]{43}$/, "32 bytes, base64url without padding");
+/** A machine's identity: its Ed25519 public key (32 bytes, base64url). */
+export const MachineId = Key32.describe("Ed25519 public key of a machine, base64url");
+/** A machine's X25519 public key used to seal envelope bodies addressed to it. */
+export const EncKey = Key32.describe("X25519 public key, base64url");
+/** SHA-256 digest, base64url. */
+export const Hash = Key32.describe("SHA-256 digest, base64url");
+/** A team id is the hash of its JCS-canonical genesis entry. */
+export const TeamId = Key32.describe("Team id: SHA-256 of the canonical genesis entry, base64url");
+/** Crockford base32 ULID, 26 chars. */
+export const Ulid = z.string().regex(/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/, "ULID");
+export const PersonName = z.string().regex(/^[a-z][a-z0-9-]{0,31}$/, "lowercase person name");
+/** A hosted realm's person (spec §15.1): `p_` and 26 lower-case base32 characters, derived from a Jelly account. */
+export const HostedPersonId = z.string().regex(/^p_[a-z2-7]{26}$/, "hosted person id");
+/** A person in either realm: a roster person name, or a hosted `p_…` id. The two forms cannot collide. */
+export const PersonId = z.union([PersonName, HostedPersonId]);
+/** A channel's name (spec §6.8). Unique among the channels one machine holds, not across the team. */
+export const ChannelName = z.string().regex(/^[a-z][a-z0-9-]{0,31}$/, "lowercase channel name");
+/** A chat room (spec §6.8): `dm:<person>` for a direct human message, `channel:<name>` for a channel. */
+export const RoomRef = z.string().regex(/^(?:dm:(?:[a-z][a-z0-9-]{0,31}|p_[a-z2-7]{26})|channel:[a-z][a-z0-9-]{0,31})$/, "dm:<person> or channel:<name>");
+export const SessionName = z.string().regex(/^[a-z0-9][a-z0-9._-]{0,63}$/, "lowercase session name");
+export const MachineLabel = z.string().regex(/^[a-z0-9][a-z0-9-]{0,31}$/, "lowercase machine label");
+export const TeamName = z.string().min(1).max(64);
+/** Client kind, e.g. "opencode", "claude-code", "cli". */
+export const AgentKind = z.string().regex(/^[a-z0-9][a-z0-9._-]{0,63}$/, "lowercase agent kind");
+/**
+ * The agent kind of the human `messaging` command line (spec §8.2, §8.3): never kept or expired on
+ * disconnect, refused as a task executor, and the only sender of group addresses.
+ */
+export const CLI_AGENT = "cli";
+/** Milliseconds since the Unix epoch. */
+export const Millis = z.number().int().nonnegative();
+/**
+ * Address grammar (parsed by `parseAddress`); `person` is a `PersonId` (a roster person name or a hosted `p_…`):
+ *   person/session            one session (must be unambiguous across the person's machines)
+ *   person/session@label      one session on a named machine
+ * There are no group addresses (spec §3).
+ */
+export const Address = z.string().min(1).max(200);
+/**
+ * A resolved, fully qualified single-session address: `person/session@label`, where `person` is a `PersonId` (a
+ * roster person name, or a hosted `p_…` id). Every daemon-produced address uses it.
+ */
+export const SessionAddress = z
+    .string()
+    .regex(/^(?:[a-z][a-z0-9-]{0,31}|p_[a-z2-7]{26})\/[a-z0-9][a-z0-9._-]{0,63}@[a-z0-9][a-z0-9-]{0,31}$/, "person/session@label");
+export const MemberRole = z.enum(["admin", "member"]);
+export const SessionState = z.enum(["idle", "busy"]);
+/** push: the client may wake an idle session for inbound mail. pull: the agent reads its inbox. */
+export const DeliveryTier = z.enum(["push", "pull"]);
+/** Sender-side view of one envelope's progress. Stages only move forward, except to rejected/expired. */
+export const DeliveryStage = z.enum([
+    "accepted", // stored in the local outbox
+    "relayed", // the relay stored or forwarded it
+    "delivered", // recipient daemon stored it (signed receipt)
+    "held", // recipient daemon holds it for its person to answer (signed receipt, spec §6.9)
+    "handed_to_agent", // recipient client put it in front of the agent (signed receipt)
+    "read", // recipient agent read the full body (signed receipt)
+    "replied", // a message with replyTo = this id arrived
+    "rejected", // refused by policy, unknown session, etc. (code says why)
+    "expired", // TTL passed before delivery
+]);
+export const LIMITS = {
+    /** Max bytes for one relay WebSocket frame. */
+    frameBytes: 1_048_576,
+    /** Max bytes for one IPC NDJSON line. */
+    ipcLineBytes: 2_097_152,
+    /** Max UTF-8 bytes of a decrypted envelope body (JCS). */
+    plaintextBytes: 262_144,
+    /** Max characters in a single text part. */
+    textPartChars: 65_536,
+    /** Max parts in one message. */
+    partsPerMessage: 16,
+    /** Default and max envelope TTL, and the max invite lifetime (`expires − ts`). */
+    ttlMs: 7 * 24 * 60 * 60 * 1000,
+    /** Max nesting of arrays and objects in any JSON value Messaging parses, signs or hashes; the outermost container is depth 1. */
+    jsonDepth: 32,
+    /** Accepted clock skew for `ts` in the future. */
+    clockSkewMs: 5 * 60 * 1000,
+    /** Inbound envelopes accepted per sending machine per minute (daemon policy). */
+    inboundPerMachinePerMinute: 60,
+    /** Agent-to-agent loop guard per (sender session, recipient session) pair. */
+    loopGuard: { max: 12, windowMs: 10 * 60 * 1000 },
+    /** Max sessions advertised in one presence payload. */
+    presenceSessions: 200,
+    /**
+     * Max UTF-8 bytes of a presence body (JCS). It bounds what each member adds to every welcome's replay
+     * and every fan-out, and still holds `presenceSessions` sessions once their optional fields are dropped.
+     */
+    presenceBytes: 65_536,
+    /** Max preview characters in an inbox item. */
+    previewChars: 200,
+    /** Max UTF-8 bytes of one relay frame before `hello`; a larger one closes the connection. */
+    preAuthFrameBytes: 32_768,
+    /** Max UTF-8 bytes of an envelope header: JCS of the envelope without `body` (relay nacks `too_large`). */
+    headerBytes: 4096,
+    /** Max unexpired envelopes the relay queues from one sender machine to one recipient machine (`rate_limited`). */
+    queuePerSender: 1000,
+    /** Relay budget per machine for every frame after `hello`: a token bucket of this many frames, refilled per minute. */
+    relayFramesPerMinute: 600,
+    /** Relay budget per machine for every frame after `hello`: a token bucket of this many UTF-8 bytes, refilled per minute. */
+    relayBytesPerMinute: 32 * 1_048_576,
+    /** Relay limit on presence frames per machine: a token bucket of `presenceBurst`, refilled one per `presenceIntervalMs`. */
+    presenceIntervalMs: 2000,
+    /** See `presenceIntervalMs`. */
+    presenceBurst: 3,
+    /** Max entries in one `join` or `roster.sync` reply page. */
+    rosterPageEntries: 256,
+    /** Max UTF-8 bytes of one roster entry (JCS). */
+    rosterEntryBytes: 16_384,
+    /** Max grants in a delegation chain (spec §6.7): R → X → Y → Z → W. */
+    delegationDepth: 4,
+    /** Max scope labels in one delegation grant. */
+    delegationScopes: 8,
+    /** Max UTF-8 bytes of a whole delegation chain (JCS). */
+    delegationBytes: 8192,
+    /** Max persons in a channel, its creator included (spec §6.8). */
+    channelPersons: 32,
+    /** Max UTF-16 code units of one chat line's text (spec §6.8). */
+    chatChars: 8000,
+    /** Max follow-ups a requester's task record lists (spec §6.3, the newest). */
+    taskFollowUps: 20,
+    /** Max current devices of one hosted person (spec §15.3); also bounds `dir.erase` (§7, "Directory frames"). */
+    devicesPerPerson: 10,
+    /** A directory makes a new epoch at most this often while changes wait (spec §15.10). */
+    epochMinMs: 5000,
+    /** ...and one at least this often without changes, so a fresh STH always exists. */
+    epochHeartbeatMs: 10 * 60 * 1000,
+    /** How often a directory reads Jelly ID's account-deletion feed (spec §15.10). */
+    deletionPollMs: 6 * 60 * 60 * 1000,
+    /** After a gap in that feed of over 90 days, the directory erases persons idle for this many days, once. */
+    dormantDays: 180,
+    /** Distinct persons one person may send message requests to per day, at a directory relay. */
+    requestsPerDay: 20,
+    /** Max UTF-16 code units of a message request's text (spec §6.9, "Message requests"): the whole of what a stranger may say first. */
+    requestChars: 500,
+    /** Envelopes per day from one person to another who never sent to them (an unsolicited pair). */
+    unsolicitedPerPairPerDay: 20,
+    /** Distinct persons one person may send to unsolicited per day. */
+    unsolicitedTargetsPerDay: 50,
+    /** Max persons in one `dir.lookup`. */
+    dirLookupPersons: 64,
+    /** Max persons one `dir.resolve` or `dir.search` answers. */
+    dirSearchResults: 25,
+    /** Max persons one device watches with `dir.watch`, and with `presence.watch`. */
+    watchPersons: 500,
+    /** Max age of a link request when its device is approved, and of an approval after it (spec §15.3). */
+    linkTtlMs: 10 * 60 * 1000,
+    /**
+     * A directory realm's freshness bounds (spec §15.9): a person's devices are sealed to only when verified at an STH
+     * fetched at most `dirFreshFirstMs` ago for a first message or right after a change push, and at most `dirFreshMs`
+     * ago otherwise.
+     */
+    dirFreshFirstMs: 10 * 60 * 1000,
+    dirFreshMs: 24 * 60 * 60 * 1000,
+    /** How often, at least, a device verifies its own person's log and keys at the directory (spec §15.9). */
+    selfMonitorMs: 60 * 60 * 1000,
+    /** A Jelly-vouched device attests again at its first chance after this long (spec §15.9). */
+    attestAfterMs: 30 * 24 * 60 * 60 * 1000,
+    /** Max UTF-8 bytes of one device-log entry (JCS), a Jelly token included (spec §15.3). */
+    logEntryBytes: 16_384,
+    /** Max UTF-8 bytes of one keys statement (JCS) (spec §15.4). */
+    keysStatementBytes: 1024,
+    /** Trust a grant gives when the person names no end (spec §6.9). */
+    trustDefaultMs: 30 * 24 * 60 * 60 * 1000,
+    /** Max `trustedUntil − ts` of a grant (spec §6.9). */
+    trustMaxMs: 90 * 24 * 60 * 60 * 1000,
+    /** Max UTF-8 bytes of one grant (JCS). */
+    grantBytes: 2048,
+    /** Max UTF-8 bytes of one contact card (JCS) (spec §6.9, "Contact cards"). */
+    cardBytes: 2048,
+    /** Max grants one person's device holds (spec §6.9): one per subject. */
+    grantsPerPerson: 5000,
+    /** Max requests a device holds from one sending person for its person to answer (spec §6.9). */
+    heldPerSender: 20,
+    /** Max requests a device holds in all (spec §6.9). */
+    heldTotal: 200,
+    /** Max lines one person's agents send to another person in an hour, summed over the agents (spec §6.9, "Pacing"). */
+    a2hPerHour: 30,
+    /** Max lines one person's agents send to another person in a day, summed over the agents (spec §6.9, "Pacing"). */
+    a2hPerDay: 100,
+    /** Conversations (spec §16): max participants (persons and agents) of a channel. */
+    convParticipants: 1000,
+    /** Max participants (persons and agents) of a group. A group has at least 3. */
+    groupParticipants: 50,
+    /** Max participants one `add` or `remove` op names. */
+    convOpParticipants: 100,
+    /** Max UTF-8 bytes of one conversation event (JCS), signature and body included. */
+    convEventBytes: 262_144,
+    /** Max UTF-8 bytes of one message body's plaintext (JCS) before it is sealed. */
+    convPlaintextBytes: 65_536,
+    /** Max UTF-16 code units of one conversation line's text. */
+    lineChars: 40_000,
+    /** Max mentions in one line or edit. */
+    mentions: 50,
+    /** Max attachments in one line. */
+    files: 10,
+    /** Max delegation grants one line carries for the agents it mentions (spec §16.3). */
+    agentMentions: 5,
+    /** Max bytes of one attached file, encrypted. */
+    blobBytes: 26_214_400,
+    /** Max distinct reaction keys on one event. */
+    reactionsPerEvent: 50,
+    /** Max pinned events in one conversation. */
+    pins: 100,
+    /** Retention of a conversation that sets none, in days. */
+    retainDaysDefault: 90,
+    /** Max `retainDays` of a conversation, and max lookback of a context rule. */
+    retainDaysMax: 365,
+    /** Max message keys a receiver keeps for one sender chain to open messages that arrive out of order. */
+    skippedKeys: 1000,
+    /** A sender starts a new chain after this many messages on one chain... */
+    chainMessages: 500,
+    /** ...or this long after it started the chain, whichever comes first. */
+    chainMaxMs: 7 * 24 * 60 * 60 * 1000,
+    /** An epoch older than this may be ended by a `rekey` with cause `schedule`. */
+    rekeyScheduleMs: 30 * 24 * 60 * 60 * 1000,
+    /** Max chain keys in one sealed key share, and in one `keys` sync of the `self` conversation. */
+    keyShares: 512,
+    /** Max recipient devices one `keys` event seals to; a larger share is split over several events. */
+    keySharesPerEvent: 500,
+    /** Max agents one event's `wake` hint names. */
+    wakeHints: 5,
+    /** Max context rules a person holds (spec §16.8). */
+    contextRules: 500,
+};
+const LOOPBACK_HOST = /^(?:localhost|127(?:\.\d{1,3}){3}|\[::1\])$/;
+/**
+ * True for a relay URL a client may connect to: `wss://`, or `ws://` to a loopback host (`localhost`,
+ * 127.0.0.0/8 or `[::1]`, after WHATWG URL parsing). Anything else, including text that is not a URL, is false.
+ */
+export function isAllowedRelayUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    if (parsed.protocol === "wss:")
+        return true;
+    return parsed.protocol === "ws:" && LOOPBACK_HOST.test(parsed.hostname);
+}
+/** A relay connect URL that passes `isAllowedRelayUrl`. */
+export const RelayUrl = z.string().url().refine(isAllowedRelayUrl, { message: "relay must be wss://, or ws:// to a loopback host" });

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

@@ -0,0 +1,120 @@
+/**
+ * Consent (spec §6.9): a person's grants, the policy they hold for one sender person or one channel. One of the
+ * person's devices signs each grant; only the person's own devices hold it, and their daemons enforce it on
+ * receipt. Agents never sign or change a grant: every method that does is human tier (§8.2).
+ */
+import { z } from "../../vendor/zod/index.js";
+import { Base64Url, LIMITS, MachineId, Millis, PersonId, PROTOCOL, Ulid } from "./common.js";
+import { RealmId } from "./realm.js";
+/** H2H lines from the subject: `muted` delivers with no notification and no unread mark; `blocked` refuses every class from them. */
+export const ChatLevel = z.enum(["open", "muted", "blocked"]);
+/** Lines from the subject's agents to the person (A2H). */
+export const AgentMailLevel = z.enum(["open", "blocked"]);
+/** Mail and tasks from the subject or their agents to the person's agents: `request` holds each one for the person to answer. */
+export const AskLevel = z.enum(["open", "request", "no"]);
+/** Whom a grant is about: one person, or every member of one channel (by its id). */
+export const GrantSubject = z.union([z.strictObject({ person: PersonId }), z.strictObject({ channel: Ulid })]);
+/**
+ * A grant, signed by `by`, a device of `person`: `sig = Ed25519(by, "messaging/1/grant\n" || JCS(grant without sig))`.
+ * Every level is optional: an absent level is the default for the relation (spec §6.9, "Effective policy"), and a
+ * grant with none is a clear. `trustedUntil` needs `ask: "open"` and is at most `ts + LIMITS.trustMaxMs`. A channel
+ * grant sets only `ask` and `agentMail`. A grant about the person themself sets only `discoverable`.
+ * `resignedAt` marks a grant re-signed by another device of the person (spec §6.9, "Signers"); it keeps `id` and
+ * `ts`.
+ */
+export const ConsentGrant = z
+    .object({
+    v: z.literal(PROTOCOL),
+    realm: RealmId,
+    id: Ulid,
+    person: PersonId,
+    by: MachineId,
+    ts: Millis,
+    subject: GrantSubject,
+    chat: ChatLevel.optional(),
+    agentMail: AgentMailLevel.optional(),
+    ask: AskLevel.optional(),
+    trustedUntil: Millis.optional(),
+    discoverable: z.boolean().optional(),
+    resignedAt: Millis.optional(),
+    sig: Base64Url,
+})
+    .superRefine((grant, ctx) => {
+    const problem = grantProblem(grant);
+    if (problem)
+        ctx.addIssue({ code: "custom", message: problem });
+});
+/** Most grants one `self` sync envelope carries (spec §6.9, "Sync"): a snapshot goes in as many envelopes as it needs. */
+export const GRANTS_PER_SYNC = 100;
+/**
+ * The one data part of a `self` sync envelope (spec §6.9, "Sync"): grants as signed, kept raw so that members a
+ * newer device adds stay covered by their signatures. The receiver verifies each one.
+ */
+export const GrantSync = z.strictObject({ grants: z.array(z.record(z.string(), z.unknown())).min(1).max(GRANTS_PER_SYNC) });
+/** The rules of a grant that its schema alone cannot say. */
+export function grantProblem(grant) {
+    const own = "person" in grant.subject && grant.subject.person === grant.person;
+    if ("channel" in grant.subject && (grant.chat !== undefined || grant.trustedUntil !== undefined || grant.discoverable !== undefined)) {
+        return "a channel grant sets only ask and agentMail";
+    }
+    if (own && (grant.chat !== undefined || grant.agentMail !== undefined || grant.ask !== undefined || grant.trustedUntil !== undefined)) {
+        return "a grant about its own person sets only discoverable";
+    }
+    if (!own && grant.discoverable !== undefined)
+        return "discoverable is set only on a grant about its own person";
+    if (grant.trustedUntil !== undefined) {
+        if (grant.ask !== "open")
+            return "trustedUntil needs ask open";
+        if (grant.trustedUntil > grant.ts + LIMITS.trustMaxMs)
+            return "trustedUntil is past ts + LIMITS.trustMaxMs";
+    }
+    if (grant.resignedAt !== undefined && grant.resignedAt < grant.ts)
+        return "resignedAt is before ts";
+    return undefined;
+}
+/**
+ * What a person's card tells another person they may send (spec §6.9, "Contact cards"): DM lines (`chat`), lines from
+ * their agents (`agentMail`), and asks to the person's agents (`ask`, with `trustedUntil` while they are trusted).
+ */
+export const CardCan = z.strictObject({
+    chat: z.boolean(),
+    agentMail: z.boolean(),
+    ask: AskLevel,
+    trustedUntil: Millis.optional(),
+});
+/**
+ * A contact card: `from`'s word to `to` about what `to` may send them, signed by `by`, a device of `from`:
+ * `sig = Ed25519(by, "messaging/1/card\n" || JCS(card without sig))`. `seq` rises with every card `from` sends `to`;
+ * the receiver keeps the highest. `grantId` names the grant it reflects. A card is advice: `from`'s own daemon
+ * enforces the grants, which may be newer.
+ */
+export const ContactCard = z
+    .object({
+    v: z.literal(PROTOCOL),
+    realm: RealmId,
+    from: PersonId,
+    to: PersonId,
+    by: MachineId,
+    seq: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+    ts: Millis,
+    grantId: Ulid.optional(),
+    can: CardCan,
+    sig: Base64Url,
+})
+    .superRefine((card, ctx) => {
+    const problem = cardProblem(card);
+    if (problem)
+        ctx.addIssue({ code: "custom", message: problem });
+});
+/** The rules of a card that its schema alone cannot say. */
+export function cardProblem(card) {
+    if (card.from === card.to)
+        return "a card is about another person";
+    if (card.can.trustedUntil !== undefined && card.can.ask !== "open")
+        return "trustedUntil needs ask open";
+    return undefined;
+}
+/** The one data part of a `card` message (spec §5, "Meaning"): the card as signed, kept raw; the receiver verifies it. */
+export const CardData = z.strictObject({ card: z.record(z.string(), z.unknown()) });
+/** The one data part of a card request (`what: "get"`). */
+export const CardGetData = z.strictObject({ get: z.literal(true) });