@youam/sdk 0.2.1 → 0.4.0

package/dist/index.js

@@ -39,11 +39,11 @@ function extractPublicKey(tags) {
   }
   return null;
 }
-async function queryUamTxt(domain, timeout) {
+async function queryUamTxt(domain2, timeout) {
   const controller = new AbortController();
   const timer = timeout != null ? setTimeout(() => controller.abort(), timeout) : void 0;
   try {
-    const records = await dnsResolveTxt(`_uam.${domain}`);
+    const records = await dnsResolveTxt(`_uam.${domain2}`);
     const results = [];
     for (const parts of records) {
       const txtValue = parts.join("");
@@ -58,8 +58,8 @@ async function queryUamTxt(domain, timeout) {
     if (timer != null) clearTimeout(timer);
   }
 }
-async function resolveKeyViaHttps(agentName, domain, timeout) {
-  const url = `https://${domain}/.well-known/uam.json`;
+async function resolveKeyViaHttps(agentName, domain2, timeout) {
+  const url = `https://${domain2}/.well-known/uam.json`;
   try {
     const resp = await fetch(url, {
       signal: AbortSignal.timeout(timeout ?? 1e4)
@@ -99,32 +99,43 @@ __export(protocol_exports, {
   EnvelopeTooLargeError: () => EnvelopeTooLargeError,
   InvalidAddressError: () => InvalidAddressError,
   InvalidContactCardError: () => InvalidContactCardError,
+  InvalidDidKeyError: () => InvalidDidKeyError,
   InvalidEnvelopeError: () => InvalidEnvelopeError,
   KeyPinningError: () => KeyPinningError,
   MAX_ENVELOPE_AGE: () => MAX_ENVELOPE_AGE,
   MAX_ENVELOPE_SIZE: () => MAX_ENVELOPE_SIZE,
   MessageType: () => MessageType,
+  SendRefusedError: () => SendRefusedError,
   SignatureError: () => SignatureError,
   SignatureVerificationError: () => SignatureVerificationError,
+  SignedObjectError: () => SignedObjectError,
   UAMError: () => UAMError,
   UAM_VERSION: () => UAM_VERSION,
+  WebAuthnError: () => WebAuthnError,
+  approvalChallenge: () => approvalChallenge,
   b64Decode: () => b64Decode,
   b64Encode: () => b64Encode,
+  canonical: () => canonical,
   canonicalize: () => canonicalize,
   contactCardFromDict: () => contactCardFromDict,
   contactCardToDict: () => contactCardToDict,
   createContactCard: () => createContactCard,
   createEnvelope: () => createEnvelope,
+  credentialDid: () => credentialDid,
+  decodeDidKey: () => decodeDidKey,
   decryptPayload: () => decryptPayload,
   decryptPayloadAnonymous: () => decryptPayloadAnonymous,
   deserializeSigningKey: () => deserializeSigningKey,
   deserializeVerifyKey: () => deserializeVerifyKey,
+  encodeDidKey: () => encodeDidKey,
   encryptPayload: () => encryptPayload,
   encryptPayloadAnonymous: () => encryptPayloadAnonymous,
   fromWireDict: () => fromWireDict,
   generateKeypair: () => generateKeypair,
   generateNonce: () => generateNonce,
+  objectHash: () => objectHash,
   parseAddress: () => parseAddress,
+  parseBody: () => parseBody,
   publicKeyFingerprint: () => publicKeyFingerprint,
   serializeSigningKey: () => serializeSigningKey,
   serializeVerifyKey: () => serializeVerifyKey,
@@ -133,8 +144,11 @@ __export(protocol_exports, {
   toWireDict: () => toWireDict,
   utcTimestamp: () => utcTimestamp,
   validateEnvelopeSize: () => validateEnvelopeSize,
+  validateSignedObject: () => validate,
+  verifyAssertion: () => verifyAssertion,
   verifyContactCard: () => verifyContactCard,
   verifyEnvelope: () => verifyEnvelope,
+  verifyRegistration: () => verifyRegistration,
   verifySignature: () => verifySignature
 });
 
@@ -229,6 +243,18 @@ var KeyPinningError = class _KeyPinningError extends UAMError {
     Object.setPrototypeOf(this, _KeyPinningError.prototype);
   }
 };
+var SendRefusedError = class extends UAMError {
+  messageId;
+  code;
+  detail;
+  constructor(messageId, code, detail) {
+    super(`Relay refused message ${messageId}: [${code}] ${detail ?? ""}`.trimEnd());
+    this.name = "SendRefusedError";
+    this.messageId = messageId;
+    this.code = code;
+    this.detail = detail;
+  }
+};
 
 // src/protocol/address.ts
 var ADDRESS_RE = /^(?<agent>[a-z0-9][a-z0-9_-]{0,62}[a-z0-9]|[a-z0-9])::(?<domain>[a-z0-9](?:[a-z0-9.-]{0,253}[a-z0-9])?)$/;
@@ -355,11 +381,11 @@ function encryptPayload(plaintext, senderSigningKey, recipientVerifyKey) {
   try {
     const senderCurve = sodium.crypto_sign_ed25519_sk_to_curve25519(senderSigningKey);
     const recipientCurve = sodium.crypto_sign_ed25519_pk_to_curve25519(recipientVerifyKey);
-    const nonce = sodium.randombytes_buf(sodium.crypto_box_NONCEBYTES);
-    const encrypted = sodium.crypto_box_easy(plaintext, nonce, recipientCurve, senderCurve);
-    const combined = new Uint8Array(nonce.length + encrypted.length);
-    combined.set(nonce, 0);
-    combined.set(encrypted, nonce.length);
+    const nonce2 = sodium.randombytes_buf(sodium.crypto_box_NONCEBYTES);
+    const encrypted = sodium.crypto_box_easy(plaintext, nonce2, recipientCurve, senderCurve);
+    const combined = new Uint8Array(nonce2.length + encrypted.length);
+    combined.set(nonce2, 0);
+    combined.set(encrypted, nonce2.length);
     return b64Encode(combined);
   } catch (err) {
     if (err instanceof EncryptionError) throw err;
@@ -369,11 +395,11 @@ function encryptPayload(plaintext, senderSigningKey, recipientVerifyKey) {
 function decryptPayload(ciphertextB64, recipientSigningKey, senderVerifyKey) {
   try {
     const combined = b64Decode(ciphertextB64);
-    const nonce = combined.slice(0, sodium.crypto_box_NONCEBYTES);
+    const nonce2 = combined.slice(0, sodium.crypto_box_NONCEBYTES);
     const ciphertext = combined.slice(sodium.crypto_box_NONCEBYTES);
     const recipientCurve = sodium.crypto_sign_ed25519_sk_to_curve25519(recipientSigningKey);
     const senderCurve = sodium.crypto_sign_ed25519_pk_to_curve25519(senderVerifyKey);
-    return sodium.crypto_box_open_easy(ciphertext, nonce, senderCurve, recipientCurve);
+    return sodium.crypto_box_open_easy(ciphertext, nonce2, senderCurve, recipientCurve);
   } catch (err) {
     if (err instanceof DecryptionError) throw err;
     throw new DecryptionError(err instanceof Error ? err.message : String(err));
@@ -481,7 +507,7 @@ async function createEnvelope(fromAddress, toAddress, messageType, payloadPlaint
   parseAddress(fromAddress);
   parseAddress(toAddress);
   const messageId = randomUUID();
-  const nonce = generateNonce();
+  const nonce2 = generateNonce();
   const timestamp = utcTimestamp();
   let encryptedPayload;
   if (typeValue === "handshake.request" /* HANDSHAKE_REQUEST */) {
@@ -500,7 +526,7 @@ async function createEnvelope(fromAddress, toAddress, messageType, payloadPlaint
     toAddress,
     timestamp,
     type: typeValue,
-    nonce,
+    nonce: nonce2,
     payload: encryptedPayload,
     signature: "",
     threadId: options?.threadId,
@@ -519,7 +545,7 @@ async function createEnvelope(fromAddress, toAddress, messageType, payloadPlaint
     toAddress,
     timestamp,
     type: typeValue,
-    nonce,
+    nonce: nonce2,
     payload: encryptedPayload,
     signature,
     threadId: options?.threadId,
@@ -611,8 +637,8 @@ function contactCardFromDict(d, options) {
   }
   return card;
 }
-async function createContactCard(address, displayName, relay, signingKey, options) {
-  parseAddress(address);
+async function createContactCard(address2, displayName, relay, signingKey, options) {
+  parseAddress(address2);
   const verifyKey = signingKey.slice(32);
   const pubKeyB64 = serializeVerifyKey(verifyKey);
   const fp = publicKeyFingerprint(verifyKey);
@@ -622,7 +648,7 @@ async function createContactCard(address, displayName, relay, signingKey, option
   ];
   const tempCard = {
     version: UAM_VERSION,
-    address,
+    address: address2,
     displayName,
     description: options?.description,
     system: options?.system,
@@ -639,7 +665,7 @@ async function createContactCard(address, displayName, relay, signingKey, option
   const signature = signMessage(canonicalize(signable), signingKey);
   return Object.freeze({
     version: UAM_VERSION,
-    address,
+    address: address2,
     displayName,
     description: options?.description,
     system: options?.system,
@@ -666,8 +692,778 @@ function verifyContactCard(card) {
   verifySignature(canonicalize(signable), card.signature, vk);
 }
 
+// src/protocol/signed.ts
+import { createHash as createHash2 } from "crypto";
+
+// src/protocol/didkey.ts
+var B58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var PREFIX = {
+  ed25519: new Uint8Array([237, 1]),
+  p256: new Uint8Array([128, 36])
+};
+var LENGTH = { ed25519: 32, p256: 33 };
+var InvalidDidKeyError = class extends UAMError {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidDidKeyError";
+  }
+};
+function b58encode(data) {
+  let n = 0n;
+  for (const byte of data) n = n << 8n | BigInt(byte);
+  let out = "";
+  while (n > 0n) {
+    out = B58[Number(n % 58n)] + out;
+    n /= 58n;
+  }
+  let zeros = 0;
+  while (zeros < data.length && data[zeros] === 0) zeros += 1;
+  return "1".repeat(zeros) + out;
+}
+function b58decode(text) {
+  let n = 0n;
+  for (const c of text) {
+    const i = B58.indexOf(c);
+    if (i < 0) throw new InvalidDidKeyError(`not base58btc: ${JSON.stringify(c)}`);
+    n = n * 58n + BigInt(i);
+  }
+  const body = [];
+  while (n > 0n) {
+    body.unshift(Number(n & 0xffn));
+    n >>= 8n;
+  }
+  let zeros = 0;
+  while (zeros < text.length && text[zeros] === "1") zeros += 1;
+  return new Uint8Array([...new Array(zeros).fill(0), ...body]);
+}
+function checkKey(kind, key) {
+  if (key.length !== LENGTH[kind]) {
+    throw new InvalidDidKeyError(`${kind} key must be ${LENGTH[kind]} bytes`);
+  }
+  if (kind === "p256" && key[0] !== 2 && key[0] !== 3) {
+    throw new InvalidDidKeyError("P-256 key must be a compressed point");
+  }
+}
+function encodeDidKey(kind, publicKey) {
+  if (!(kind in PREFIX)) throw new InvalidDidKeyError(`unsupported key type: ${kind}`);
+  checkKey(kind, publicKey);
+  return "did:key:z" + b58encode(new Uint8Array([...PREFIX[kind], ...publicKey]));
+}
+function decodeDidKey(did2) {
+  if (typeof did2 !== "string" || !did2.startsWith("did:key:z")) {
+    throw new InvalidDidKeyError("not a did:key with base58btc multibase");
+  }
+  const raw = b58decode(did2.slice("did:key:z".length));
+  for (const kind of Object.keys(PREFIX)) {
+    const prefix = PREFIX[kind];
+    if (raw.length >= prefix.length && prefix.every((b, i) => raw[i] === b)) {
+      const key = raw.slice(prefix.length);
+      checkKey(kind, key);
+      return { kind, key };
+    }
+  }
+  throw new InvalidDidKeyError("unsupported key type");
+}
+
+// src/protocol/signed.ts
+var MAX_INT = 2 ** 53 - 1;
+var GRANT_MAX_DAYS = 90;
+var INVITE_MAX_DAYS = 7;
+var SignedObjectError = class extends UAMError {
+  constructor(message) {
+    super(message);
+    this.name = "SignedObjectError";
+  }
+};
+var has = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+var Parser = class {
+  constructor(s) {
+    this.s = s;
+  }
+  i = 0;
+  fail(why) {
+    throw new SignedObjectError(`not JSON or outside the profile at ${this.i}: ${why}`);
+  }
+  ws() {
+    while (this.i < this.s.length && " 	\n\r".includes(this.s[this.i])) this.i += 1;
+  }
+  document() {
+    this.ws();
+    if (this.s[this.i] !== "{") this.fail("a body must be a JSON object");
+    const value = this.value();
+    this.ws();
+    if (this.i !== this.s.length) this.fail("trailing characters");
+    return value;
+  }
+  value() {
+    this.ws();
+    const c = this.s[this.i];
+    if (c === "{") return this.object();
+    if (c === "[") return this.array();
+    if (c === '"') return this.string();
+    if (c === "-" || c !== void 0 && c >= "0" && c <= "9") return this.number();
+    for (const [word, v] of [["true", true], ["false", false]]) {
+      if (this.s.startsWith(word, this.i)) {
+        this.i += word.length;
+        return v;
+      }
+    }
+    if (this.s.startsWith("null", this.i)) this.fail("null is not allowed");
+    return this.fail("unexpected character");
+  }
+  object() {
+    this.i += 1;
+    const out = /* @__PURE__ */ Object.create(null);
+    this.ws();
+    if (this.s[this.i] === "}") {
+      this.i += 1;
+      return out;
+    }
+    for (; ; ) {
+      this.ws();
+      if (this.s[this.i] !== '"') this.fail("expected a key");
+      const key = this.string();
+      if (has(out, key)) this.fail(`duplicate key: ${JSON.stringify(key)}`);
+      this.ws();
+      if (this.s[this.i] !== ":") this.fail("expected ':'");
+      this.i += 1;
+      Object.defineProperty(out, key, {
+        value: this.value(),
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+      this.ws();
+      if (this.s[this.i] === ",") {
+        this.i += 1;
+        continue;
+      }
+      if (this.s[this.i] === "}") {
+        this.i += 1;
+        return out;
+      }
+      this.fail("expected ',' or '}'");
+    }
+  }
+  array() {
+    this.i += 1;
+    const out = [];
+    this.ws();
+    if (this.s[this.i] === "]") {
+      this.i += 1;
+      return out;
+    }
+    for (; ; ) {
+      out.push(this.value());
+      this.ws();
+      if (this.s[this.i] === ",") {
+        this.i += 1;
+        continue;
+      }
+      if (this.s[this.i] === "]") {
+        this.i += 1;
+        return out;
+      }
+      this.fail("expected ',' or ']'");
+    }
+  }
+  string() {
+    this.i += 1;
+    let out = "";
+    for (; ; ) {
+      const c = this.s[this.i];
+      if (c === void 0) this.fail("unterminated string");
+      this.i += 1;
+      if (c === '"') break;
+      if (c === "\\") {
+        const e = this.s[this.i];
+        this.i += 1;
+        const simple = {
+          '"': '"',
+          "\\": "\\",
+          "/": "/",
+          b: "\b",
+          f: "\f",
+          n: "\n",
+          r: "\r",
+          t: "	"
+        };
+        if (e !== void 0 && has(simple, e)) {
+          out += simple[e];
+        } else if (e === "u") {
+          const hex = this.s.slice(this.i, this.i + 4);
+          if (!/^[0-9a-fA-F]{4}$/.test(hex)) this.fail("bad \\u escape");
+          out += String.fromCharCode(parseInt(hex, 16));
+          this.i += 4;
+        } else {
+          this.fail("bad escape");
+        }
+      } else {
+        if (c < " ") this.fail("control character in string");
+        out += c;
+      }
+    }
+    checkString(out);
+    return out;
+  }
+  number() {
+    const m = /^-?(0|[1-9][0-9]*)([.][0-9]+)?([eE][+-]?[0-9]+)?/.exec(this.s.slice(this.i));
+    if (!m) return this.fail("bad number");
+    const text = m[0];
+    if (m[2] !== void 0 || m[3] !== void 0) this.fail(`floats are not allowed: ${text}`);
+    if (text === "-0") this.fail("-0 is not allowed");
+    const big = BigInt(text);
+    if (big > BigInt(MAX_INT) || big < -BigInt(MAX_INT)) this.fail(`integer out of range: ${text}`);
+    this.i += text.length;
+    return Number(big);
+  }
+};
+function parseBody(text) {
+  let s;
+  if (typeof text === "string") {
+    s = text;
+  } else {
+    try {
+      s = new TextDecoder("utf-8", { fatal: true }).decode(text);
+    } catch {
+      throw new SignedObjectError("body is not UTF-8");
+    }
+  }
+  return new Parser(s).document();
+}
+function checkString(value) {
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code < 32 || code > 126) {
+      throw new SignedObjectError("strings must be printable ASCII");
+    }
+  }
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+function encode(value) {
+  if (value === true) return "true";
+  if (value === false) return "false";
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value) || Object.is(value, -0)) {
+      throw new SignedObjectError(`not an integer in range: ${value}`);
+    }
+    return String(value);
+  }
+  if (typeof value === "string") {
+    checkString(value);
+    return '"' + value.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '"';
+  }
+  if (Array.isArray(value)) return "[" + value.map(encode).join(",") + "]";
+  if (isPlainObject(value)) {
+    return "{" + Object.keys(value).sort().map((key) => {
+      checkString(key);
+      return encode(key) + ":" + encode(value[key]);
+    }).join(",") + "}";
+  }
+  if (value === null) throw new SignedObjectError("null is not allowed");
+  throw new SignedObjectError(`not allowed: ${typeof value}`);
+}
+function canonical(body) {
+  if (!isPlainObject(body)) throw new SignedObjectError("a body must be a JSON object");
+  return new TextEncoder().encode(encode(body));
+}
+function hashCanonical(body) {
+  return createHash2("sha256").update(`UAM-${String(body["type"])}-v1
+`).update(canonical(body)).digest("base64url");
+}
+function objectHash(body) {
+  validate(body);
+  return hashCanonical(body);
+}
+var TIME_RE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})Z$/;
+var HASH_RE = /^[A-Za-z0-9_-]{43}$/;
+var OWNER_ID_RE = /^[A-Za-z0-9_-]{22}$/;
+var NONCE_RE = /^[A-Za-z0-9_-]{16,64}$/;
+var SECRET_RE = /^[A-Za-z0-9_-]{22}$/;
+var DOMAIN_RE = /^(?=.{1,253}$)[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)+$/;
+function fail(path, why) {
+  throw new SignedObjectError(`${path}: ${why}`);
+}
+var string_ = (v, p) => {
+  if (typeof v !== "string" || v.length === 0) fail(p, "must be a non-empty string");
+};
+var label = (v, p) => {
+  string_(v, p);
+  if (v.length > 64) fail(p, "at most 64 characters");
+  if (v.includes('"')) fail(p, 'must not contain "');
+};
+var matching = (re, what) => (v, p) => {
+  if (typeof v !== "string" || !re.test(v)) fail(p, `must be ${what}`);
+};
+var hash = matching(HASH_RE, "a hash (43 base64url characters)");
+var ownerId = matching(OWNER_ID_RE, "an owner id (22 base64url characters)");
+var nonce = matching(NONCE_RE, "a nonce (16-64 base64url characters)");
+var secret = matching(SECRET_RE, "a secret (22 base64url characters)");
+var domain = matching(DOMAIN_RE, "a lowercase domain");
+function parseTime(value) {
+  const m = TIME_RE.exec(value);
+  if (!m) return null;
+  const [y, mo, d, h, mi, s] = m.slice(1).map(Number);
+  const t = Date.UTC(y, mo - 1, d, h, mi, s);
+  const back = new Date(t);
+  if (back.getUTCFullYear() !== y || back.getUTCMonth() !== mo - 1 || back.getUTCDate() !== d || back.getUTCHours() !== h || back.getUTCMinutes() !== mi || back.getUTCSeconds() !== s) {
+    return null;
+  }
+  return t;
+}
+var time = (v, p) => {
+  if (typeof v !== "string" || !TIME_RE.test(v)) fail(p, "must be YYYY-MM-DDTHH:MM:SSZ");
+  if (parseTime(v) === null) fail(p, "not a real time");
+};
+var bool = (v, p) => {
+  if (typeof v !== "boolean") fail(p, "must be true or false");
+};
+var constant = (expected) => (v, p) => {
+  if (v !== expected) fail(p, `must be ${JSON.stringify(expected)}`);
+};
+var oneOf = (...options) => (v, p) => {
+  if (typeof v !== "string" || !options.includes(v)) fail(p, `must be one of ${options.join(", ")}`);
+};
+var uint = (v, p) => {
+  if (typeof v !== "number" || !Number.isSafeInteger(v) || v < 0) {
+    fail(p, "must be a non-negative integer");
+  }
+};
+var address = (v, p) => {
+  if (typeof v !== "string") fail(p, "must be an address");
+  let full;
+  try {
+    full = parseAddress(v).full;
+  } catch {
+    return fail(p, "must be an address");
+  }
+  if (full !== v) fail(p, "must be an address in canonical (lowercase) form");
+};
+var did = (kind) => (v, p) => {
+  let found;
+  try {
+    found = decodeDidKey(v).kind;
+  } catch (err) {
+    return fail(p, err instanceof Error ? err.message : String(err));
+  }
+  if (found !== kind) fail(p, `must be a ${kind} did:key`);
+};
+var list = (item, minLen = 1, maxLen = 64) => (v, p) => {
+  if (!Array.isArray(v) || v.length < minLen || v.length > maxLen) {
+    fail(p, `must be a list of ${minLen}-${maxLen} items`);
+  }
+  v.forEach((entry, i) => item(entry, `${p}[${i}]`));
+};
+var object = (required, optional = {}) => (v, p) => {
+  if (!isPlainObject(v)) fail(p, "must be an object");
+  for (const key of Object.keys(v)) {
+    if (!has(required, key) && !has(optional, key)) fail(`${p}.${key}`, "unknown member");
+  }
+  for (const [key, member] of Object.entries(required)) {
+    if (!has(v, key)) fail(`${p}.${key}`, "missing");
+    member(v[key], `${p}.${key}`);
+  }
+  for (const [key, member] of Object.entries(optional)) {
+    if (has(v, key)) member(v[key], `${p}.${key}`);
+  }
+};
+var location = (v, p) => {
+  if (v !== "shared") address(v, p);
+};
+var access = object({ actions: list(oneOf("message"), 1, 1), locations: list(location) });
+var ownerRef = object({ relay: domain, ownerId, keysHash: hash });
+var ownerRefNoKeys = object({ relay: domain, ownerId });
+var passkey = did("p256");
+var agentKey = did("ed25519");
+var keysOwner = object({ relay: domain }, { ownerId });
+var EXT = { ext: () => void 0, crit: () => void 0 };
+function checkExt(body) {
+  if (has(body, "ext") && !isPlainObject(body["ext"])) fail("ext", "must be an object");
+  if (has(body, "crit")) {
+    const crit = body["crit"];
+    if (!has(body, "ext")) fail("crit", "needs ext");
+    if (!Array.isArray(crit) || !crit.every((k) => typeof k === "string")) {
+      fail("crit", "must be a list of ext keys");
+    }
+    for (const key of crit) {
+      if (!has(body["ext"], key)) fail(`crit.${key}`, "not in ext");
+      fail(`crit.${key}`, "unknown critical extension");
+    }
+  }
+}
+function span(body, from, to) {
+  return parseTime(body[to]) - parseTime(body[from]);
+}
+var DAY = 24 * 60 * 60 * 1e3;
+var SCHEMAS = {
+  UamOwnerKeys(body) {
+    object(
+      {
+        type: constant("UamOwnerKeys"),
+        v: constant(1),
+        owner: keysOwner,
+        seq: uint,
+        keys: list(object({ id: passkey, rpId: domain, backupEligible: bool, label }), 1, 16)
+      },
+      {
+        prev: hash,
+        removed: list(object({ id: passkey, reason: oneOf("removed", "compromised") }), 1, 64),
+        recovery: bool,
+        ...EXT
+      }
+    )(body, "$");
+    const owner = body["owner"];
+    if (body["seq"] === 0) {
+      if (has(owner, "ownerId") || has(body, "prev")) fail("$", "entry 0 has no owner.ownerId and no prev");
+    } else if (!has(owner, "ownerId") || !has(body, "prev")) {
+      fail("$", "a later entry needs owner.ownerId and prev");
+    }
+  },
+  UamOwnerLink(body) {
+    object({
+      type: constant("UamOwnerLink"),
+      v: constant(1),
+      owner: ownerRef,
+      agent: address,
+      agentKey,
+      relay: domain,
+      via: oneOf("setup", "link"),
+      shared: bool,
+      effectiveAt: time,
+      validFrom: time,
+      nonce
+    }, { ...EXT })(body, "$");
+  },
+  UamOwnerUnlink(body) {
+    object({
+      type: constant("UamOwnerUnlink"),
+      v: constant(1),
+      owner: ownerRef,
+      agent: address,
+      agentKey,
+      reason: oneOf("owner", "admin", "relink", "authority", "lapsed"),
+      validFrom: time,
+      nonce
+    }, { ...EXT })(body, "$");
+  },
+  UamInvite(body) {
+    object(
+      {
+        type: constant("UamInvite"),
+        v: constant(1),
+        inviter: ownerRef,
+        offer: access,
+        ask: access,
+        secretHash: hash,
+        mode: oneOf("preapproved", "confirm"),
+        maxUses: constant(1),
+        validFrom: time,
+        redeemBy: time,
+        nonce
+      },
+      { emailHash: hash, ...EXT }
+    )(body, "$");
+    if (body["mode"] === "preapproved" && !has(body, "emailHash")) {
+      fail("$.emailHash", "a pre-approved invite names the invitee's email");
+    }
+    const d = span(body, "validFrom", "redeemBy");
+    if (!(d > 0 && d <= INVITE_MAX_DAYS * DAY)) {
+      fail("$.redeemBy", `must be after validFrom, within ${INVITE_MAX_DAYS} days`);
+    }
+  },
+  UamRedemption(body) {
+    object({
+      type: constant("UamRedemption"),
+      v: constant(1),
+      invite: hash,
+      secret,
+      invitee: ownerRef,
+      issuer: passkey,
+      createdAt: time,
+      nonce
+    }, { ...EXT })(body, "$");
+  },
+  UamContactGrant(body) {
+    object({
+      type: constant("UamContactGrant"),
+      v: constant(1),
+      issuer: passkey,
+      issuerOwner: ownerRefNoKeys,
+      credentialSubject: subject,
+      authorization_details: list(object({
+        type: constant("uam_contact"),
+        actions: list(oneOf("message"), 1, 1),
+        locations: list(location)
+      }), 1, 8),
+      via: oneOf("intro_email", "intro_code", "intro_qr", "request", "carried_over"),
+      enforcer: domain,
+      validFrom: time,
+      validUntil: time,
+      nonce
+    }, { ...EXT })(body, "$");
+    const d = span(body, "validFrom", "validUntil");
+    if (!(d > 0 && d <= GRANT_MAX_DAYS * DAY)) {
+      fail("$.validUntil", `must be after validFrom, within ${GRANT_MAX_DAYS} days`);
+    }
+  },
+  // Who may message an agent, as its owner approved it (P2e). Only a change
+  // that widens it is signed; narrowing needs no passkey.
+  UamAgentPolicy(body) {
+    object({
+      type: constant("UamAgentPolicy"),
+      v: constant(1),
+      owner: ownerRef,
+      agent: address,
+      agentKey,
+      policy: oneOf("open", "contacts"),
+      sameOwner: bool,
+      validFrom: time,
+      nonce
+    }, { ...EXT })(body, "$");
+  }
+};
+var SUBJECTS = {
+  owner: object({ kind: constant("owner"), owner: ownerRef }),
+  invitee: object({ kind: constant("invitee"), invite: hash }),
+  agent: object({ kind: constant("agent"), id: agentKey, address })
+};
+function subject(value, path) {
+  const kind = isPlainObject(value) ? value["kind"] : void 0;
+  if (typeof kind !== "string" || !has(SUBJECTS, kind)) {
+    fail(`${path}.kind`, `must be one of ${Object.keys(SUBJECTS).join(", ")}`);
+  }
+  SUBJECTS[kind](value, path);
+}
+function validate(body) {
+  if (!isPlainObject(body)) throw new SignedObjectError("a body must be a JSON object");
+  encode(body);
+  const type = body["type"];
+  if (typeof type !== "string" || !has(SCHEMAS, type)) {
+    throw new SignedObjectError(`unknown type: ${JSON.stringify(type)}`);
+  }
+  SCHEMAS[type](body);
+  checkExt(body);
+}
+
+// src/protocol/webauthn.ts
+import { createHash as createHash3 } from "crypto";
+import { p256 } from "@noble/curves/p256";
+var ES256 = -7;
+var UP = 1;
+var UV = 4;
+var BE = 8;
+var AT = 64;
+var ED = 128;
+var WebAuthnError = class extends UAMError {
+  constructor(message) {
+    super(message);
+    this.name = "WebAuthnError";
+  }
+};
+function credentialDid(credential) {
+  return encodeDidKey("p256", credential.publicKey);
+}
+var sha256 = (...parts) => {
+  const h = createHash3("sha256");
+  for (const part of parts) h.update(part);
+  return new Uint8Array(h.digest());
+};
+var equal = (a, b) => a.length === b.length && a.every((byte, i) => byte === b[i]);
+function cbor(data, start) {
+  let i = start;
+  if (i >= data.length) throw new WebAuthnError("CBOR: truncated");
+  const first = data[i];
+  const major = first >> 5;
+  const info = first & 31;
+  i += 1;
+  if (major === 7) {
+    if (info === 20) return [false, i];
+    if (info === 21) return [true, i];
+    throw new WebAuthnError("CBOR: unsupported simple value or float");
+  }
+  let n;
+  if (info < 24) {
+    n = info;
+  } else if (info >= 24 && info <= 27) {
+    const size = 1 << info - 24;
+    if (i + size > data.length) throw new WebAuthnError("CBOR: truncated");
+    let big = 0n;
+    for (let k = 0; k < size; k += 1) big = big << 8n | BigInt(data[i + k]);
+    if (big > BigInt(Number.MAX_SAFE_INTEGER)) throw new WebAuthnError("CBOR: number too large");
+    n = Number(big);
+    i += size;
+  } else {
+    throw new WebAuthnError("CBOR: indefinite lengths are not supported");
+  }
+  if (major === 0) return [n, i];
+  if (major === 1) return [-1 - n, i];
+  if (major === 2 || major === 3) {
+    if (i + n > data.length) throw new WebAuthnError("CBOR: truncated");
+    const raw = data.slice(i, i + n);
+    i += n;
+    if (major === 2) return [raw, i];
+    try {
+      return [new TextDecoder("utf-8", { fatal: true }).decode(raw), i];
+    } catch {
+      throw new WebAuthnError("CBOR: text is not UTF-8");
+    }
+  }
+  if (major === 4) {
+    const items = [];
+    for (let k = 0; k < n; k += 1) {
+      const [item, next] = cbor(data, i);
+      items.push(item);
+      i = next;
+    }
+    return [items, i];
+  }
+  if (major === 5) {
+    const out = /* @__PURE__ */ new Map();
+    for (let k = 0; k < n; k += 1) {
+      const [key, afterKey] = cbor(data, i);
+      if (typeof key !== "number" && typeof key !== "string") {
+        throw new WebAuthnError("CBOR: map keys must be integers or text");
+      }
+      if (out.has(key)) throw new WebAuthnError("CBOR: duplicate map key");
+      const [value, afterValue] = cbor(data, afterKey);
+      out.set(key, value);
+      i = afterValue;
+    }
+    return [out, i];
+  }
+  throw new WebAuthnError("CBOR: tags are not supported");
+}
+function cborWhole(data) {
+  const [value, end] = cbor(data, 0);
+  if (end !== data.length) throw new WebAuthnError("CBOR: trailing bytes");
+  return value;
+}
+function checkClientData(raw, kind, challenge, origin) {
+  let data;
+  try {
+    data = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(raw));
+  } catch {
+    throw new WebAuthnError("clientDataJSON is not JSON");
+  }
+  if (data === null || typeof data !== "object" || Array.isArray(data)) {
+    throw new WebAuthnError("clientDataJSON is not an object");
+  }
+  const d = data;
+  if (d["type"] !== kind) throw new WebAuthnError(`clientData.type must be ${kind}`);
+  if (d["challenge"] !== Buffer.from(challenge).toString("base64url")) {
+    throw new WebAuthnError("clientData.challenge doesn't match");
+  }
+  if (d["origin"] !== origin) throw new WebAuthnError("clientData.origin doesn't match");
+  if ("crossOrigin" in d && d["crossOrigin"] !== false) {
+    throw new WebAuthnError("cross-origin ceremonies are refused");
+  }
+  if ("topOrigin" in d) throw new WebAuthnError("ceremonies in a frame are refused");
+}
+function checkAuthData(data, rpId) {
+  if (data.length < 37) throw new WebAuthnError("authenticatorData too short");
+  if (!equal(data.slice(0, 32), sha256(new TextEncoder().encode(rpId)))) {
+    throw new WebAuthnError("rpIdHash doesn't match");
+  }
+  const flags = data[32];
+  if (!(flags & UP)) throw new WebAuthnError("user not present");
+  if (!(flags & UV)) throw new WebAuthnError("user not verified");
+  const count = new DataView(data.buffer, data.byteOffset + 33, 4).getUint32(0, false);
+  return { flags, count };
+}
+function point(bytes) {
+  try {
+    return p256.ProjectivePoint.fromHex(bytes);
+  } catch {
+    throw new WebAuthnError("not a P-256 point");
+  }
+}
+function verifyRegistration(args) {
+  checkClientData(args.clientDataJSON, "webauthn.create", args.challenge, args.origin);
+  const att = cborWhole(args.attestationObject);
+  if (!(att instanceof Map) || att.size !== 3 || !att.has("fmt") || !att.has("attStmt") || !att.has("authData")) {
+    throw new WebAuthnError("attestationObject must have fmt, attStmt and authData");
+  }
+  const stmt = att.get("attStmt");
+  if (att.get("fmt") !== "none" || !(stmt instanceof Map) || stmt.size !== 0) {
+    throw new WebAuthnError("only attestation format 'none' is accepted");
+  }
+  const data = att.get("authData");
+  if (!(data instanceof Uint8Array)) throw new WebAuthnError("authData must be bytes");
+  const { flags, count } = checkAuthData(data, args.rpId);
+  if (!(flags & AT)) throw new WebAuthnError("no attested credential data");
+  if (data.length < 55) throw new WebAuthnError("attested credential data too short");
+  const idLen = data[53] << 8 | data[54];
+  const credentialId = data.slice(55, 55 + idLen);
+  if (credentialId.length !== idLen) throw new WebAuthnError("credential id truncated");
+  const [cose, end] = cbor(data, 55 + idLen);
+  if (!(flags & ED) && end !== data.length) {
+    throw new WebAuthnError("trailing bytes after the credential key");
+  }
+  if (!(cose instanceof Map) || cose.get(1) !== 2 || cose.get(3) !== ES256 || cose.get(-1) !== 1) {
+    throw new WebAuthnError("only ES256 (P-256) passkeys are accepted");
+  }
+  const x = cose.get(-2);
+  const y = cose.get(-3);
+  if (!(x instanceof Uint8Array) || !(y instanceof Uint8Array) || x.length !== 32 || y.length !== 32) {
+    throw new WebAuthnError("bad P-256 coordinates");
+  }
+  const key = point(new Uint8Array([4, ...x, ...y]));
+  return {
+    id: credentialId,
+    alg: ES256,
+    publicKey: key.toRawBytes(true),
+    backupEligible: Boolean(flags & BE),
+    signCount: count
+  };
+}
+function verifyAssertion(credential, args) {
+  if (credential.alg !== ES256) throw new WebAuthnError("only ES256 (P-256) passkeys are accepted");
+  checkClientData(args.clientDataJSON, "webauthn.get", args.challenge, args.origin);
+  const { flags, count } = checkAuthData(args.authenticatorData, args.rpId);
+  if (Boolean(flags & BE) !== credential.backupEligible) {
+    throw new WebAuthnError("backup eligibility changed since registration");
+  }
+  const key = point(credential.publicKey);
+  const digest = sha256(args.authenticatorData, sha256(args.clientDataJSON));
+  let ok = false;
+  try {
+    ok = p256.verify(args.signature, digest, key.toRawBytes(false), {
+      format: "der",
+      lowS: false,
+      prehash: false
+    });
+  } catch {
+    ok = false;
+  }
+  if (!ok) throw new WebAuthnError("bad signature");
+  const checkCounter = args.checkCounter ?? true;
+  if (checkCounter && (count || credential.signCount) && count <= credential.signCount) {
+    throw new WebAuthnError("sign count didn't go up: the passkey may have been cloned");
+  }
+  return count;
+}
+function approvalChallenge(items, screen) {
+  if (items.length === 0) throw new WebAuthnError("an approval covers at least one object");
+  const body = {
+    set: items.map(([t, h]) => ({ t, h })),
+    screen: createHash3("sha256").update(screen, "utf8").digest("hex")
+  };
+  let data;
+  try {
+    data = canonical(body);
+  } catch (err) {
+    if (err instanceof SignedObjectError) throw new WebAuthnError(`bad approval set: ${err.message}`);
+    throw err;
+  }
+  return sha256(new TextEncoder().encode("UAM-APPROVAL-v1\n"), data);
+}
+
 // src/version.ts
-var SDK_VERSION = "0.2.1";
+var SDK_VERSION = "0.4.0";
 
 // src/sdk/config.ts
 import { homedir } from "os";
@@ -843,11 +1639,11 @@ var KeyManager = class {
   /**
    * Store the address `relayUrl` gave this agent.
    */
-  saveAddress(name, address, relayUrl) {
+  saveAddress(name, address2, relayUrl) {
     mkdirSync(this._keyDir, { recursive: true });
     writeFileSync(
       join2(this._keyDir, `${name}.address`),
-      JSON.stringify({ address, relay_url: relayUrl })
+      JSON.stringify({ address: address2, relay_url: relayUrl })
     );
   }
   /**
@@ -860,14 +1656,14 @@ var KeyManager = class {
     try {
       const path = join2(this._keyDir, `${name}.address`);
       const saved = JSON.parse(readFileSync(path, "utf-8"));
-      const address = saved?.address;
+      const address2 = saved?.address;
       const savedRelay = saved?.relay_url;
-      if (typeof address !== "string" || typeof savedRelay !== "string") {
+      if (typeof address2 !== "string" || typeof savedRelay !== "string") {
         return null;
       }
       if (trimRelayUrl(savedRelay) !== trimRelayUrl(relayUrl)) return null;
-      parseAddress(address);
-      return address;
+      parseAddress(address2);
+      return address2;
     } catch {
       return null;
     }
@@ -935,6 +1731,42 @@ var KeyManager = class {
   }
 };
 
+// src/sdk/message.ts
+var SEND_STATUSES = [
+  "delivered",
+  "stored",
+  "relayed",
+  "queued",
+  "duplicate",
+  "dropped",
+  "pending",
+  "accepted",
+  "unknown"
+];
+function sendStatus(answer) {
+  if (answer === null) return "unknown";
+  const status = answer["status"];
+  if (typeof status === "string" && SEND_STATUSES.includes(status) && status !== "accepted" && status !== "unknown") {
+    return status;
+  }
+  return "accepted";
+}
+function supports(features, name, version = 1) {
+  const prefix = `${name}:`;
+  for (const feature of features) {
+    if (feature === name && version <= 1) return true;
+    if (feature.startsWith(prefix)) {
+      const rest = feature.slice(prefix.length);
+      if (/^\d+$/.test(rest) && Number(rest) >= version) return true;
+    }
+  }
+  return false;
+}
+var PENDING_NOTE = "Not delivered: {to} only accepts messages from approved contacts. Do not resend it.";
+function pendingNote(to) {
+  return PENDING_NOTE.replace("{to}", to);
+}
+
 // src/sdk/contact-book.ts
 import { mkdirSync as mkdirSync2 } from "fs";
 import { join as join3, dirname } from "path";
@@ -1032,36 +1864,36 @@ var ContactBook = class {
   /**
    * Check if an address is in the contact book (in-memory, no I/O).
    */
-  isKnown(address) {
-    return this._knownAddresses.has(address);
+  isKnown(address2) {
+    return this._knownAddresses.has(address2);
   }
   /**
    * Check if an address matches any blocked pattern (O(1) set lookup).
    */
-  isBlocked(address) {
-    if (this._blockedExact.has(address)) {
+  isBlocked(address2) {
+    if (this._blockedExact.has(address2)) {
       return true;
     }
-    if (address.includes("::")) {
-      const domain = address.split("::")[1];
-      return this._blockedDomains.has(domain);
+    if (address2.includes("::")) {
+      const domain2 = address2.split("::")[1];
+      return this._blockedDomains.has(domain2);
     }
     return false;
   }
   /**
    * Look up the public key for a known contact.
    */
-  getPublicKey(address) {
+  getPublicKey(address2) {
     if (this._db === null) return null;
-    const row = this._db.prepare("SELECT public_key FROM contacts WHERE address = ?").get(address);
+    const row = this._db.prepare("SELECT public_key FROM contacts WHERE address = ?").get(address2);
     return row?.public_key ?? null;
   }
   /**
    * Return the relay URLs for a known contact (CARD-04).
    */
-  getRelayUrls(address) {
+  getRelayUrls(address2) {
     if (this._db === null) return null;
-    const row = this._db.prepare("SELECT relay, relays_json FROM contacts WHERE address = ?").get(address);
+    const row = this._db.prepare("SELECT relay, relays_json FROM contacts WHERE address = ?").get(address2);
     if (!row) return null;
     if (row.relays_json !== null) {
       return JSON.parse(row.relays_json);
@@ -1082,19 +1914,19 @@ var ContactBook = class {
    * @throws {KeyPinningError} If a pinned/verified contact's key would be
    *   replaced by a different key without `force`.
    */
-  addContact(address, publicKey, options) {
+  addContact(address2, publicKey, options) {
     if (this._db === null) {
       throw new Error("ContactBook not open. Call open() first.");
     }
-    const existing = this._db.prepare("SELECT public_key, trust_state FROM contacts WHERE address = ?").get(address);
+    const existing = this._db.prepare("SELECT public_key, trust_state FROM contacts WHERE address = ?").get(address2);
     if (existing !== void 0 && (existing.trust_state === "pinned" || existing.trust_state === "verified") && existing.public_key !== publicKey) {
       if (!options?.force) {
         throw new KeyPinningError(
-          `Refusing to overwrite ${existing.trust_state} contact ${JSON.stringify(address)}: stored public key does not match the new key. Pass force: true to rotate.`
+          `Refusing to overwrite ${existing.trust_state} contact ${JSON.stringify(address2)}: stored public key does not match the new key. Pass force: true to rotate.`
         );
       }
       log.warn(
-        `Force-replacing the key of ${existing.trust_state} contact ${address} (key rotation)`
+        `Force-replacing the key of ${existing.trust_state} contact ${address2} (key rotation)`
       );
     }
     const displayName = options?.displayName ?? null;
@@ -1113,8 +1945,8 @@ var ContactBook = class {
            relay = COALESCE(excluded.relay, contacts.relay),
            relays_json = COALESCE(excluded.relays_json, contacts.relays_json),
            last_seen = datetime('now')`
-    ).run(address, publicKey, displayName, trustState, trustSource, relay, relaysJson);
-    this._knownAddresses.add(address);
+    ).run(address2, publicKey, displayName, trustState, trustSource, relay, relaysJson);
+    this._knownAddresses.add(address2);
   }
   /**
    * Return all contacts sorted by last_seen DESC.
@@ -1135,13 +1967,13 @@ var ContactBook = class {
   /**
    * Store a pending handshake request.
    */
-  addPending(address, contactCardJson) {
+  addPending(address2, contactCardJson) {
     if (this._db === null) {
       throw new Error("ContactBook not open. Call open() first.");
     }
     this._db.prepare(
       `INSERT OR REPLACE INTO pending_handshakes (address, contact_card) VALUES (?, ?)`
-    ).run(address, contactCardJson);
+    ).run(address2, contactCardJson);
   }
   /**
    * Retrieve all pending handshake requests.
@@ -1160,9 +1992,9 @@ var ContactBook = class {
   /**
    * Remove a pending handshake request.
    */
-  removePending(address) {
+  removePending(address2) {
     if (this._db === null) return;
-    this._db.prepare("DELETE FROM pending_handshakes WHERE address = ?").run(address);
+    this._db.prepare("DELETE FROM pending_handshakes WHERE address = ?").run(address2);
   }
   /**
    * Return pending handshakes older than N days.
@@ -1182,31 +2014,31 @@ var ContactBook = class {
   /**
    * Return the trust_state for an address, or null if unknown.
    */
-  getTrustState(address) {
+  getTrustState(address2) {
     if (this._db === null) return null;
-    const row = this._db.prepare("SELECT trust_state FROM contacts WHERE address = ?").get(address);
+    const row = this._db.prepare("SELECT trust_state FROM contacts WHERE address = ?").get(address2);
     return row?.trust_state ?? null;
   }
   /**
    * Set the pinned_at timestamp and trust_state='pinned' for a contact (TOFU).
    */
-  setPinnedAt(address) {
+  setPinnedAt(address2) {
     if (this._db === null) {
       throw new Error("ContactBook not open. Call open() first.");
     }
     this._db.prepare(
       "UPDATE contacts SET pinned_at = datetime('now'), trust_state = 'pinned' WHERE address = ?"
-    ).run(address);
+    ).run(address2);
   }
   /**
    * Remove a contact by address. Returns true if a contact was deleted.
    */
-  removeContact(address) {
+  removeContact(address2) {
     if (this._db === null) {
       throw new Error("ContactBook not open. Call open() first.");
     }
-    const result = this._db.prepare("DELETE FROM contacts WHERE address = ?").run(address);
-    this._knownAddresses.delete(address);
+    const result = this._db.prepare("DELETE FROM contacts WHERE address = ?").run(address2);
+    this._knownAddresses.delete(address2);
     return result.changes > 0;
   }
   /**
@@ -1214,8 +2046,8 @@ var ContactBook = class {
    *
    * Convenience helper for inbound message filtering (CARD-05, TOFU-02).
    */
-  isTrustedOrVerified(address) {
-    const state = this.getTrustState(address);
+  isTrustedOrVerified(address2) {
+    const state = this.getTrustState(address2);
     return state === "trusted" || state === "verified" || state === "pinned";
   }
   /**
@@ -1512,8 +2344,8 @@ var Tier3Resolver = class extends AddressResolver {
       transport: http(rpcUrl)
     });
   }
-  async resolvePublicKey(address, _token, _relayUrl) {
-    const parsed = parseAddress(address);
+  async resolvePublicKey(address2, _token, _relayUrl) {
+    const parsed = parseAddress(address2);
     const name = parsed.domain;
     const cached = this._cache.get(name);
     if (cached && cached.expiresAt > Date.now()) {
@@ -1577,12 +2409,12 @@ var Tier3Resolver = class extends AddressResolver {
 // src/sdk/resolver.ts
 init_dns_verifier();
 var Tier1Resolver = class extends AddressResolver {
-  async resolvePublicKey(address, _token, relayUrl) {
+  async resolvePublicKey(address2, _token, relayUrl) {
     const resp = await fetch(
-      `${relayUrl}/api/v1/agents/${address}/public-key`
+      `${relayUrl}/api/v1/agents/${address2}/public-key`
     );
     if (resp.status === 404) {
-      throw new UAMError(`Agent not found: ${address}`);
+      throw new UAMError(`Agent not found: ${address2}`);
     }
     if (!resp.ok) {
       throw new UAMError(
@@ -1594,8 +2426,8 @@ var Tier1Resolver = class extends AddressResolver {
   }
 };
 var Tier2Resolver = class extends AddressResolver {
-  async resolvePublicKey(address, _token, _relayUrl) {
-    const parsed = parseAddress(address);
+  async resolvePublicKey(address2, _token, _relayUrl) {
+    const parsed = parseAddress(address2);
     const txtRecords = await queryUamTxt(parsed.domain);
     for (const txt of txtRecords) {
       const tags = parseUamTxt(txt);
@@ -1607,7 +2439,7 @@ var Tier2Resolver = class extends AddressResolver {
     const httpsKey = await resolveKeyViaHttps(parsed.agent, parsed.domain);
     if (httpsKey) return httpsKey;
     throw new UAMError(
-      `Could not resolve public key for ${address} via DNS or HTTPS`
+      `Could not resolve public key for ${address2} via DNS or HTTPS`
     );
   }
 };
@@ -1623,21 +2455,21 @@ var SmartResolver = class extends AddressResolver {
     this._tier2 = new Tier2Resolver();
     this._tier3 = tier3Config ? new Tier3Resolver(tier3Config) : null;
   }
-  async resolvePublicKey(address, token, relayUrl) {
-    const parsed = parseAddress(address);
-    const domain = parsed.domain;
-    if (domain === this.relayDomain) {
-      return this._tier1.resolvePublicKey(address, token, relayUrl);
+  async resolvePublicKey(address2, token, relayUrl) {
+    const parsed = parseAddress(address2);
+    const domain2 = parsed.domain;
+    if (domain2 === this.relayDomain) {
+      return this._tier1.resolvePublicKey(address2, token, relayUrl);
     }
-    if (domain.includes(".")) {
-      return this._tier2.resolvePublicKey(address, token, relayUrl);
+    if (domain2.includes(".")) {
+      return this._tier2.resolvePublicKey(address2, token, relayUrl);
     }
     if (!this._tier3) {
       throw new UAMError(
-        `Tier 3 resolution requires contract config. Cannot resolve dot-free domain: '${domain}'`
+        `Tier 3 resolution requires contract config. Cannot resolve dot-free domain: '${domain2}'`
       );
     }
-    return this._tier3.resolvePublicKey(address, token, relayUrl);
+    return this._tier3.resolvePublicKey(address2, token, relayUrl);
   }
 };
 
@@ -1646,15 +2478,23 @@ var TransportBase = class {
 };
 
 // src/sdk/transport/http.ts
+async function readAnswer(resp) {
+  try {
+    const body = await resp.json();
+    return body !== null && typeof body === "object" && !Array.isArray(body) ? body : {};
+  } catch {
+    return {};
+  }
+}
 var HTTPTransport = class extends TransportBase {
   _relayUrl;
   _token;
   _address;
-  constructor(relayUrl, token, address) {
+  constructor(relayUrl, token, address2) {
     super();
     this._relayUrl = relayUrl.replace(/\/+$/, "");
     this._token = token;
-    this._address = address;
+    this._address = address2;
   }
   async connect() {
   }
@@ -1674,6 +2514,7 @@ var HTTPTransport = class extends TransportBase {
         `HTTP send failed: ${resp.status} ${resp.statusText}`
       );
     }
+    return readAnswer(resp);
   }
   async receive(limit = 50) {
     const url = new URL(
@@ -1706,6 +2547,7 @@ var BASE_DELAY = 1;
 var MAX_DELAY = 60;
 var JITTER_RANGE = 1;
 var SEND_SETTLE_SECONDS = 5;
+var ACK_TIMEOUT_SECONDS = 5;
 var WebSocketTransport = class extends TransportBase {
   _url;
   _token;
@@ -1721,8 +2563,12 @@ var WebSocketTransport = class extends TransportBase {
   _unanswered = 0;
   _settling = null;
   _settled = null;
+  /** Sends waiting for the relay's answer, by message_id. */
+  _waiting = /* @__PURE__ */ new Map();
   /** @internal How long a close waits, in ms. Replaceable in tests. */
   _settleMs = SEND_SETTLE_SECONDS * 1e3;
+  /** @internal How long send() waits for an answer, in ms. Replaceable in tests. */
+  _ackMs = ACK_TIMEOUT_SECONDS * 1e3;
   constructor(wsUrl, token, onMessage) {
     super();
     this._url = wsUrl;
@@ -1766,13 +2612,42 @@ var WebSocketTransport = class extends TransportBase {
       this._ws = null;
     }
     this._connected = false;
+    this._abandonWaiting();
   }
+  /**
+   * Send an envelope and wait for the relay's answer.
+   *
+   * Resolves with the ack that names the message, or null when none came
+   * within _ackMs or the socket went: the message may still have arrived.
+   * Rejects with SendRefusedError when the relay refuses it by message_id
+   * (relays before 1.1 don't name it, so their refusals end as null).
+   */
   async send(envelope) {
     if (!this._ws || this._ws.readyState !== WebSocket.OPEN) {
       throw new Error("WebSocket not connected");
     }
+    const messageId = envelope["message_id"];
+    let answer = null;
+    let timer;
+    if (typeof messageId === "string" && !this._waiting.has(messageId)) {
+      answer = new Promise((resolve, reject) => {
+        this._waiting.set(messageId, { resolve, reject });
+        timer = setTimeout(() => {
+          log.warn(
+            `No answer from the relay for ${messageId} within ${this._ackMs / 1e3}s`
+          );
+          this._settle(messageId, null);
+        }, this._ackMs);
+      });
+    }
     this._ws.send(JSON.stringify(envelope));
     this._unanswered += 1;
+    if (answer === null) return null;
+    try {
+      return await answer;
+    } finally {
+      clearTimeout(timer);
+    }
   }
   async receive(limit = 50) {
     const result = this._pending.slice(0, limit);
@@ -1799,6 +2674,21 @@ var WebSocketTransport = class extends TransportBase {
     });
     return this._settling;
   }
+  /** Hand the relay's answer (or a refusal) to the send waiting for it. */
+  _settle(messageId, answer, error) {
+    if (typeof messageId !== "string") return;
+    const waiting = this._waiting.get(messageId);
+    if (!waiting) return;
+    this._waiting.delete(messageId);
+    if (error) waiting.reject(error);
+    else waiting.resolve(answer);
+  }
+  /** The socket went: no answers will come for what it carried. */
+  _abandonWaiting() {
+    const waiting = [...this._waiting.values()];
+    this._waiting.clear();
+    for (const w of waiting) w.resolve(null);
+  }
   _answered() {
     this._unanswered = Math.max(0, this._unanswered - 1);
     if (this._unanswered === 0) this._settled?.();
@@ -1830,6 +2720,7 @@ var WebSocketTransport = class extends TransportBase {
         this._ws = null;
         this._unanswered = 0;
         this._settled?.();
+        this._abandonWaiting();
         if (!this._running) return;
         attempt += 1;
         const delay = Math.min(BASE_DELAY * Math.pow(2, attempt), MAX_DELAY);
@@ -1859,16 +2750,28 @@ var WebSocketTransport = class extends TransportBase {
       }
     } else if (msgType === "ack") {
       this._answered();
+      this._settle(msg["message_id"], msg);
+    } else if (msgType === "relay.notice") {
+      log.warn(
+        `Relay notice: message ${String(msg["message_id"])} is ${String(msg["status"])}`
+      );
     } else if (msgType === "error" || "error" in msg) {
       this._answered();
+      const code = String(msg["error"] ?? msg["code"] ?? "error");
+      const detail = typeof msg["detail"] === "string" ? msg["detail"] : void 0;
+      log.warn(`Relay error: [${code}] ${detail ?? ""}`.trimEnd());
+      const messageId = msg["message_id"];
+      if (typeof messageId === "string") {
+        this._settle(messageId, null, new SendRefusedError(messageId, code, detail));
+      }
     }
   }
 };
 
 // src/sdk/transport/index.ts
-function createTransport(config, token, address, onMessage) {
+function createTransport(config, token, address2, onMessage) {
   if (config.transportType === "http") {
-    return new HTTPTransport(config.relayUrl, token, address);
+    return new HTTPTransport(config.relayUrl, token, address2);
   } else {
     return new WebSocketTransport(config.relayWsUrl, token, onMessage);
   }
@@ -2261,7 +3164,12 @@ var Agent = class {
   }
   // -- Messaging -----------------------------------------------------------
   /**
-   * Send an encrypted, signed message. Returns the message_id.
+   * Send an encrypted, signed message.
+   *
+   * Returns the message id with what the relay did with it: `status`
+   * "pending" means the recipient only takes approved contacts, and the
+   * message was not kept (don't resend it). `delivered` is true only when
+   * the relay says the recipient has it.
    */
   async send(toAddress, message, options) {
     await this._ensureConnected();
@@ -2293,14 +3201,20 @@ var Agent = class {
     );
     const wire = toWireDict(envelope);
     const relayUrls = await this._getRelayUrls(toAddress);
+    let answer;
     if (relayUrls !== null && relayUrls.length === 1 && relayUrls[0] === this._config.relayUrl) {
-      await this._transport.send(wire);
+      answer = await this._transport.send(wire);
     } else if (relayUrls !== null && relayUrls.length > 0) {
-      await this._trySendWithFailover(wire, relayUrls);
+      answer = await this._trySendWithFailover(wire, relayUrls);
     } else {
-      await this._transport.send(wire);
+      answer = await this._transport.send(wire);
     }
-    return envelope.messageId;
+    const status = sendStatus(answer);
+    return {
+      messageId: envelope.messageId,
+      status,
+      delivered: status === "delivered"
+    };
   }
   /**
    * Retrieve, decrypt, and verify pending messages.
@@ -2345,43 +3259,43 @@ var Agent = class {
    * Adds the sender to contacts with trust_source='explicit-approval'
    * and sends handshake.accept back.
    */
-  async approve(address) {
+  async approve(address2) {
     await this._ensureConnected();
     const pendingList = this._contactBook.getPending();
-    const entry = pendingList.find((p) => p.address === address);
+    const entry = pendingList.find((p) => p.address === address2);
     if (!entry) {
-      throw new UAMError(`No pending handshake from ${address}`);
+      throw new UAMError(`No pending handshake from ${address2}`);
     }
     const cardDict = JSON.parse(entry.contactCard);
     const card = contactCardFromDict(cardDict);
     verifyContactCard(card);
     const senderVk = deserializeVerifyKey(card.publicKey);
-    bindCardToEnvelope(card, { fromAddress: address }, senderVk);
+    bindCardToEnvelope(card, { fromAddress: address2 }, senderVk);
     this._contactBook.addContact(card.address, card.publicKey, {
       displayName: card.displayName,
       trustState: "trusted",
       trustSource: "explicit-approval"
     });
-    this._contactBook.removePending(address);
-    await this._handshake._sendAccept(this, address, senderVk);
+    this._contactBook.removePending(address2);
+    await this._handshake._sendAccept(this, address2, senderVk);
   }
   /**
    * Deny a pending handshake request.
    *
    * Removes the entry from pending and sends handshake.deny.
    */
-  async deny(address) {
+  async deny(address2) {
     await this._ensureConnected();
     const pendingList = this._contactBook.getPending();
-    const entry = pendingList.find((p) => p.address === address);
+    const entry = pendingList.find((p) => p.address === address2);
     if (!entry) {
-      throw new UAMError(`No pending handshake from ${address}`);
+      throw new UAMError(`No pending handshake from ${address2}`);
     }
     const cardDict = JSON.parse(entry.contactCard);
     const card = contactCardFromDict(cardDict);
     const senderVk = deserializeVerifyKey(card.publicKey);
-    this._contactBook.removePending(address);
-    await this._handshake._sendDeny(this, address, senderVk);
+    this._contactBook.removePending(address2);
+    await this._handshake._sendDeny(this, address2, senderVk);
   }
   /**
    * Block an address or domain pattern (HAND-04).
@@ -2407,7 +3321,7 @@ var Agent = class {
    *
    * Returns `true` if verified, `false` on timeout.
    */
-  async verifyDomain(domain, options) {
+  async verifyDomain(domain2, options) {
     const { generateTxtRecord: generateTxtRecord2 } = await Promise.resolve().then(() => (init_dns_verifier(), dns_verifier_exports));
     await this._ensureConnected();
     const timeout = options?.timeout ?? 3e5;
@@ -2428,7 +3342,7 @@ var Agent = class {
               "Content-Type": "application/json",
               Authorization: `Bearer ${this._token}`
             },
-            body: JSON.stringify({ domain }),
+            body: JSON.stringify({ domain: domain2 }),
             signal: AbortSignal.timeout(3e4)
           }
         );
@@ -2481,7 +3395,7 @@ var Agent = class {
         if (!resp.ok) {
           throw new Error(`HTTP ${resp.status}`);
         }
-        return;
+        return await readAnswer(resp);
       } catch (err) {
         lastError = err instanceof Error ? err : new Error(String(err));
       }
@@ -2779,13 +3693,13 @@ var Agent = class {
     };
     let resp = await this._postRegistration(body);
     if (resp.status === 409) {
-      const address2 = await this._addressOnRelay();
+      const address3 = await this._addressOnRelay();
       resp = await this._postRegistration({
         ...body,
-        proof: this._registrationProof(address2)
+        proof: this._registrationProof(address3)
       });
       if (resp.status === 409 || resp.status === 403) {
-        throw this._ownershipNotProven(address2);
+        throw this._ownershipNotProven(address3);
       }
     }
     if (!resp.ok) {
@@ -2795,26 +3709,26 @@ var Agent = class {
       );
     }
     const data = await resp.json();
-    const address = data["address"];
-    this._useAddress(address);
+    const address2 = data["address"];
+    this._useAddress(address2);
     this._token = data["token"];
     const { name } = this._config;
     const token = this._token;
     this._tryToSave("token", () => this._keyManager.saveToken(name, token));
-    this._saveAddress(address);
+    this._saveAddress(address2);
   }
   /** This agent's address on the relay, for signing a proof. */
   async _addressOnRelay() {
     const { name, explicitRelayDomain, relayDomain, relayUrl } = this._config;
     if (explicitRelayDomain !== null) return `${name}::${explicitRelayDomain}`;
-    const domain = await this._fetchRelayDomain();
-    if (domain === null) return `${name}::${relayDomain}`;
-    if (!this._relayMayUse(domain)) {
+    const domain2 = await this._fetchRelayDomain();
+    if (domain2 === null) return `${name}::${relayDomain}`;
+    if (!this._relayMayUse(domain2)) {
       throw new UAMError(
-        `The relay at ${relayUrl} says its domain is ${domain}. Pass the domain option as ${JSON.stringify(domain)} if that is right.`
+        `The relay at ${relayUrl} says its domain is ${domain2}. Pass the domain option as ${JSON.stringify(domain2)} if that is right.`
       );
     }
-    return `${name}::${domain}`;
+    return `${name}::${domain2}`;
   }
   /**
    * True if the relay's URL fits `domain`, so a proof can be signed for it.
@@ -2822,14 +3736,14 @@ var Agent = class {
    * A proof names an address on one relay, so it is only signed for a domain
    * this URL belongs to. A relay on this machine may use any domain.
    */
-  _relayMayUse(domain) {
+  _relayMayUse(domain2) {
     let host;
     try {
       host = new URL(this._config.relayUrl).hostname.toLowerCase();
     } catch {
       return false;
     }
-    const wanted = domain.toLowerCase();
+    const wanted = domain2.toLowerCase();
     return host === wanted || host.endsWith(`.${wanted}`) || host === "localhost" || host === "[::1]" || /^127\.\d+\.\d+\.\d+$/.test(host);
   }
   _postRegistration(body) {
@@ -2844,27 +3758,27 @@ var Agent = class {
    *
    * The signed string must stay byte-identical to the Python SDK's.
    */
-  _registrationProof(address) {
+  _registrationProof(address2) {
     const timestamp = utcTimestamp();
     const signature = signMessage(
       new TextEncoder().encode(`uam-register-v1
-${address}
+${address2}
 ${timestamp}`),
       this._keyManager.signingKey
     );
     return { timestamp, signature };
   }
-  _ownershipNotProven(address) {
+  _ownershipNotProven(address2) {
     return new UAMError(
-      `Address already registered, and this key could not prove ownership: ` + address
+      `Address already registered, and this key could not prove ownership: ` + address2
     );
   }
   /** Remember `address` for this relay, if the key folder allows it. */
-  _saveAddress(address) {
+  _saveAddress(address2) {
     const { name, relayUrl } = this._config;
     this._tryToSave(
       "address",
-      () => this._keyManager.saveAddress(name, address, relayUrl)
+      () => this._keyManager.saveAddress(name, address2, relayUrl)
     );
   }
   /** Saving is best effort: a key folder we can't write doesn't stop us. */
@@ -2877,12 +3791,12 @@ ${timestamp}`),
     }
   }
   /** Take `address` as ours; its domain is this relay's real domain. */
-  _useAddress(address) {
-    this._address = address;
-    const domain = parseAddress(address).domain;
-    this._config.relayDomain = domain;
+  _useAddress(address2) {
+    this._address = address2;
+    const domain2 = parseAddress(address2).domain;
+    this._config.relayDomain = domain2;
     if (this._resolver instanceof SmartResolver) {
-      this._resolver.relayDomain = domain;
+      this._resolver.relayDomain = domain2;
     }
   }
   /**
@@ -2897,11 +3811,11 @@ ${timestamp}`),
     if (explicitRelayDomain !== null) return `${name}::${explicitRelayDomain}`;
     const saved = this._keyManager.loadAddress(name, this._config.relayUrl);
     if (saved) return saved;
-    const domain = await this._fetchRelayDomain();
-    if (domain === null) return `${name}::${this._config.relayDomain}`;
-    const address = `${name}::${domain}`;
-    this._saveAddress(address);
-    return address;
+    const domain2 = await this._fetchRelayDomain();
+    if (domain2 === null) return `${name}::${this._config.relayDomain}`;
+    const address2 = `${name}::${domain2}`;
+    this._saveAddress(address2);
+    return address2;
   }
   /** Ask the relay for its domain; null if it cannot say. */
   async _fetchRelayDomain() {
@@ -2910,9 +3824,9 @@ ${timestamp}`),
       const resp = await fetch(url, { signal: AbortSignal.timeout(1e4) });
       if (!resp.ok) return null;
       const data = await resp.json();
-      const domain = data["relay_domain"];
-      if (typeof domain !== "string" || domain === "") return null;
-      return parseAddress(`${this._config.name}::${domain}`).domain;
+      const domain2 = data["relay_domain"];
+      if (typeof domain2 !== "string" || domain2 === "") return null;
+      return parseAddress(`${this._config.name}::${domain2}`).domain;
     } catch {
       return null;
     }
@@ -2921,11 +3835,11 @@ ${timestamp}`),
 
 // src/sdk/webhook-verify.ts
 import { createHmac, timingSafeEqual } from "crypto";
-function verifyWebhookSignature(payload, signatureHeader, secret) {
+function verifyWebhookSignature(payload, signatureHeader, secret2) {
   if (!signatureHeader.startsWith("sha256=")) {
     return false;
   }
-  const expected = createHmac("sha256", secret).update(payload).digest("hex");
+  const expected = createHmac("sha256", secret2).update(payload).digest("hex");
   const received = signatureHeader.slice("sha256=".length);
   const expectedBuf = Buffer.from(expected, "utf-8");
   const receivedBuf = Buffer.from(received, "utf-8");
@@ -2940,7 +3854,11 @@ init_dns_verifier();
 export {
   Agent,
   ContactBook,
+  PENDING_NOTE,
+  SEND_STATUSES,
+  pendingNote,
   protocol_exports as protocol,
+  supports,
   verifyWebhookSignature
 };
 //# sourceMappingURL=index.js.map