@formstr/mcp 0.1.1 → 0.3.0

package/dist/index.js

@@ -766,7 +766,7 @@ var require_validation = __commonJS({
 var require_receiver = __commonJS({
   "../../node_modules/.pnpm/ws@8.21.0/node_modules/ws/lib/receiver.js"(exports2, module2) {
     "use strict";
-    var { Writable } = require("stream");
+    var { Writable: Writable2 } = require("stream");
     var PerMessageDeflate2 = require_permessage_deflate();
     var {
       BINARY_TYPES,
@@ -784,7 +784,7 @@ var require_receiver = __commonJS({
     var GET_DATA = 4;
     var INFLATING = 5;
     var DEFER_EVENT = 6;
-    var Receiver2 = class extends Writable {
+    var Receiver2 = class extends Writable2 {
       /**
        * Creates a Receiver instance.
        *
@@ -22056,243 +22056,6 @@ async function validateEvent2(event, url, method, body) {
   return true;
 }
 
-// ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/pbkdf2.js
-function pbkdf2Init(hash, _password, _salt, _opts) {
-  ahash(hash);
-  const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
-  const { c, dkLen, asyncTick } = opts;
-  anumber(c, "c");
-  anumber(dkLen, "dkLen");
-  anumber(asyncTick, "asyncTick");
-  if (c < 1)
-    throw new Error("iterations (c) must be >= 1");
-  const password = kdfInputToBytes(_password, "password");
-  const salt = kdfInputToBytes(_salt, "salt");
-  const DK = new Uint8Array(dkLen);
-  const PRF = hmac.create(hash, password);
-  const PRFSalt = PRF._cloneInto().update(salt);
-  return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
-}
-function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {
-  PRF.destroy();
-  PRFSalt.destroy();
-  if (prfW)
-    prfW.destroy();
-  clean(u);
-  return DK;
-}
-function pbkdf2(hash, password, salt, opts) {
-  const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
-  let prfW;
-  const arr = new Uint8Array(4);
-  const view = createView(arr);
-  const u = new Uint8Array(PRF.outputLen);
-  for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
-    const Ti = DK.subarray(pos, pos + PRF.outputLen);
-    view.setInt32(0, ti, false);
-    (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
-    Ti.set(u.subarray(0, Ti.length));
-    for (let ui = 1; ui < c; ui++) {
-      PRF._cloneInto(prfW).update(u).digestInto(u);
-      for (let i4 = 0; i4 < Ti.length; i4++)
-        Ti[i4] ^= u[i4];
-    }
-  }
-  return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
-}
-
-// ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/scrypt.js
-function XorAndSalsa(prev, pi, input, ii, out, oi) {
-  let y00 = prev[pi++] ^ input[ii++], y01 = prev[pi++] ^ input[ii++];
-  let y02 = prev[pi++] ^ input[ii++], y03 = prev[pi++] ^ input[ii++];
-  let y04 = prev[pi++] ^ input[ii++], y05 = prev[pi++] ^ input[ii++];
-  let y06 = prev[pi++] ^ input[ii++], y07 = prev[pi++] ^ input[ii++];
-  let y08 = prev[pi++] ^ input[ii++], y09 = prev[pi++] ^ input[ii++];
-  let y10 = prev[pi++] ^ input[ii++], y11 = prev[pi++] ^ input[ii++];
-  let y12 = prev[pi++] ^ input[ii++], y13 = prev[pi++] ^ input[ii++];
-  let y14 = prev[pi++] ^ input[ii++], y15 = prev[pi++] ^ input[ii++];
-  let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;
-  for (let i4 = 0; i4 < 8; i4 += 2) {
-    x04 ^= rotl(x00 + x12 | 0, 7);
-    x08 ^= rotl(x04 + x00 | 0, 9);
-    x12 ^= rotl(x08 + x04 | 0, 13);
-    x00 ^= rotl(x12 + x08 | 0, 18);
-    x09 ^= rotl(x05 + x01 | 0, 7);
-    x13 ^= rotl(x09 + x05 | 0, 9);
-    x01 ^= rotl(x13 + x09 | 0, 13);
-    x05 ^= rotl(x01 + x13 | 0, 18);
-    x14 ^= rotl(x10 + x06 | 0, 7);
-    x02 ^= rotl(x14 + x10 | 0, 9);
-    x06 ^= rotl(x02 + x14 | 0, 13);
-    x10 ^= rotl(x06 + x02 | 0, 18);
-    x03 ^= rotl(x15 + x11 | 0, 7);
-    x07 ^= rotl(x03 + x15 | 0, 9);
-    x11 ^= rotl(x07 + x03 | 0, 13);
-    x15 ^= rotl(x11 + x07 | 0, 18);
-    x01 ^= rotl(x00 + x03 | 0, 7);
-    x02 ^= rotl(x01 + x00 | 0, 9);
-    x03 ^= rotl(x02 + x01 | 0, 13);
-    x00 ^= rotl(x03 + x02 | 0, 18);
-    x06 ^= rotl(x05 + x04 | 0, 7);
-    x07 ^= rotl(x06 + x05 | 0, 9);
-    x04 ^= rotl(x07 + x06 | 0, 13);
-    x05 ^= rotl(x04 + x07 | 0, 18);
-    x11 ^= rotl(x10 + x09 | 0, 7);
-    x08 ^= rotl(x11 + x10 | 0, 9);
-    x09 ^= rotl(x08 + x11 | 0, 13);
-    x10 ^= rotl(x09 + x08 | 0, 18);
-    x12 ^= rotl(x15 + x14 | 0, 7);
-    x13 ^= rotl(x12 + x15 | 0, 9);
-    x14 ^= rotl(x13 + x12 | 0, 13);
-    x15 ^= rotl(x14 + x13 | 0, 18);
-  }
-  out[oi++] = y00 + x00 | 0;
-  out[oi++] = y01 + x01 | 0;
-  out[oi++] = y02 + x02 | 0;
-  out[oi++] = y03 + x03 | 0;
-  out[oi++] = y04 + x04 | 0;
-  out[oi++] = y05 + x05 | 0;
-  out[oi++] = y06 + x06 | 0;
-  out[oi++] = y07 + x07 | 0;
-  out[oi++] = y08 + x08 | 0;
-  out[oi++] = y09 + x09 | 0;
-  out[oi++] = y10 + x10 | 0;
-  out[oi++] = y11 + x11 | 0;
-  out[oi++] = y12 + x12 | 0;
-  out[oi++] = y13 + x13 | 0;
-  out[oi++] = y14 + x14 | 0;
-  out[oi++] = y15 + x15 | 0;
-}
-function BlockMix(input, ii, out, oi, r) {
-  let head = oi + 0;
-  let tail = oi + 16 * r;
-  for (let i4 = 0; i4 < 16; i4++)
-    out[tail + i4] = input[ii + (2 * r - 1) * 16 + i4];
-  for (let i4 = 0; i4 < r; i4++, head += 16, ii += 16) {
-    XorAndSalsa(out, tail, input, ii, out, head);
-    if (i4 > 0)
-      tail += 16;
-    XorAndSalsa(out, head, input, ii += 16, out, tail);
-  }
-}
-function scryptInit(password, salt, _opts) {
-  const opts = checkOpts({
-    dkLen: 32,
-    asyncTick: 10,
-    maxmem: 1024 ** 3 + 1024
-  }, _opts);
-  const { N, r, p, dkLen, asyncTick, maxmem, onProgress } = opts;
-  anumber(N, "N");
-  anumber(r, "r");
-  anumber(p, "p");
-  anumber(dkLen, "dkLen");
-  anumber(asyncTick, "asyncTick");
-  anumber(maxmem, "maxmem");
-  if (onProgress !== void 0 && typeof onProgress !== "function")
-    throw new Error("progressCb must be a function");
-  const blockSize = 128 * r;
-  const blockSize32 = blockSize / 4;
-  const pow32 = Math.pow(2, 32);
-  if (N <= 1 || (N & N - 1) !== 0 || N > pow32)
-    throw new Error('"N" expected a power of 2, and 2^1 <= N <= 2^32');
-  if (p < 1 || p > (pow32 - 1) * 32 / blockSize)
-    throw new Error('"p" expected integer 1..((2^32 - 1) * 32) / (128 * r)');
-  if (dkLen < 1 || dkLen > (pow32 - 1) * 32)
-    throw new Error('"dkLen" expected integer 1..(2^32 - 1) * 32');
-  const memUsed = blockSize * (N + p);
-  if (memUsed > maxmem)
-    throw new Error('"maxmem" limit was hit, expected 128*r*(N+p) <= "maxmem"=' + maxmem);
-  const B = pbkdf2(sha256, password, salt, { c: 1, dkLen: blockSize * p });
-  const B32 = u32(B);
-  const V = u32(new Uint8Array(blockSize * N));
-  const tmp = u32(new Uint8Array(blockSize));
-  let blockMixCb = () => {
-  };
-  if (onProgress) {
-    const totalBlockMix = 2 * N * p;
-    const callbackPer = Math.max(Math.floor(totalBlockMix / 1e4), 1);
-    let blockMixCnt = 0;
-    blockMixCb = () => {
-      blockMixCnt++;
-      if (onProgress && (!(blockMixCnt % callbackPer) || blockMixCnt === totalBlockMix))
-        onProgress(blockMixCnt / totalBlockMix);
-    };
-  }
-  return { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb, asyncTick };
-}
-function scryptOutput(password, dkLen, B, V, tmp) {
-  const res = pbkdf2(sha256, password, B, { c: 1, dkLen });
-  clean(B, V, tmp);
-  return res;
-}
-function scrypt(password, salt, opts) {
-  const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb } = scryptInit(password, salt, opts);
-  swap32IfBE(B32);
-  for (let pi = 0; pi < p; pi++) {
-    const Pi = blockSize32 * pi;
-    for (let i4 = 0; i4 < blockSize32; i4++)
-      V[i4] = B32[Pi + i4];
-    for (let i4 = 0, pos = 0; i4 < N - 1; i4++) {
-      BlockMix(V, pos, V, pos += blockSize32, r);
-      blockMixCb();
-    }
-    BlockMix(V, (N - 1) * blockSize32, B32, Pi, r);
-    blockMixCb();
-    for (let i4 = 0; i4 < N; i4++) {
-      const j = (B32[Pi + blockSize32 - 16] & N - 1) >>> 0;
-      for (let k = 0; k < blockSize32; k++)
-        tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k];
-      BlockMix(tmp, 0, B32, Pi, r);
-      blockMixCb();
-    }
-  }
-  swap32IfBE(B32);
-  return scryptOutput(password, dkLen, B, V, tmp);
-}
-
-// ../../node_modules/.pnpm/nostr-tools@2.23.3_typescript@5.9.3/node_modules/nostr-tools/lib/esm/nip49.js
-var Bech32MaxSize2 = 5e3;
-function encodeBech322(prefix, data) {
-  let words = bech32.toWords(data);
-  return bech32.encode(prefix, words, Bech32MaxSize2);
-}
-function encodeBytes2(prefix, bytes) {
-  return encodeBech322(prefix, bytes);
-}
-function encrypt3(sec, password, logn = 16, ksb = 2) {
-  let salt = randomBytes(16);
-  let n = 2 ** logn;
-  let key = scrypt(password.normalize("NFKC"), salt, { N: n, r: 8, p: 1, dkLen: 32 });
-  let nonce = randomBytes(24);
-  let aad = Uint8Array.from([ksb]);
-  let xc2p1 = xchacha20poly1305(key, nonce, aad);
-  let ciphertext = xc2p1.encrypt(sec);
-  let b = concatBytes(Uint8Array.from([2]), Uint8Array.from([logn]), salt, nonce, aad, ciphertext);
-  return encodeBytes2("ncryptsec", b);
-}
-function decrypt3(ncryptsec, password) {
-  let { prefix, words } = bech32.decode(ncryptsec, Bech32MaxSize2);
-  if (prefix !== "ncryptsec") {
-    throw new Error(`invalid prefix ${prefix}, expected 'ncryptsec'`);
-  }
-  let b = new Uint8Array(bech32.fromWords(words));
-  let version2 = b[0];
-  if (version2 !== 2) {
-    throw new Error(`invalid version ${version2}, expected 0x02`);
-  }
-  let logn = b[1];
-  let n = 2 ** logn;
-  let salt = b.slice(2, 2 + 16);
-  let nonce = b.slice(2 + 16, 2 + 16 + 24);
-  let ksb = b[2 + 16 + 24];
-  let aad = Uint8Array.from([ksb]);
-  let ciphertext = b.slice(2 + 16 + 24 + 1);
-  let key = scrypt(password.normalize("NFKC"), salt, { N: n, r: 8, p: 1, dkLen: 32 });
-  let xc2p1 = xchacha20poly1305(key, nonce, aad);
-  let sec = xc2p1.decrypt(ciphertext);
-  return sec;
-}
-
 // ../../node_modules/.pnpm/nostr-tools@2.23.3_typescript@5.9.3/node_modules/nostr-tools/lib/esm/nip46.js
 var verifiedSymbol2 = /* @__PURE__ */ Symbol("verified");
 var isRecord2 = (obj) => obj instanceof Object;
@@ -22468,14 +22231,14 @@ function decodePayload2(payload) {
     mac: data.subarray(-32)
   };
 }
-function encrypt4(plaintext, conversationKey, nonce = randomBytes(32)) {
+function encrypt3(plaintext, conversationKey, nonce = randomBytes(32)) {
   const { chacha_key, chacha_nonce, hmac_key } = getMessageKeys2(conversationKey, nonce);
   const padded = pad2(plaintext);
   const ciphertext = chacha20(chacha_key, chacha_nonce, padded);
   const mac = hmacAad2(hmac_key, ciphertext, nonce);
   return base64.encode(concatBytes(new Uint8Array([2]), nonce, ciphertext, mac));
 }
-function decrypt4(payload, conversationKey) {
+function decrypt3(payload, conversationKey) {
   const { nonce, ciphertext, mac } = decodePayload2(payload);
   const { chacha_key, chacha_nonce, hmac_key } = getMessageKeys2(conversationKey, nonce);
   const calculatedMac = hmacAad2(hmac_key, ciphertext, nonce);
@@ -23426,7 +23189,7 @@ var BunkerSigner = class {
           onevent: async (event) => {
             try {
               const tempConvKey = getConversationKey2(clientSecretKey, event.pubkey);
-              const decryptedContent = decrypt4(event.content, tempConvKey);
+              const decryptedContent = decrypt3(event.content, tempConvKey);
               const response = JSON.parse(decryptedContent);
               if (response.result === uri.searchParams.get("secret")) {
                 sub.close();
@@ -23469,7 +23232,7 @@ var BunkerSigner = class {
       },
       {
         onevent: async (event) => {
-          const o = JSON.parse(decrypt4(event.content, convKey));
+          const o = JSON.parse(decrypt3(event.content, convKey));
           const { id, result, error: error2 } = o;
           if (result === "auth_url" && waitingForAuth[id]) {
             delete waitingForAuth[id];
@@ -23531,7 +23294,7 @@ var BunkerSigner = class {
           this.setupSubscription();
         this.serial++;
         const id = `${this.idPrefix}-${this.serial}`;
-        const encryptedContent = encrypt4(JSON.stringify({ id, method, params }), this.conversationKey);
+        const encryptedContent = encrypt3(JSON.stringify({ id, method, params }), this.conversationKey);
         const verifiedEvent = finalizeEvent2(
           {
             kind: NostrConnect2,
@@ -23586,7 +23349,244 @@ var BunkerSigner = class {
   }
 };
 
-// ../../node_modules/.pnpm/@formstr+signer@0.1.0_typescript@5.9.3/node_modules/@formstr/signer/dist/index.js
+// ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/pbkdf2.js
+function pbkdf2Init(hash, _password, _salt, _opts) {
+  ahash(hash);
+  const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
+  const { c, dkLen, asyncTick } = opts;
+  anumber(c, "c");
+  anumber(dkLen, "dkLen");
+  anumber(asyncTick, "asyncTick");
+  if (c < 1)
+    throw new Error("iterations (c) must be >= 1");
+  const password = kdfInputToBytes(_password, "password");
+  const salt = kdfInputToBytes(_salt, "salt");
+  const DK = new Uint8Array(dkLen);
+  const PRF = hmac.create(hash, password);
+  const PRFSalt = PRF._cloneInto().update(salt);
+  return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
+}
+function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {
+  PRF.destroy();
+  PRFSalt.destroy();
+  if (prfW)
+    prfW.destroy();
+  clean(u);
+  return DK;
+}
+function pbkdf2(hash, password, salt, opts) {
+  const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
+  let prfW;
+  const arr = new Uint8Array(4);
+  const view = createView(arr);
+  const u = new Uint8Array(PRF.outputLen);
+  for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
+    const Ti = DK.subarray(pos, pos + PRF.outputLen);
+    view.setInt32(0, ti, false);
+    (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
+    Ti.set(u.subarray(0, Ti.length));
+    for (let ui = 1; ui < c; ui++) {
+      PRF._cloneInto(prfW).update(u).digestInto(u);
+      for (let i4 = 0; i4 < Ti.length; i4++)
+        Ti[i4] ^= u[i4];
+    }
+  }
+  return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
+}
+
+// ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/scrypt.js
+function XorAndSalsa(prev, pi, input, ii, out, oi) {
+  let y00 = prev[pi++] ^ input[ii++], y01 = prev[pi++] ^ input[ii++];
+  let y02 = prev[pi++] ^ input[ii++], y03 = prev[pi++] ^ input[ii++];
+  let y04 = prev[pi++] ^ input[ii++], y05 = prev[pi++] ^ input[ii++];
+  let y06 = prev[pi++] ^ input[ii++], y07 = prev[pi++] ^ input[ii++];
+  let y08 = prev[pi++] ^ input[ii++], y09 = prev[pi++] ^ input[ii++];
+  let y10 = prev[pi++] ^ input[ii++], y11 = prev[pi++] ^ input[ii++];
+  let y12 = prev[pi++] ^ input[ii++], y13 = prev[pi++] ^ input[ii++];
+  let y14 = prev[pi++] ^ input[ii++], y15 = prev[pi++] ^ input[ii++];
+  let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;
+  for (let i4 = 0; i4 < 8; i4 += 2) {
+    x04 ^= rotl(x00 + x12 | 0, 7);
+    x08 ^= rotl(x04 + x00 | 0, 9);
+    x12 ^= rotl(x08 + x04 | 0, 13);
+    x00 ^= rotl(x12 + x08 | 0, 18);
+    x09 ^= rotl(x05 + x01 | 0, 7);
+    x13 ^= rotl(x09 + x05 | 0, 9);
+    x01 ^= rotl(x13 + x09 | 0, 13);
+    x05 ^= rotl(x01 + x13 | 0, 18);
+    x14 ^= rotl(x10 + x06 | 0, 7);
+    x02 ^= rotl(x14 + x10 | 0, 9);
+    x06 ^= rotl(x02 + x14 | 0, 13);
+    x10 ^= rotl(x06 + x02 | 0, 18);
+    x03 ^= rotl(x15 + x11 | 0, 7);
+    x07 ^= rotl(x03 + x15 | 0, 9);
+    x11 ^= rotl(x07 + x03 | 0, 13);
+    x15 ^= rotl(x11 + x07 | 0, 18);
+    x01 ^= rotl(x00 + x03 | 0, 7);
+    x02 ^= rotl(x01 + x00 | 0, 9);
+    x03 ^= rotl(x02 + x01 | 0, 13);
+    x00 ^= rotl(x03 + x02 | 0, 18);
+    x06 ^= rotl(x05 + x04 | 0, 7);
+    x07 ^= rotl(x06 + x05 | 0, 9);
+    x04 ^= rotl(x07 + x06 | 0, 13);
+    x05 ^= rotl(x04 + x07 | 0, 18);
+    x11 ^= rotl(x10 + x09 | 0, 7);
+    x08 ^= rotl(x11 + x10 | 0, 9);
+    x09 ^= rotl(x08 + x11 | 0, 13);
+    x10 ^= rotl(x09 + x08 | 0, 18);
+    x12 ^= rotl(x15 + x14 | 0, 7);
+    x13 ^= rotl(x12 + x15 | 0, 9);
+    x14 ^= rotl(x13 + x12 | 0, 13);
+    x15 ^= rotl(x14 + x13 | 0, 18);
+  }
+  out[oi++] = y00 + x00 | 0;
+  out[oi++] = y01 + x01 | 0;
+  out[oi++] = y02 + x02 | 0;
+  out[oi++] = y03 + x03 | 0;
+  out[oi++] = y04 + x04 | 0;
+  out[oi++] = y05 + x05 | 0;
+  out[oi++] = y06 + x06 | 0;
+  out[oi++] = y07 + x07 | 0;
+  out[oi++] = y08 + x08 | 0;
+  out[oi++] = y09 + x09 | 0;
+  out[oi++] = y10 + x10 | 0;
+  out[oi++] = y11 + x11 | 0;
+  out[oi++] = y12 + x12 | 0;
+  out[oi++] = y13 + x13 | 0;
+  out[oi++] = y14 + x14 | 0;
+  out[oi++] = y15 + x15 | 0;
+}
+function BlockMix(input, ii, out, oi, r) {
+  let head = oi + 0;
+  let tail = oi + 16 * r;
+  for (let i4 = 0; i4 < 16; i4++)
+    out[tail + i4] = input[ii + (2 * r - 1) * 16 + i4];
+  for (let i4 = 0; i4 < r; i4++, head += 16, ii += 16) {
+    XorAndSalsa(out, tail, input, ii, out, head);
+    if (i4 > 0)
+      tail += 16;
+    XorAndSalsa(out, head, input, ii += 16, out, tail);
+  }
+}
+function scryptInit(password, salt, _opts) {
+  const opts = checkOpts({
+    dkLen: 32,
+    asyncTick: 10,
+    maxmem: 1024 ** 3 + 1024
+  }, _opts);
+  const { N, r, p, dkLen, asyncTick, maxmem, onProgress } = opts;
+  anumber(N, "N");
+  anumber(r, "r");
+  anumber(p, "p");
+  anumber(dkLen, "dkLen");
+  anumber(asyncTick, "asyncTick");
+  anumber(maxmem, "maxmem");
+  if (onProgress !== void 0 && typeof onProgress !== "function")
+    throw new Error("progressCb must be a function");
+  const blockSize = 128 * r;
+  const blockSize32 = blockSize / 4;
+  const pow32 = Math.pow(2, 32);
+  if (N <= 1 || (N & N - 1) !== 0 || N > pow32)
+    throw new Error('"N" expected a power of 2, and 2^1 <= N <= 2^32');
+  if (p < 1 || p > (pow32 - 1) * 32 / blockSize)
+    throw new Error('"p" expected integer 1..((2^32 - 1) * 32) / (128 * r)');
+  if (dkLen < 1 || dkLen > (pow32 - 1) * 32)
+    throw new Error('"dkLen" expected integer 1..(2^32 - 1) * 32');
+  const memUsed = blockSize * (N + p);
+  if (memUsed > maxmem)
+    throw new Error('"maxmem" limit was hit, expected 128*r*(N+p) <= "maxmem"=' + maxmem);
+  const B = pbkdf2(sha256, password, salt, { c: 1, dkLen: blockSize * p });
+  const B32 = u32(B);
+  const V = u32(new Uint8Array(blockSize * N));
+  const tmp = u32(new Uint8Array(blockSize));
+  let blockMixCb = () => {
+  };
+  if (onProgress) {
+    const totalBlockMix = 2 * N * p;
+    const callbackPer = Math.max(Math.floor(totalBlockMix / 1e4), 1);
+    let blockMixCnt = 0;
+    blockMixCb = () => {
+      blockMixCnt++;
+      if (onProgress && (!(blockMixCnt % callbackPer) || blockMixCnt === totalBlockMix))
+        onProgress(blockMixCnt / totalBlockMix);
+    };
+  }
+  return { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb, asyncTick };
+}
+function scryptOutput(password, dkLen, B, V, tmp) {
+  const res = pbkdf2(sha256, password, B, { c: 1, dkLen });
+  clean(B, V, tmp);
+  return res;
+}
+function scrypt(password, salt, opts) {
+  const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb } = scryptInit(password, salt, opts);
+  swap32IfBE(B32);
+  for (let pi = 0; pi < p; pi++) {
+    const Pi = blockSize32 * pi;
+    for (let i4 = 0; i4 < blockSize32; i4++)
+      V[i4] = B32[Pi + i4];
+    for (let i4 = 0, pos = 0; i4 < N - 1; i4++) {
+      BlockMix(V, pos, V, pos += blockSize32, r);
+      blockMixCb();
+    }
+    BlockMix(V, (N - 1) * blockSize32, B32, Pi, r);
+    blockMixCb();
+    for (let i4 = 0; i4 < N; i4++) {
+      const j = (B32[Pi + blockSize32 - 16] & N - 1) >>> 0;
+      for (let k = 0; k < blockSize32; k++)
+        tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k];
+      BlockMix(tmp, 0, B32, Pi, r);
+      blockMixCb();
+    }
+  }
+  swap32IfBE(B32);
+  return scryptOutput(password, dkLen, B, V, tmp);
+}
+
+// ../../node_modules/.pnpm/nostr-tools@2.23.3_typescript@5.9.3/node_modules/nostr-tools/lib/esm/nip49.js
+var Bech32MaxSize2 = 5e3;
+function encodeBech322(prefix, data) {
+  let words = bech32.toWords(data);
+  return bech32.encode(prefix, words, Bech32MaxSize2);
+}
+function encodeBytes2(prefix, bytes) {
+  return encodeBech322(prefix, bytes);
+}
+function encrypt4(sec, password, logn = 16, ksb = 2) {
+  let salt = randomBytes(16);
+  let n = 2 ** logn;
+  let key = scrypt(password.normalize("NFKC"), salt, { N: n, r: 8, p: 1, dkLen: 32 });
+  let nonce = randomBytes(24);
+  let aad = Uint8Array.from([ksb]);
+  let xc2p1 = xchacha20poly1305(key, nonce, aad);
+  let ciphertext = xc2p1.encrypt(sec);
+  let b = concatBytes(Uint8Array.from([2]), Uint8Array.from([logn]), salt, nonce, aad, ciphertext);
+  return encodeBytes2("ncryptsec", b);
+}
+function decrypt4(ncryptsec, password) {
+  let { prefix, words } = bech32.decode(ncryptsec, Bech32MaxSize2);
+  if (prefix !== "ncryptsec") {
+    throw new Error(`invalid prefix ${prefix}, expected 'ncryptsec'`);
+  }
+  let b = new Uint8Array(bech32.fromWords(words));
+  let version2 = b[0];
+  if (version2 !== 2) {
+    throw new Error(`invalid version ${version2}, expected 0x02`);
+  }
+  let logn = b[1];
+  let n = 2 ** logn;
+  let salt = b.slice(2, 2 + 16);
+  let nonce = b.slice(2 + 16, 2 + 16 + 24);
+  let ksb = b[2 + 16 + 24];
+  let aad = Uint8Array.from([ksb]);
+  let ciphertext = b.slice(2 + 16 + 24 + 1);
+  let key = scrypt(password.normalize("NFKC"), salt, { N: n, r: 8, p: 1, dkLen: 32 });
+  let xc2p1 = xchacha20poly1305(key, nonce, aad);
+  let sec = xc2p1.decrypt(ciphertext);
+  return sec;
+}
+
+// ../../node_modules/.pnpm/@formstr+signer@0.2.2_typescript@5.9.3/node_modules/@formstr/signer/dist/index.js
 var DEFAULT_PREFIX = "@formstr/signer:";
 function localStorageAdapter(prefix = DEFAULT_PREFIX) {
   const ls = () => {
@@ -23645,16 +23645,16 @@ var LocalSigner = class {
   }
 };
 function encryptSecretKey(secretKey, passphrase) {
-  return encrypt3(secretKey, passphrase);
+  return encrypt4(secretKey, passphrase);
 }
 function decryptNcryptsec(ncryptsec, passphrase) {
-  return decrypt3(ncryptsec, passphrase);
+  return decrypt4(ncryptsec, passphrase);
 }
 function generateAccount(passphrase) {
   const secretKey = generateSecretKey();
   const pubkey = getPublicKey(secretKey);
   const npub2 = nip19_exports.npubEncode(pubkey);
-  const ncryptsec = encrypt3(secretKey, passphrase);
+  const ncryptsec = encrypt4(secretKey, passphrase);
   return { secretKey, pubkey, npub: npub2, ncryptsec };
 }
 function getWindowNostr() {
@@ -23696,10 +23696,15 @@ var ExtensionSigner = class {
 };
 var BunkerSigner2 = class {
   #delegate;
-  constructor(delegate) {
+  #cachedUserPubkey;
+  constructor(delegate, cachedUserPubkey) {
     this.#delegate = delegate;
+    this.#cachedUserPubkey = cachedUserPubkey ?? null;
   }
   getPublicKey() {
+    if (this.#cachedUserPubkey !== null) {
+      return Promise.resolve(this.#cachedUserPubkey);
+    }
     return this.#delegate.getPublicKey();
   }
   signEvent(event) {
@@ -23775,7 +23780,7 @@ async function connectWithBunkerUri(uri, options = {}) {
     options.onRelayMismatch
   );
   return {
-    signer: new BunkerSigner2(tools),
+    signer: new BunkerSigner2(tools, pubkey),
     pubkey,
     pointer: { ...pointer, relays: resolvedRelays },
     clientSecretKey
@@ -23811,7 +23816,7 @@ function initiateNostrConnect(options) {
       options.onRelayMismatch
     );
     return {
-      signer: new BunkerSigner2(tools),
+      signer: new BunkerSigner2(tools, pubkey),
       pubkey,
       pointer: { ...tools.bp, relays: resolvedRelays },
       clientSecretKey
@@ -23899,28 +23904,57 @@ var AndroidSigner = class {
     return result;
   }
 };
+function describeIdentifier(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value !== "string") {
+    return `<${typeof value}>`;
+  }
+  if (value.length === 0) return "empty string";
+  const prefix = value.slice(0, 12);
+  const suffix = value.length > 12 ? "\u2026" : "";
+  return `"${prefix}${suffix}" (length=${value.length})`;
+}
+var HEX_PUBKEY_RE = /^[0-9a-f]{64}$/i;
 async function loginWithAndroidSigner(plugin, packageName) {
   if (packageName) {
     await plugin.setPackageName(packageName);
   }
-  const { npub: npub2, package: pluginPackage } = await plugin.getPublicKey(packageName);
+  const { npub: rawIdentifier, package: pluginPackage } = await plugin.getPublicKey(packageName);
   const resolvedPackage = pluginPackage || packageName;
   if (!resolvedPackage) {
     throw new Error(
       "@formstr/signer: android signer did not return a package name and none was supplied"
     );
   }
-  const decoded = nip19_exports.decode(npub2);
-  if (decoded.type !== "npub") {
-    throw new Error("@formstr/signer: android signer returned a non-npub identifier");
-  }
+  const { pubkey, npub: npub2 } = normalizeAndroidIdentifier(rawIdentifier);
   return {
-    signer: new AndroidSigner(plugin, resolvedPackage, npub2, decoded.data),
-    pubkey: decoded.data,
+    signer: new AndroidSigner(plugin, resolvedPackage, npub2, pubkey),
+    pubkey,
     npub: npub2,
     packageName: resolvedPackage
   };
 }
+function normalizeAndroidIdentifier(rawIdentifier) {
+  if (typeof rawIdentifier === "string" && HEX_PUBKEY_RE.test(rawIdentifier)) {
+    const pubkey = rawIdentifier.toLowerCase();
+    return { pubkey, npub: nip19_exports.npubEncode(pubkey) };
+  }
+  let decoded;
+  try {
+    decoded = nip19_exports.decode(rawIdentifier);
+  } catch (e) {
+    throw new Error(
+      `@formstr/signer: android signer returned an undecodable identifier (got ${describeIdentifier(rawIdentifier)}): ${e.message}`
+    );
+  }
+  if (decoded.type !== "npub") {
+    throw new Error(
+      `@formstr/signer: android signer returned a non-npub identifier (type=${decoded.type}, got ${describeIdentifier(rawIdentifier)})`
+    );
+  }
+  return { pubkey: decoded.data, npub: rawIdentifier };
+}
 var ACCOUNTS_KEY = "accounts";
 var ACTIVE_KEY = "active-pubkey";
 var Signer = class {
@@ -24183,6 +24217,88 @@ var Signer = class {
   getActiveSigner() {
     return this.#activeSigner;
   }
+  /**
+   * Silently unlock the active account from persisted state — no user
+   * prompt, no fresh pairing. The package already keeps everything it
+   * needs to reconstruct the runtime signer on disk; this method is the
+   * way to actually use that on cold start instead of re-running each
+   * method's first-time login flow.
+   *
+   * Behavior by method:
+   *
+   *  - `extension`: constructs an {@link ExtensionSigner}, which just
+   *    proxies to `window.nostr`. No setup roundtrip — individual
+   *    operations may still prompt depending on the extension's own
+   *    permission state, but unlock itself does not.
+   *
+   *  - `nip46`: reuses the stored `clientSecretKey` to construct a
+   *    {@link BunkerSigner} against the stored bunker pubkey + relays
+   *    via `BunkerSigner.fromBunker`. Deliberately skips the `connect`
+   *    request — the remote signer (Amber etc.) approved this client
+   *    pubkey on first pairing and re-sending `connect` is what surfaces
+   *    a fresh approval prompt every cold start. Requires `options.pool`
+   *    so the BunkerSigner has somewhere to listen for responses.
+   *    The cached user pubkey is fed into the wrapper so a follow-up
+   *    `getPublicKey()` is a memory read, not a relay request.
+   *
+   *  - `android`: constructs an {@link AndroidSigner} directly from the
+   *    stored `androidPackageName` + `pubkey` + `npub`. Skips the
+   *    `getPublicKey` content-provider roundtrip that
+   *    {@link loginWithAndroidSigner} performs and that — on Amber —
+   *    surfaces as a permission prompt every cold start.
+   *
+   *  - `ncryptsec`: returns `null`. There is no silent path — the user's
+   *    passphrase isn't (and shouldn't be) persisted. The caller must
+   *    drive the passphrase prompt and call {@link loginWithNcryptsec}.
+   *
+   * Returns `null` (without emitting any event or mutating state) when
+   * there is no active account, when the account is missing fields
+   * required to unlock, when `nip46` is the method but no `pool` was
+   * supplied, or when `android` is the method but no plugin is
+   * configured. On success emits the same `login` / `switch` event the
+   * corresponding `loginWith*` would.
+   */
+  async unlock(options = {}) {
+    const account = this.getActiveAccount();
+    if (!account) return null;
+    switch (account.method) {
+      case "extension": {
+        const signer = new ExtensionSigner();
+        this.#setActive(account, signer);
+        return signer;
+      }
+      case "nip46": {
+        if (!account.nip46) return null;
+        if (!options.pool) return null;
+        const { remoteSignerPubkey, relays, clientSecretKey } = account.nip46;
+        if (!remoteSignerPubkey || !relays.length || !clientSecretKey) {
+          return null;
+        }
+        const tools = BunkerSigner.fromBunker(
+          hexToBytes2(clientSecretKey),
+          { pubkey: remoteSignerPubkey, relays, secret: null },
+          { pool: options.pool }
+        );
+        const signer = new BunkerSigner2(tools, account.pubkey);
+        this.#setActive(account, signer);
+        return signer;
+      }
+      case "android": {
+        if (!account.androidPackageName) return null;
+        if (!this.#defaultAndroidPlugin) return null;
+        const signer = new AndroidSigner(
+          this.#defaultAndroidPlugin,
+          account.androidPackageName,
+          account.npub,
+          account.pubkey
+        );
+        this.#setActive(account, signer);
+        return signer;
+      }
+      case "ncryptsec":
+        return null;
+    }
+  }
   /**
    * Make `pubkey` the active account. Clears the in-memory signer —
    * the new account starts **locked** even if it was previously
@@ -24289,7 +24405,26 @@ async function loginImport(deps) {
 }
 async function loginBunker(deps) {
   const uri = (await deps.prompt("Paste the bunker:// URI: ")).trim();
-  await deps.signer.loginWithBunkerUri(uri, { pool: deps.pool, perms: NIP46_PERMS });
+  try {
+    await deps.signer.loginWithBunkerUri(uri, { pool: deps.pool, perms: NIP46_PERMS });
+  } catch (err) {
+    throw new Error(describeBunkerError(uri, err));
+  }
+}
+function describeBunkerError(uri, err) {
+  const raw = err instanceof Error ? err.message : String(err);
+  const hasSecret = /[?&]secret=/.test(uri);
+  const expected = "`bunker://<pubkey>?relay=wss://\u2026&secret=<token>`";
+  if (/no secret/i.test(raw) || !hasSecret) {
+    return "Could not pair with this bunker URI" + (hasSecret ? "" : " \u2014 it has no `secret=` token") + `, so the remote signer rejected the connection. A pairing URI must look like ${expected}. Copy the FULL connection URI (including \`&secret=\u2026\`) from your signer app (e.g. nsec.app \u2192 Connect app), and make sure nothing was truncated \u2014 the secret is often one-time, so generate a fresh connection if needed. Or use the QR flow: \`formstr-mcp login\` \u2192 \`q\`. (signer reported: ${raw})`;
+  }
+  if (/invalid bunker uri/i.test(raw)) {
+    return `That doesn't look like a valid bunker URI. Expected ${expected}. (parser reported: ${raw})`;
+  }
+  if (/at least one relay/i.test(raw)) {
+    return `This bunker URI has no relays. Expected ${expected}. (reported: ${raw})`;
+  }
+  return `Bunker login failed: ${raw}. Check that the URI includes a \`secret=\` token and at least one \`relay=\`, that the remote signer is online, or try the QR flow (\`formstr-mcp login\` \u2192 \`q\`).`;
 }
 async function loginNostrConnect(deps, log) {
   const relays = deps.relays?.length ? deps.relays : DEFAULT_NOSTRCONNECT_RELAYS;
@@ -24310,6 +24445,19 @@ function whoami(signer) {
 function listAccounts(signer) {
   return signer.listAccounts();
 }
+function findAccount(accounts, target) {
+  return accounts.find((a) => a.npub === target || a.pubkey === target) ?? null;
+}
+async function doSwitch(signer, target) {
+  const match = findAccount(listAccounts(signer), target);
+  if (!match) {
+    throw new Error(
+      `No stored account matching "${target}". Run \`formstr-mcp accounts\` to list them.`
+    );
+  }
+  await signer.switchAccount(match.pubkey);
+  return match;
+}
 
 // src/auth/kvStore.ts
 var import_node_crypto = require("crypto");
@@ -25400,25 +25548,39 @@ function createPatchedPool() {
 
 // src/auth/terminal.ts
 var readline = __toESM(require("readline"));
+var import_node_stream = require("stream");
 var import_qrcode = __toESM(require_lib());
 function createTerminalIo() {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  const stderr = process.stderr;
+  let muted = false;
+  const output = new import_node_stream.Writable({
+    write(chunk, _enc, cb) {
+      if (!muted) stderr.write(chunk);
+      cb();
+    }
+  });
+  Object.defineProperties(output, {
+    isTTY: { get: () => stderr.isTTY },
+    columns: { get: () => stderr.columns },
+    rows: { get: () => stderr.rows }
+  });
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output,
+    terminal: Boolean(process.stdin.isTTY)
+  });
   return {
     prompt(question) {
       return new Promise((resolve) => rl.question(question, resolve));
     },
     promptPassphrase(question) {
       return new Promise((resolve) => {
-        process.stderr.write(question);
-        const muted = rl;
-        const original = muted._writeToOutput?.bind(rl);
-        muted._writeToOutput = () => {
-        };
-        rl.question("", (answer) => {
-          muted._writeToOutput = original;
-          process.stderr.write("\n");
+        rl.question(question, (answer) => {
+          muted = false;
+          stderr.write("\n");
           resolve(answer);
         });
+        muted = true;
       });
     },
     close() {
@@ -26027,15 +26189,29 @@ var EventStore = class {
   eventsByDTag = /* @__PURE__ */ new Map();
   // "kind:pubkey:dtag" → event
   deletedIds = /* @__PURE__ */ new Set();
+  // NIP-09 coordinate tombstones: "kind:pubkey:dtag" → newest deletion created_at.
+  // An addressable event is only rejected when its created_at ≤ that time, so a
+  // legitimate re-publish after a delete survives.
+  deletedCoordinates = /* @__PURE__ */ new Map();
+  // Kind-84 participant-removal tombstones.
+  ignoredEventIds = /* @__PURE__ */ new Set();
+  ignoredCoordinates = /* @__PURE__ */ new Set();
   subscriptions = [];
   /** Store event. Returns false if duplicate or older replaceable. */
   store(event) {
     if (this.deletedIds.has(event.id))
       return false;
+    if (this.ignoredEventIds.has(event.id))
+      return false;
     if (this.eventsById.has(event.id))
       return false;
     if (this.isReplaceable(event.kind) || this.isParameterizedReplaceable(event.kind)) {
       const addr = this.getAddress(event);
+      const deletedAt = this.deletedCoordinates.get(addr);
+      if (deletedAt !== void 0 && event.created_at <= deletedAt)
+        return false;
+      if (this.ignoredCoordinates.has(addr))
+        return false;
       const existing = this.eventsByDTag.get(addr);
       if (existing && existing.created_at >= event.created_at) {
         return false;
@@ -26050,6 +26226,9 @@ var EventStore = class {
     if (event.kind === 5) {
       this.handleDeletion(event);
     }
+    if (event.kind === 84) {
+      this.handleParticipantRemoval(event);
+    }
     this.eventsById.set(event.id, event);
     if (!this.eventsByKind.has(event.kind)) {
       this.eventsByKind.set(event.kind, /* @__PURE__ */ new Map());
@@ -26118,14 +26297,50 @@ var EventStore = class {
       if (tag[0] === "e" && tag[1]) {
         const targetId = tag[1];
         const target = this.eventsById.get(targetId);
-        if (target && target.pubkey === deletionEvent.pubkey) {
-          this.remove(targetId);
-        }
+        if (target && target.pubkey !== deletionEvent.pubkey)
+          continue;
         this.deletedIds.add(targetId);
+        if (target)
+          this.remove(targetId);
       }
       if (tag[0] === "a" && tag[1]) {
+        const coordAuthor = tag[1].split(":")[1];
+        if (coordAuthor && coordAuthor !== deletionEvent.pubkey)
+          continue;
+        const prev = this.deletedCoordinates.get(tag[1]) ?? 0;
+        if (deletionEvent.created_at > prev) {
+          this.deletedCoordinates.set(tag[1], deletionEvent.created_at);
+        }
         const existing = this.eventsByDTag.get(tag[1]);
-        if (existing && existing.pubkey === deletionEvent.pubkey) {
+        if (existing && existing.created_at <= deletionEvent.created_at) {
+          this.remove(existing.id);
+          this.eventsByDTag.delete(tag[1]);
+        }
+      }
+    }
+  }
+  /**
+   * Process a kind-84 participant removal (a participant opting out of an
+   * event). Unlike NIP-09 there is no same-author rule — any participant
+   * (`p` tag on the target) may remove it for themselves; targets that aren't
+   * cached yet are tombstoned unconditionally, matching the standalone
+   * calendar's EventStore.
+   */
+  handleParticipantRemoval(removalEvent) {
+    const isParticipant = (target) => target.tags.some((t) => t[0] === "p" && t[1] === removalEvent.pubkey);
+    for (const tag of removalEvent.tags) {
+      if (tag[0] === "e" && tag[1]) {
+        const existing = this.eventsById.get(tag[1]);
+        if (existing) {
+          if (!isParticipant(existing))
+            continue;
+          this.remove(tag[1]);
+        }
+        this.ignoredEventIds.add(tag[1]);
+      } else if (tag[0] === "a" && tag[1]) {
+        this.ignoredCoordinates.add(tag[1]);
+        const existing = this.eventsByDTag.get(tag[1]);
+        if (existing && isParticipant(existing)) {
           this.remove(existing.id);
           this.eventsByDTag.delete(tag[1]);
         }
@@ -26149,6 +26364,9 @@ var EventStore = class {
     this.eventsByAuthor.clear();
     this.eventsByDTag.clear();
     this.deletedIds.clear();
+    this.deletedCoordinates.clear();
+    this.ignoredEventIds.clear();
+    this.ignoredCoordinates.clear();
     this.subscriptions = [];
   }
   get size() {
@@ -26385,9 +26603,20 @@ var NostrRuntime = class {
       }
     });
   }
-  /** Publish event to relays */
-  async publish(relays, event) {
-    await Promise.allSettled(this.pool.publish(relays, event));
+  /**
+   * Publish event to relays. Bounded by `timeoutMs`: a relay that never acks must
+   * not hang the caller (e.g. a form submit) forever — best-effort fan-out.
+   */
+  async publish(relays, event, timeoutMs = 1e4) {
+    let timer;
+    const timeout = new Promise((resolve) => {
+      timer = setTimeout(resolve, timeoutMs);
+    });
+    try {
+      await Promise.race([Promise.allSettled(this.pool.publish(relays, event)), timeout]);
+    } finally {
+      clearTimeout(timer);
+    }
     this.eventStore.store(event);
   }
   /** Close all subscriptions + clear caches. Use in tests; rarely in production. */
@@ -26451,7 +26680,7 @@ var MODULE_DEFAULT_RELAYS = {
     "wss://relay.primal.net",
     "wss://nos.lol",
     "wss://relay.nostr.wirednet.jp",
-    "wss://relay.yakinonne.com",
+    "wss://nostr-01.yakihonne.com",
     "wss://relay.snort.social",
     "wss://relay.nostr.band",
     "wss://nostr21.com"
@@ -26683,7 +26912,7 @@ var BlossomClient = class {
    */
   async upload(data, authEvent, contentType) {
     const authHeader = `Nostr ${btoa(JSON.stringify(authEvent))}`;
-    const sha2562 = await sha256Hex(data);
+    const sha2564 = await sha256Hex(data);
     const response = await fetch(`${this.serverUrl}/upload`, {
       method: "PUT",
       headers: {
@@ -26691,7 +26920,7 @@ var BlossomClient = class {
         "Content-Type": contentType ?? "application/octet-stream",
         // BUD-02: lets servers verify the blob and is required by some (e.g.
         // the standalone formstr-drive's default servers).
-        "X-SHA-256": sha2562
+        "X-SHA-256": sha2564
       },
       body: data
     });
@@ -26701,26 +26930,26 @@ var BlossomClient = class {
     const text = await response.text();
     try {
       const json = JSON.parse(text);
-      const hash = json.sha256 ?? json.x ?? sha2562;
+      const hash = json.sha256 ?? json.x ?? sha2564;
       return {
         sha256: hash,
         url: json.url ?? `${this.serverUrl}/${hash}`,
         size: json.size ?? data.byteLength
       };
     } catch {
-      const hash = text.trim() || sha2562;
+      const hash = text.trim() || sha2564;
       return { sha256: hash, url: `${this.serverUrl}/${hash}`, size: data.byteLength };
     }
   }
   /**
    * BUD-03: Download file blob by SHA-256 hash.
    */
-  async download(sha2562, authEvent) {
+  async download(sha2564, authEvent) {
     const headers = {};
     if (authEvent) {
       headers["Authorization"] = `Nostr ${btoa(JSON.stringify(authEvent))}`;
     }
-    const response = await fetch(`${this.serverUrl}/${sha2562}`, { headers });
+    const response = await fetch(`${this.serverUrl}/${sha2564}`, { headers });
     if (!response.ok) {
       throw new Error(`Blossom download failed: ${response.status} ${response.statusText}`);
     }
@@ -26730,9 +26959,9 @@ var BlossomClient = class {
   /**
    * BUD-04: Delete file blob by SHA-256 hash.
    */
-  async delete(sha2562, authEvent) {
+  async delete(sha2564, authEvent) {
     const authHeader = `Nostr ${btoa(JSON.stringify(authEvent))}`;
-    const response = await fetch(`${this.serverUrl}/${sha2562}`, {
+    const response = await fetch(`${this.serverUrl}/${sha2564}`, {
       method: "DELETE",
       headers: { Authorization: authHeader }
     });
@@ -26751,18 +26980,18 @@ async function sha256Hex(data) {
 }
 
 // ../core/dist/blossom/auth.js
-async function createBlossomAuthEvent(operation, sha2562, signer) {
+async function createBlossomAuthEvent(operation, sha2564, signer) {
   const now2 = Math.floor(Date.now() / 1e3);
   const event = {
     kind: 24242,
     created_at: now2,
     tags: [
       ["t", operation],
-      ["x", sha2562],
+      ["x", sha2564],
       ["expiration", String(now2 + 300)]
       // 5 min validity
     ],
-    content: `Authorize ${operation} for ${sha2562}`
+    content: `Authorize ${operation} for ${sha2564}`
   };
   return signer.signEvent(event);
 }
@@ -26837,17 +27066,6 @@ async function wrapEvent3(event, signer, recipientPubkey, wrapKind = 1059) {
   const seal = await createSeal2(rumor, signer, recipientPubkey);
   return createWrap2(seal, recipientPubkey, wrapKind);
 }
-async function wrapManyEvents3(event, signer, recipientPubkeys, wrapKind = 1059) {
-  const rumor = createRumor2(event);
-  rumor.pubkey = await signer.getPublicKey();
-  const wraps = [];
-  for (const pubkey of recipientPubkeys) {
-    const seal = await createSeal2(rumor, signer, pubkey);
-    const wrap = await createWrap2(seal, pubkey, wrapKind);
-    wraps.push(wrap);
-  }
-  return wraps;
-}
 async function unwrapEvent3(wrappedEvent, signer) {
   if (!signer.nip44Decrypt) {
     throw new Error("Signer does not support NIP-44 for unwrap");
@@ -26865,21 +27083,34 @@ function randomizeTimestamp(timestamp) {
 
 // ../core/dist/crypto/nkeys.js
 var PREFIX = "nkeys";
+var BECH32_LIMIT = 2048;
 function encodeNKeys(keys) {
-  const tlvBytes = [];
+  const encoder = new TextEncoder();
+  const names = [];
+  const values = [];
   for (const [name, value] of Object.entries(keys)) {
-    const nameBytes = new TextEncoder().encode(name);
-    tlvBytes.push(0);
-    tlvBytes.push(nameBytes.length >> 8, nameBytes.length & 255);
-    tlvBytes.push(...nameBytes);
-    const valueBytes = new TextEncoder().encode(value);
-    tlvBytes.push(1);
-    tlvBytes.push(valueBytes.length >> 8, valueBytes.length & 255);
-    tlvBytes.push(...valueBytes);
-  }
-  const data = new Uint8Array(tlvBytes);
-  const words = bech32ToWords(data);
-  return bech32Encode(PREFIX, words);
+    const nameBytes = encoder.encode(name);
+    const valueBytes = encoder.encode(value);
+    if (nameBytes.length > 255)
+      throw new Error(`nkeys: key name too long (${name.length})`);
+    if (valueBytes.length > 255)
+      throw new Error(`nkeys: value too long for key "${name}"`);
+    names.push(nameBytes);
+    values.push(valueBytes);
+  }
+  const tlvBytes = [];
+  for (const nameBytes of names) {
+    tlvBytes.push(0, nameBytes.length, ...nameBytes);
+  }
+  for (const valueBytes of values) {
+    tlvBytes.push(1, valueBytes.length, ...valueBytes);
+  }
+  const words = bech32ToWords(new Uint8Array(tlvBytes));
+  const encoded = bech32Encode(PREFIX, words);
+  if (encoded.length > BECH32_LIMIT) {
+    throw new Error(`nkeys: encoded length ${encoded.length} exceeds ${BECH32_LIMIT}`);
+  }
+  return encoded;
 }
 var CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
 function bech32Encode(prefix, words) {
@@ -26991,11 +27222,16 @@ async function aesGcmDecrypt(ciphertext, conversationKey) {
 }
 async function encryptFileWithKey(fileBytes) {
   const secretKey = generateSecretKey();
+  const privateKeyHex = bytesToHex(secretKey);
+  const ciphertext = await encryptFileWithExistingKey(fileBytes, privateKeyHex);
+  return { ciphertext, privateKeyHex };
+}
+async function encryptFileWithExistingKey(fileBytes, privateKeyHex) {
+  const secretKey = hexToBytes(privateKeyHex);
   const pubkey = getPublicKey(secretKey);
   const conversationKey = nip44_exports.v2.utils.getConversationKey(secretKey, pubkey);
   const plaintextBase64 = uint8ArrayToBase64(fileBytes);
-  const ciphertext = await aesGcmEncrypt(plaintextBase64, conversationKey);
-  return { ciphertext, privateKeyHex: bytesToHex(secretKey) };
+  return aesGcmEncrypt(plaintextBase64, conversationKey);
 }
 async function decryptFileWithKey(ciphertext, privateKeyHex) {
   const secretKey = hexToBytes(privateKeyHex);
@@ -27021,23 +27257,23 @@ var KIND_MODULE_MAP = {
   30168: "forms",
   // Form template
   // Calendar
-  31922: "calendar",
-  // Date-based calendar event
   31923: "calendar",
-  // Time-based calendar event
-  31924: "calendar",
+  // Public time-based event (NIP-52)
+  32678: "calendar",
+  // Private event
+  32679: "calendar",
+  // Private event (legacy recurring variant, read-only)
+  32123: "calendar",
   // Calendar list
   // Pages
-  30023: "pages",
-  // Long-form content (NIP-23)
-  30024: "pages",
-  // Draft article
+  33457: "pages",
+  // Encrypted markdown doc (nostr-docs)
   // Drive
-  30563: "drive",
-  // Drive file tree
+  34578: "drive",
+  // File metadata (formstr-drive)
   // Polls
   1068: "polls"
-  // Poll event
+  // Poll event (NIP-88)
 };
 function createRef(_module, kind, pubkey, identifier, relays = []) {
   return nip19_exports.naddrEncode({ kind, pubkey, identifier, relays });
@@ -27162,7 +27398,7 @@ async function bootstrap(input, deps = {}) {
 }
 async function selectAccount(signer, requested) {
   if (requested) {
-    const match = signer.listAccounts().find((a) => a.pubkey === requested);
+    const match = findAccount(signer.listAccounts(), requested);
     if (!match) {
       throw new Error(
         `No stored account for --account ${requested}. Run \`formstr-mcp accounts\` to list them.`
@@ -27179,18 +27415,7 @@ async function selectAccount(signer, requested) {
 }
 async function unlock(signer, account, deps) {
   if (account.method === "ncryptsec") {
-    if (!account.ncryptsec) {
-      throw new Error(
-        "Stored ncryptsec account is missing its encrypted key. Run `formstr-mcp login`."
-      );
-    }
-    const passphrase = deps.passphrase ?? process.env.FORMSTR_MCP_NCRYPTSEC_PASSPHRASE;
-    if (!passphrase) {
-      throw new Error(
-        "Set FORMSTR_MCP_NCRYPTSEC_PASSPHRASE to unlock the ncryptsec account at boot."
-      );
-    }
-    await signer.loginWithNcryptsec(account.ncryptsec, passphrase);
+    await unlockNcryptsec(signer, account, deps);
     return;
   }
   if (account.method === "nip46") {
@@ -27198,41 +27423,120 @@ async function unlock(signer, account, deps) {
       throw new Error("Stored nip46 account is missing its session. Run `formstr-mcp login`.");
     }
     const pool = deps.pool ?? createPatchedPool();
-    await signer.loginWithBunkerUri(account.nip46.uri, {
-      clientSecretKey: hexToBytes2(account.nip46.clientSecretKey),
-      pool
-    });
+    const active = await signer.unlock({ pool });
+    if (!active) {
+      throw new Error(
+        "Could not resume the stored nip46 session (its keys are incomplete). Run `formstr-mcp login` to re-pair."
+      );
+    }
     return;
   }
   throw new Error(
     `Account method "${account.method}" cannot be unlocked headlessly \u2014 use ncryptsec or nip46.`
   );
 }
+var MAX_PASSPHRASE_ATTEMPTS = 3;
+async function unlockNcryptsec(signer, account, deps) {
+  if (!account.ncryptsec) {
+    throw new Error(
+      `Account ${account.npub} is stored as an ncryptsec but its encrypted key is missing. Re-add it with \`formstr-mcp login\`.`
+    );
+  }
+  const ncryptsec = account.ncryptsec;
+  const tryUnlock = async (passphrase) => {
+    try {
+      await signer.loginWithNcryptsec(ncryptsec, passphrase);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const configured = deps.passphrase ?? process.env.FORMSTR_MCP_NCRYPTSEC_PASSPHRASE;
+  if (configured) {
+    if (await tryUnlock(configured)) return;
+    if (!deps.promptPassphrase) {
+      throw new Error(
+        `The configured passphrase did not unlock account ${account.npub} \u2014 it is most likely the wrong passphrase for this account (each account has its own). Set FORMSTR_MCP_NCRYPTSEC_PASSPHRASE to the passphrase that matches this account, or switch to another with \`formstr-mcp switch <npub>\` (a nip46/bunker account needs no passphrase).`
+      );
+    }
+    console.error(
+      `formstr-mcp: the configured passphrase didn't unlock ${account.npub} \u2014 enter it manually.`
+    );
+  } else if (!deps.promptPassphrase) {
+    throw new Error(
+      `Cannot unlock account ${account.npub} (ncryptsec): no passphrase is available. FORMSTR_MCP_NCRYPTSEC_PASSPHRASE is not set and this process has no interactive terminal to prompt on \u2014 an MCP host runs the server with stdin wired to the JSON-RPC channel. Fix: add FORMSTR_MCP_NCRYPTSEC_PASSPHRASE to your MCP server config's \`env\`, or switch to a nip46/bunker account with \`formstr-mcp switch <npub>\` (resumes with no passphrase).`
+    );
+  }
+  const promptPassphrase = deps.promptPassphrase;
+  for (let attempt = 1; attempt <= MAX_PASSPHRASE_ATTEMPTS; attempt++) {
+    const passphrase = await promptPassphrase(`Passphrase to unlock ${account.npub}: `);
+    if (await tryUnlock(passphrase)) return;
+    const left = MAX_PASSPHRASE_ATTEMPTS - attempt;
+    if (left > 0) console.error(`formstr-mcp: incorrect passphrase, ${left} attempt(s) left.`);
+  }
+  throw new Error(
+    `Incorrect passphrase for account ${account.npub} after ${MAX_PASSPHRASE_ATTEMPTS} attempts.`
+  );
+}
 
 // src/cli.ts
-var SUBCOMMANDS = /* @__PURE__ */ new Set(["login", "logout", "whoami", "accounts"]);
+var SUBCOMMANDS = /* @__PURE__ */ new Set(["login", "logout", "whoami", "accounts", "switch", "help"]);
 function parseCli(argv) {
   const rest = [...argv];
+  if (rest.includes("-h") || rest.includes("--help")) {
+    return { command: "help", allowWrites: false };
+  }
   let command = "run";
   if (rest[0] && SUBCOMMANDS.has(rest[0])) {
     command = rest.shift();
   }
   let relays;
   let account;
+  let target;
   let allowWrites = false;
   for (let i4 = 0; i4 < rest.length; i4++) {
     const arg = rest[i4];
     if (arg === "--relays") relays = splitRelays(rest[++i4]);
     else if (arg === "--allow-writes") allowWrites = true;
     else if (arg === "--account") account = rest[++i4];
+    else if (!arg.startsWith("-") && target === void 0) target = arg;
   }
-  return { command, relays, allowWrites, account };
+  return { command, relays, allowWrites, account, target };
+}
+function formatFatal(err, debug = false) {
+  if (err instanceof Error) return debug && err.stack ? err.stack : err.message;
+  return String(err);
 }
 function splitRelays(value) {
   if (!value) return void 0;
   const parts = value.split(",").map((s) => s.trim()).filter(Boolean);
   return parts.length ? parts : void 0;
 }
+function helpText() {
+  return [
+    "formstr-mcp \u2014 MCP server for the Formstr super-app (Nostr forms & more).",
+    "",
+    "Usage: formstr-mcp [command] [flags]",
+    "",
+    "Commands:",
+    "  run               Run the stdio MCP server (default when no command is given).",
+    "  login             Sign in (create / import / bunker URI / QR) and store the key.",
+    "  logout [npub]     Remove a stored account (defaults to the active one).",
+    "  whoami            Print the active account.",
+    "  accounts          List stored accounts ('*' marks the active one).",
+    "  switch <npub>     Set the active account (accepts an npub or hex pubkey).",
+    "  help              Show this help (also -h, --help).",
+    "",
+    "Flags:",
+    "  --allow-writes         Enable gated write tools (update / delete / share / submit).",
+    "  --account <npub|hex>   Boot a specific account instead of the active one.",
+    "  --relays <a,b,\u2026>       Override relays (comma-separated).",
+    "",
+    "Env:",
+    "  FORMSTR_MCP_NCRYPTSEC_PASSPHRASE   Unlock the active ncryptsec account at boot.",
+    "  FORMSTR_MCP_PASSPHRASE             Encrypt the keystore file (keychain-less hosts)."
+  ].join("\n");
+}
 
 // src/config.ts
 function resolveConfig(cli, env) {
@@ -31315,6 +31619,7 @@ __export(service_exports, {
   createForm: () => createForm,
   deleteForm: () => deleteForm,
   fetchForm: () => fetchForm,
+  fetchFormKeys: () => fetchFormKeys,
   fetchFormSummaryFromRef: () => fetchFormSummaryFromRef,
   fetchMyForms: () => fetchMyForms,
   fetchResponses: () => fetchResponses,
@@ -31326,34 +31631,328 @@ __export(service_exports, {
   updateForm: () => updateForm
 });
 
-// ../../node_modules/.pnpm/nostr-tools@2.23.3_typescript@5.9.3/node_modules/nostr-tools/lib/esm/utils.js
-var utf8Decoder7 = new TextDecoder("utf-8");
-var utf8Encoder7 = new TextEncoder();
-
-// ../agent/src/services/forms/keys.ts
-function makeViewKeySigner(viewKeyHex) {
-  return new LocalSigner2(hexToBytes3(viewKeyHex));
+// ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/utils.js
+function isBytes4(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
 }
-function makeSigningKeySigner(signingKeyHex) {
-  return new LocalSigner2(hexToBytes3(signingKeyHex));
+function abytes4(b, ...lengths) {
+  if (!isBytes4(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
 }
-function encodeFormKeys(signingKeyHex, viewKeyHex) {
-  return viewKeyHex ? `${signingKeyHex}:${viewKeyHex}` : signingKeyHex;
+function aexists3(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
 }
-function decodeFormKeys(segment) {
-  const idx = segment.indexOf(":");
-  if (idx < 0) return { signingKey: segment };
-  return { signingKey: segment.slice(0, idx), viewKey: segment.slice(idx + 1) };
+function aoutput3(out, instance) {
+  abytes4(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
 }
-function hexToBytes3(hex) {
-  if (hex.length % 2 !== 0) throw new Error("invalid hex length");
-  if (hex.length > 0 && !/^[0-9a-fA-F]+$/.test(hex)) throw new Error("invalid hex characters");
-  const out = new Uint8Array(hex.length / 2);
-  for (let i4 = 0; i4 < out.length; i4++) {
-    out[i4] = parseInt(hex.slice(i4 * 2, i4 * 2 + 2), 16);
+function clean3(...arrays) {
+  for (let i4 = 0; i4 < arrays.length; i4++) {
+    arrays[i4].fill(0);
   }
-  return out;
 }
+function createView3(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr2(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+function utf8ToBytes2(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes2(data);
+  abytes4(data);
+  return data;
+}
+var Hash = class {
+};
+function createHasher2(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+
+// ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/_md.js
+function setBigUint64(view, byteOffset, value, isLE3) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE3);
+  const _32n = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  const wh = Number(value >> _32n & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = isLE3 ? 4 : 0;
+  const l = isLE3 ? 0 : 4;
+  view.setUint32(byteOffset + h, wh, isLE3);
+  view.setUint32(byteOffset + l, wl, isLE3);
+}
+function Chi2(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj2(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+var HashMD2 = class extends Hash {
+  constructor(blockLen, outputLen, padOffset, isLE3) {
+    super();
+    this.finished = false;
+    this.length = 0;
+    this.pos = 0;
+    this.destroyed = false;
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE3;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView3(this.buffer);
+  }
+  update(data) {
+    aexists3(this);
+    data = toBytes(data);
+    abytes4(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView3(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists3(this);
+    aoutput3(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE: isLE3 } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean3(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i4 = pos; i4 < blockLen; i4++)
+      buffer[i4] = 0;
+    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE3);
+    this.process(view, 0);
+    const oview = createView3(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i4 = 0; i4 < outLen; i4++)
+      oview.setUint32(4 * i4, state[i4], isLE3);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to || (to = new this.constructor());
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+var SHA256_IV2 = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha2.js
+var SHA256_K2 = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_W2 = /* @__PURE__ */ new Uint32Array(64);
+var SHA256 = class extends HashMD2 {
+  constructor(outputLen = 32) {
+    super(64, outputLen, 8, false);
+    this.A = SHA256_IV2[0] | 0;
+    this.B = SHA256_IV2[1] | 0;
+    this.C = SHA256_IV2[2] | 0;
+    this.D = SHA256_IV2[3] | 0;
+    this.E = SHA256_IV2[4] | 0;
+    this.F = SHA256_IV2[5] | 0;
+    this.G = SHA256_IV2[6] | 0;
+    this.H = SHA256_IV2[7] | 0;
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  // prettier-ignore
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i4 = 0; i4 < 16; i4++, offset += 4)
+      SHA256_W2[i4] = view.getUint32(offset, false);
+    for (let i4 = 16; i4 < 64; i4++) {
+      const W15 = SHA256_W2[i4 - 15];
+      const W2 = SHA256_W2[i4 - 2];
+      const s0 = rotr2(W15, 7) ^ rotr2(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr2(W2, 17) ^ rotr2(W2, 19) ^ W2 >>> 10;
+      SHA256_W2[i4] = s1 + SHA256_W2[i4 - 7] + s0 + SHA256_W2[i4 - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i4 = 0; i4 < 64; i4++) {
+      const sigma1 = rotr2(E, 6) ^ rotr2(E, 11) ^ rotr2(E, 25);
+      const T1 = H + sigma1 + Chi2(E, F, G) + SHA256_K2[i4] + SHA256_W2[i4] | 0;
+      const sigma0 = rotr2(A, 2) ^ rotr2(A, 13) ^ rotr2(A, 22);
+      const T2 = sigma0 + Maj2(A, B, C) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    clean3(SHA256_W2);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean3(this.buffer);
+  }
+};
+var sha2562 = /* @__PURE__ */ createHasher2(() => new SHA256());
+
+// ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha256.js
+var sha2563 = sha2562;
+
+// ../../node_modules/.pnpm/nostr-tools@2.23.3_typescript@5.9.3/node_modules/nostr-tools/lib/esm/utils.js
+var utf8Decoder7 = new TextDecoder("utf-8");
+var utf8Encoder7 = new TextEncoder();
 
 // ../agent/src/services/forms/types.ts
 var FORM_KINDS = {
@@ -31375,46 +31974,219 @@ var AnswerType = /* @__PURE__ */ ((AnswerType2) => {
   AnswerType2["datetime"] = "datetime";
   AnswerType2["fileUpload"] = "fileUpload";
   AnswerType2["signature"] = "signature";
-  AnswerType2["multiChoiceGrid"] = "multiChoiceGrid";
+  AnswerType2["multipleChoiceGrid"] = "multipleChoiceGrid";
   AnswerType2["checkboxGrid"] = "checkboxGrid";
+  AnswerType2["rating"] = "rating";
   AnswerType2["section"] = "section";
   return AnswerType2;
 })(AnswerType || {});
 
+// ../agent/src/services/forms/fieldCodec.ts
+var PRIMITIVE_BY_TYPE = {
+  ["label" /* label */]: "label",
+  ["section" /* section */]: "section",
+  ["shortText" /* shortText */]: "text",
+  ["paragraph" /* paragraph */]: "text",
+  ["date" /* date */]: "text",
+  ["time" /* time */]: "text",
+  ["signature" /* signature */]: "text",
+  ["number" /* number */]: "number",
+  ["radioButton" /* radioButton */]: "option",
+  ["checkboxes" /* checkboxes */]: "option",
+  ["dropdown" /* dropdown */]: "option",
+  ["fileUpload" /* fileUpload */]: "file",
+  ["datetime" /* datetime */]: "datetime",
+  ["multipleChoiceGrid" /* multipleChoiceGrid */]: "grid",
+  ["checkboxGrid" /* checkboxGrid */]: "grid",
+  ["rating" /* rating */]: "rating"
+};
+var DEFAULT_TYPE_BY_PRIMITIVE = {
+  text: "shortText" /* shortText */,
+  number: "number" /* number */,
+  option: "radioButton" /* radioButton */,
+  label: "label" /* label */,
+  section: "section" /* section */,
+  file: "fileUpload" /* fileUpload */,
+  datetime: "datetime" /* datetime */,
+  grid: "multipleChoiceGrid" /* multipleChoiceGrid */,
+  rating: "rating" /* rating */
+};
+var GRID_TYPES = /* @__PURE__ */ new Set(["multipleChoiceGrid" /* multipleChoiceGrid */, "checkboxGrid" /* checkboxGrid */]);
+function makeId() {
+  return Math.random().toString(36).slice(2, 8) || "id";
+}
+function buildFieldTag(field) {
+  let options = "[]";
+  if (GRID_TYPES.has(field.type)) {
+    const grid = {
+      rows: (field.gridRows ?? []).map((label) => [makeId(), label]),
+      columns: (field.gridCols ?? []).map((label) => [makeId(), label])
+    };
+    options = JSON.stringify(grid);
+  } else if (field.options) {
+    options = JSON.stringify(field.options.map((o) => [o.id, o.label]));
+  }
+  const config2 = { renderElement: field.type };
+  if (field.required !== void 0) config2.required = field.required;
+  if (field.placeholder !== void 0) config2.placeholder = field.placeholder;
+  if (field.type === "rating" /* rating */ && field.maxStars !== void 0) {
+    config2.maxStars = field.maxStars;
+  }
+  if (GRID_TYPES.has(field.type)) {
+    config2.allowMultiplePerRow = field.type === "checkboxGrid" /* checkboxGrid */;
+  }
+  if (field.validation) {
+    const v = field.validation;
+    const rules = {};
+    if (v.min !== void 0) rules.min = { min: v.min };
+    if (v.max !== void 0) rules.max = { max: v.max };
+    if (v.regex !== void 0) rules.regex = { pattern: v.regex, errorMessage: v.regexError ?? "" };
+    if (Object.keys(rules).length > 0) config2.validationRules = rules;
+  }
+  if (field.fileConfig) {
+    const f = field.fileConfig;
+    if (f.blossomServer !== void 0) config2.blossomServer = f.blossomServer;
+    if (f.maxBytes !== void 0) config2.maxFileSize = f.maxBytes / (1024 * 1024);
+    if (f.mimeTypes !== void 0) config2.allowedTypes = f.mimeTypes;
+  }
+  return ["field", field.id, PRIMITIVE_BY_TYPE[field.type], field.label, options, JSON.stringify(config2)];
+}
+function isAnswerType(value) {
+  return Object.values(AnswerType).includes(value);
+}
+function resolveType(primitive, renderElement) {
+  if (primitive === "section") return "section" /* section */;
+  if (renderElement) {
+    if (renderElement === "multiChoiceGrid") return "multipleChoiceGrid" /* multipleChoiceGrid */;
+    if (isAnswerType(renderElement)) return renderElement;
+  }
+  if (primitive === "multiChoiceGrid") return "multipleChoiceGrid" /* multipleChoiceGrid */;
+  if (isAnswerType(primitive)) return primitive;
+  return DEFAULT_TYPE_BY_PRIMITIVE[primitive] ?? "shortText" /* shortText */;
+}
+function parseFieldTag(tag) {
+  const [, id = "", primitive = "text", label = "", optionsJson, configJson] = tag;
+  let config2 = {};
+  if (configJson) {
+    try {
+      const parsed = JSON.parse(configJson);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) config2 = parsed;
+    } catch {
+    }
+  }
+  const field = {
+    id,
+    type: resolveType(primitive, config2.renderElement),
+    label
+  };
+  let parsedOptions;
+  if (optionsJson) {
+    try {
+      parsedOptions = JSON.parse(optionsJson);
+    } catch {
+    }
+  }
+  if (Array.isArray(parsedOptions) && parsedOptions.length > 0) {
+    field.options = parsedOptions.map(
+      (o) => ({ id: o[0], label: o[1] })
+    );
+  } else if (parsedOptions && typeof parsedOptions === "object") {
+    const grid = parsedOptions;
+    if (Array.isArray(grid.rows)) field.gridRows = grid.rows.map((r) => r[1]);
+    if (Array.isArray(grid.columns)) field.gridCols = grid.columns.map((c) => c[1]);
+  }
+  if (typeof config2.required === "boolean") field.required = config2.required;
+  if (typeof config2.placeholder === "string") field.placeholder = config2.placeholder;
+  if (typeof config2.maxStars === "number") field.maxStars = config2.maxStars;
+  const rules = config2.validationRules;
+  if (rules && typeof rules === "object") {
+    const validation = {};
+    if (typeof rules.range?.min === "number") validation.min = rules.range.min;
+    if (typeof rules.range?.max === "number") validation.max = rules.range.max;
+    if (typeof rules.min?.min === "number") validation.min = rules.min.min;
+    if (typeof rules.max?.max === "number") validation.max = rules.max.max;
+    if (typeof rules.regex?.pattern === "string") {
+      validation.regex = rules.regex.pattern;
+      if (rules.regex.errorMessage) validation.regexError = rules.regex.errorMessage;
+    }
+    if (Object.keys(validation).length > 0) field.validation = validation;
+  }
+  if (config2.blossomServer !== void 0 || config2.maxFileSize !== void 0 || config2.allowedTypes !== void 0) {
+    field.fileConfig = {
+      ...typeof config2.blossomServer === "string" && { blossomServer: config2.blossomServer },
+      ...typeof config2.maxFileSize === "number" && {
+        maxBytes: config2.maxFileSize * 1024 * 1024
+      },
+      ...Array.isArray(config2.allowedTypes) && { mimeTypes: config2.allowedTypes }
+    };
+  }
+  return field;
+}
+
+// ../agent/src/services/forms/keys.ts
+function makeViewKeySigner(viewKeyHex) {
+  return new LocalSigner2(hexToBytes3(viewKeyHex));
+}
+function makeSigningKeySigner(signingKeyHex) {
+  return new LocalSigner2(hexToBytes3(signingKeyHex));
+}
+function encodeFormKeys(signingKeyHex, viewKeyHex) {
+  return viewKeyHex ? `${signingKeyHex}:${viewKeyHex}` : signingKeyHex;
+}
+function decodeFormKeys(segment) {
+  const idx = segment.indexOf(":");
+  if (idx < 0) return { signingKey: segment };
+  return { signingKey: segment.slice(0, idx), viewKey: segment.slice(idx + 1) };
+}
+function hexToBytes3(hex) {
+  if (hex.length % 2 !== 0) throw new Error("invalid hex length");
+  if (hex.length > 0 && !/^[0-9a-fA-F]+$/.test(hex)) throw new Error("invalid hex characters");
+  const out = new Uint8Array(hex.length / 2);
+  for (let i4 = 0; i4 < out.length; i4++) {
+    out[i4] = parseInt(hex.slice(i4 * 2, i4 * 2 + 2), 16);
+  }
+  return out;
+}
+
 // ../agent/src/services/forms/service.ts
+function relaysForForm(formRelays) {
+  return Array.from(/* @__PURE__ */ new Set([...relayManager.getRelaysForModule("forms"), ...formRelays ?? []]));
+}
+function buildSpecRows(formId, name, fields, settings) {
+  const rows = [
+    ["d", formId],
+    ["name", name]
+  ];
+  if (settings) rows.push(["settings", JSON.stringify(settings)]);
+  for (const field of fields) rows.push(buildFieldTag(field));
+  return rows;
+}
+function buildEncryptedOuterTags(formId, name, relays, settings) {
+  const tags = [["d", formId], ["name", name], ...relays.map((r) => ["relay", r])];
+  const allowed = settings?.allowedResponders ?? [];
+  const pTags = /* @__PURE__ */ new Set([...allowed, ...settings?.collaborators ?? []]);
+  for (const pk of allowed) tags.push(["allowed", pk]);
+  for (const pk of pTags) tags.push(["p", pk]);
+  return tags;
+}
 async function createForm(params) {
-  const signer = await signerManager.getSigner();
-  const userPubkey = await signer.getPublicKey();
+  await signerManager.getSigner();
   const formId = crypto.randomUUID().slice(0, 8);
   const relays = relayManager.getRelaysForModule("forms");
-  const baseTags = [
-    ["d", formId],
-    ["name", params.name]
-  ];
-  if (params.settings) baseTags.push(["settings", JSON.stringify(params.settings)]);
-  for (const field of params.fields) {
-    baseTags.push(buildFieldTag(field));
-  }
+  const specRows = buildSpecRows(formId, params.name, params.fields, params.settings);
+  const signingKey = generateSecretKey();
+  const signingKeyHex = bytesToHex(signingKey);
+  const signingPubkey = getPublicKey(signingKey);
   if (params.encrypt) {
-    const signingKey = generateSecretKey();
-    const signingKeyHex = bytesToHex(signingKey);
-    const signingPubkey = getPublicKey(signingKey);
     const viewKey = generateSecretKey();
     const viewKeyHex = bytesToHex(viewKey);
     const viewPubkey = getPublicKey(viewKey);
     const formSigner = new LocalSigner2(signingKey);
-    const fieldTags = baseTags.filter((t) => t[0] === "field");
-    const content = await formSigner.nip44Encrypt(viewPubkey, JSON.stringify(fieldTags));
-    const encTags = [
-      ["d", formId],
-      ["name", params.name],
-      ["encryption", "view-key"]
-    ];
-    if (params.settings) encTags.push(["settings", JSON.stringify(params.settings)]);
+    const content = await formSigner.nip44Encrypt(viewPubkey, JSON.stringify(specRows));
     const event2 = {
       kind: FORM_KINDS.template,
       created_at: Math.floor(Date.now() / 1e3),
-      tags: encTags,
+      tags: buildEncryptedOuterTags(formId, params.name, relays, params.settings),
       content
     };
     const signed2 = finalizeEvent(event2, signingKey);
@@ -31422,20 +32194,20 @@ async function createForm(params) {
     await appendToMyFormsList(signingPubkey, formId, relays[0] ?? "", signingKeyHex, viewKeyHex);
     return { formId, pubkey: signingPubkey, signingKey: signingKeyHex, viewKey: viewKeyHex };
   }
-  if (params.settings?.publicForm) baseTags.push(["t", "public"]);
+  const tags = [...specRows, ["t", "public"], ...relays.map((r) => ["relay", r])];
   const event = {
     kind: FORM_KINDS.template,
     created_at: Math.floor(Date.now() / 1e3),
-    tags: baseTags,
+    tags,
     content: ""
   };
-  const signed = await signer.signEvent(event);
+  const signed = finalizeEvent(event, signingKey);
   await nostrRuntime.publish(relays, signed);
-  await appendToMyFormsList(userPubkey, formId, relays[0] ?? "", void 0, void 0);
-  return { formId, pubkey: userPubkey };
+  await appendToMyFormsList(signingPubkey, formId, relays[0] ?? "", signingKeyHex, void 0);
+  return { formId, pubkey: signingPubkey, signingKey: signingKeyHex };
 }
-async function fetchForm(pubkey, formId, viewKey) {
-  const relays = relayManager.getRelaysForModule("forms");
+async function fetchForm(pubkey, formId, viewKey, relayHints) {
+  const relays = relaysForForm(relayHints);
   const event = await nostrRuntime.fetchOne(relays, {
     kinds: [FORM_KINDS.template],
     authors: [pubkey],
@@ -31443,25 +32215,48 @@ async function fetchForm(pubkey, formId, viewKey) {
     limit: 1
   });
   if (!event) return null;
-  const template = parseFormEvent(event);
-  if (template.isEncrypted && event.content && viewKey) {
+  let effectiveViewKey = viewKey;
+  if (!effectiveViewKey && event.content && !event.tags.some((t) => t[0] === "field")) {
+    const keys = await fetchFormKeys(pubkey, formId).catch(() => null);
+    effectiveViewKey = keys?.viewKey;
+  }
+  let decryptedRows;
+  if (event.content && effectiveViewKey) {
     try {
-      const viewSigner = makeViewKeySigner(viewKey);
+      const viewSigner = makeViewKeySigner(effectiveViewKey);
       const decrypted = await viewSigner.nip44Decrypt(pubkey, event.content);
-      const fieldTags = JSON.parse(decrypted);
-      template.fields = fieldTags.filter((t) => t[0] === "field").map((t) => ({
-        id: t[1],
-        type: t[2],
-        label: t[3],
-        options: t[4] ? safeParseOptions(t[4]) : void 0,
-        required: t[5] ? JSON.parse(t[5])?.required : void 0
-      }));
+      const rows = JSON.parse(decrypted);
+      if (Array.isArray(rows)) decryptedRows = rows;
+    } catch {
+    }
+  }
+  return parseFormEvent(event, decryptedRows);
+}
+function accessGrantAlias(formAuthor, formId, recipient) {
+  return bytesToHex(sha2563(`${FORM_KINDS.template}:${formAuthor}:${formId}:${recipient}`));
+}
+async function fetchFormKeys(formAuthor, formId) {
+  const signer = signerManager.getSignerIfAvailable();
+  if (!signer?.nip44Decrypt) return null;
+  const userPub = await signer.getPublicKey();
+  const relays = relayManager.getRelaysForModule("forms");
+  const wraps = await nostrRuntime.querySync(relays, {
+    kinds: [FORM_KINDS.giftWrap],
+    "#p": [accessGrantAlias(formAuthor, formId, userPub)]
+  });
+  for (const wrap of wraps) {
+    try {
+      const seal = JSON.parse(await signer.nip44Decrypt(wrap.pubkey, wrap.content));
+      const rumor = JSON.parse(await signer.nip44Decrypt(seal.pubkey, seal.content));
+      const viewKey = rumor.tags?.find((t) => t[0] === "ViewAccess")?.[1];
+      const signingKey = rumor.tags?.find((t) => t[0] === "EditAccess")?.[1];
+      if (viewKey || signingKey) return { viewKey, signingKey };
     } catch {
     }
   }
-  return template;
+  return null;
 }
-async function submitResponse(formPubkey, formId, responses, encrypt7 = false, overrideSigner) {
+async function submitResponse(formPubkey, formId, responses, encrypt7 = false, overrideSigner, formRelays) {
   const signer = overrideSigner ?? await signerManager.getSigner();
   const responseTags = responses.map((r) => ["response", r.fieldId, r.answer, r.metadata ?? ""]);
   const tags = [
@@ -31480,11 +32275,10 @@ async function submitResponse(formPubkey, formId, responses, encrypt7 = false, o
     content
   };
   const signed = await signer.signEvent(event);
-  const relays = relayManager.getRelaysForModule("forms");
-  await nostrRuntime.publish(relays, signed);
+  await nostrRuntime.publish(relaysForForm(formRelays), signed);
 }
-function subscribeToResponses(formPubkey, formId, onResponse, onEose, signingKey) {
-  const relays = relayManager.getRelaysForModule("forms");
+function subscribeToResponses(formPubkey, formId, onResponse, onEose, signingKey, formRelays) {
+  const relays = relaysForForm(formRelays);
   const formSigner = signingKey ? makeSigningKeySigner(signingKey) : void 0;
   return nostrRuntime.subscribe(
     relays,
@@ -31508,9 +32302,8 @@ function subscribeToResponses(formPubkey, formId, onResponse, onEose, signingKey
     }
   );
 }
-async function fetchResponses(formPubkey, formId, signingKey) {
-  const relays = relayManager.getRelaysForModule("forms");
-  const events = await nostrRuntime.querySync(relays, {
+async function fetchResponses(formPubkey, formId, signingKey, formRelays) {
+  const events = await nostrRuntime.querySync(relaysForForm(formRelays), {
     kinds: [FORM_KINDS.response],
     "#a": [`${FORM_KINDS.template}:${formPubkey}:${formId}`]
   });
@@ -31543,6 +32336,27 @@ async function fetchLatestMyFormsEvent(relays, userPubkey) {
     null
   );
 }
+async function decryptListEntries(signer, userPubkey, content) {
+  let decrypted = "";
+  if (content.includes("?iv=")) {
+    if (!signer.decrypt) throw new Error("Signer cannot decrypt");
+    decrypted = await signer.decrypt(userPubkey, content);
+  } else {
+    decrypted = await nip44SelfDecrypt(signer, content);
+  }
+  const parsed = JSON.parse(decrypted);
+  return Array.isArray(parsed) ? parsed : [];
+}
+async function publishMyFormsList(signer, relays, entries) {
+  const encrypted = await nip44SelfEncrypt(signer, JSON.stringify(entries));
+  const event = {
+    kind: FORM_KINDS.myFormsList,
+    created_at: Math.floor(Date.now() / 1e3),
+    tags: [],
+    content: encrypted
+  };
+  await nostrRuntime.publish(relays, await signer.signEvent(event));
+}
 async function fetchMyForms() {
   const signer = await signerManager.getSigner();
   const userPubkey = await signer.getPublicKey();
@@ -31551,15 +32365,7 @@ async function fetchMyForms() {
   let entries = [];
   if (listEvent?.content) {
     try {
-      let decrypted = "";
-      if (listEvent.content.includes("?iv=")) {
-        if (!signer.decrypt) throw new Error("Signer cannot decrypt");
-        decrypted = await signer.decrypt(userPubkey, listEvent.content);
-      } else {
-        decrypted = await nip44SelfDecrypt(signer, listEvent.content);
-      }
-      const parsed = JSON.parse(decrypted);
-      entries = Array.isArray(parsed) ? parsed : [];
+      entries = await decryptListEntries(signer, userPubkey, listEvent.content);
     } catch {
     }
   }
@@ -31577,7 +32383,7 @@ async function fetchMyForms() {
     if (d) eventMap.set(`${evt.pubkey}:${d}`, evt);
   }
   return entries.filter((e) => e[0] === "f" && e[1]).map((entry) => {
-    const [, coordKey, , keySegment] = entry;
+    const [, coordKey, relayHint, keySegment] = entry;
     const [formPubkey, formId] = coordKey.split(":");
     if (!formPubkey || !formId) return null;
     const evt = eventMap.get(coordKey);
@@ -31593,7 +32399,8 @@ async function fetchMyForms() {
       createdAt: evt?.created_at ?? 0,
       isEncrypted,
       signingKey: keys?.signingKey,
-      viewKey: keys?.viewKey
+      viewKey: keys?.viewKey,
+      relay: relayHint || void 0
     };
     return summary;
   }).filter((s) => s !== null);
@@ -31606,15 +32413,7 @@ async function appendToMyFormsList(formPubkey, formId, relay, signingKeyHex, vie
   let entries = [];
   if (existing?.content) {
     try {
-      let decrypted = "";
-      if (existing.content.includes("?iv=")) {
-        if (!signer.decrypt) throw new Error("Signer cannot decrypt");
-        decrypted = await signer.decrypt(userPubkey, existing.content);
-      } else {
-        decrypted = await nip44SelfDecrypt(signer, existing.content);
-      }
-      const parsed = JSON.parse(decrypted);
-      entries = Array.isArray(parsed) ? parsed : [];
+      entries = await decryptListEntries(signer, userPubkey, existing.content);
     } catch {
       entries = [];
     }
@@ -31627,15 +32426,7 @@ async function appendToMyFormsList(formPubkey, formId, relay, signingKeyHex, vie
     const secrets = signingKeyHex ? encodeFormKeys(signingKeyHex, viewKeyHex) : "";
     entries.push(["f", coordKey, relay, secrets]);
   }
-  const encrypted = await nip44SelfEncrypt(signer, JSON.stringify(entries));
-  const listEvent = {
-    kind: FORM_KINDS.myFormsList,
-    created_at: Math.floor(Date.now() / 1e3),
-    tags: [],
-    content: encrypted
-  };
-  const signed = await signer.signEvent(listEvent);
-  await nostrRuntime.publish(relays, signed);
+  await publishMyFormsList(signer, relays, entries);
 }
 async function saveToMyForms(summaries) {
   const signer = await signerManager.getSigner();
@@ -31643,18 +32434,10 @@ async function saveToMyForms(summaries) {
   const entries = summaries.map((s) => [
     "f",
     `${s.pubkey}:${s.id}`,
-    "",
+    s.relay ?? "",
     s.signingKey ? encodeFormKeys(s.signingKey, s.viewKey) : ""
   ]);
-  const encrypted = await nip44SelfEncrypt(signer, JSON.stringify(entries));
-  const event = {
-    kind: FORM_KINDS.myFormsList,
-    created_at: Math.floor(Date.now() / 1e3),
-    tags: [],
-    content: encrypted
-  };
-  const signed = await signer.signEvent(event);
-  await nostrRuntime.publish(relays, signed);
+  await publishMyFormsList(signer, relays, entries);
 }
 async function fetchMyFormsByAuthor(pubkey, relays) {
   const filter = {
@@ -31677,6 +32460,8 @@ async function fetchMyFormsByAuthor(pubkey, relays) {
 }
 async function deleteForm(formId, formPubkey) {
   const signer = await signerManager.getSigner();
+  const userPubkey = await signer.getPublicKey();
+  const relays = relayManager.getRelaysForModule("forms");
   const coordinate = `${FORM_KINDS.template}:${formPubkey}:${formId}`;
   const event = {
     kind: 5,
@@ -31687,58 +32472,60 @@ async function deleteForm(formId, formPubkey) {
     ],
     content: "Deleted via Formstr"
   };
-  const signed = await signer.signEvent(event);
-  const relays = relayManager.getRelaysForModule("forms");
-  await nostrRuntime.publish(relays, signed);
+  await nostrRuntime.publish(relays, await signer.signEvent(event));
+  const listEvent = await fetchLatestMyFormsEvent(relays, userPubkey);
+  if (!listEvent?.content) return;
+  let entries;
+  try {
+    entries = await decryptListEntries(signer, userPubkey, listEvent.content);
+  } catch {
+    return;
+  }
+  const coordKey = `${formPubkey}:${formId}`;
+  const trimmed = entries.filter((e) => e[1] !== coordKey);
+  if (trimmed.length === entries.length) return;
+  await publishMyFormsList(signer, relays, trimmed);
 }
 async function updateForm(params) {
   const relays = relayManager.getRelaysForModule("forms");
-  const existing = await fetchForm(params.pubkey, params.formId);
+  const summary = (await fetchMyForms()).find(
+    (f) => f.id === params.formId && f.pubkey === params.pubkey
+  );
+  const existing = await fetchForm(params.pubkey, params.formId, summary?.viewKey);
   if (!existing) throw new Error(`Form not found: ${params.formId}`);
   const name = params.name ?? existing.name;
   const settings = { ...existing.settings, ...params.settings };
   const fields = params.fields ?? existing.fields;
+  const specRows = buildSpecRows(params.formId, name, fields, settings);
   if (existing.isEncrypted) {
-    const summary = (await fetchMyForms()).find(
-      (f) => f.id === params.formId && f.pubkey === params.pubkey
-    );
     if (!summary?.signingKey || !summary?.viewKey) {
       throw new Error("Not the form owner or signing key unavailable");
     }
     const signingKeyBytes = hexToBytes3(summary.signingKey);
     const formSigner = makeSigningKeySigner(summary.signingKey);
     const viewPubkey = getPublicKey(hexToBytes3(summary.viewKey));
-    const fieldTags = fields.map(buildFieldTag);
-    const content = await formSigner.nip44Encrypt(viewPubkey, JSON.stringify(fieldTags));
-    const tags2 = [
-      ["d", params.formId],
-      ["name", name],
-      ["encryption", "view-key"],
-      ["settings", JSON.stringify(settings)]
-    ];
+    const content = await formSigner.nip44Encrypt(viewPubkey, JSON.stringify(specRows));
     const event2 = {
       kind: FORM_KINDS.template,
       created_at: Math.floor(Date.now() / 1e3),
-      tags: tags2,
+      tags: buildEncryptedOuterTags(params.formId, name, relays, settings),
       content
     };
     await nostrRuntime.publish(relays, finalizeEvent(event2, signingKeyBytes));
     return;
   }
-  const signer = await signerManager.getSigner();
-  const tags = [
-    ["d", params.formId],
-    ["name", name],
-    ["settings", JSON.stringify(settings)]
-  ];
-  for (const field of fields) tags.push(buildFieldTag(field));
-  if (settings.publicForm) tags.push(["t", "public"]);
+  const tags = [...specRows, ["t", "public"], ...relays.map((r) => ["relay", r])];
   const event = {
     kind: FORM_KINDS.template,
     created_at: Math.floor(Date.now() / 1e3),
     tags,
     content: ""
   };
+  if (summary?.signingKey) {
+    await nostrRuntime.publish(relays, finalizeEvent(event, hexToBytes3(summary.signingKey)));
+    return;
+  }
+  const signer = await signerManager.getSigner();
   await nostrRuntime.publish(relays, await signer.signEvent(event));
 }
 async function shareForm(params) {
@@ -31746,27 +32533,50 @@ async function shareForm(params) {
   const summary = (await fetchMyForms()).find(
     (f) => f.id === params.formId && f.pubkey === params.formPubkey
   );
-  if (!summary?.viewKey) {
-    throw new Error("Not the form owner or view key unavailable");
-  }
-  const coordinate = `${FORM_KINDS.template}:${params.formPubkey}:${params.formId}`;
-  const naddr = createRef("forms", FORM_KINDS.template, params.formPubkey, params.formId);
-  const signer = await signerManager.getSigner();
-  const rumor = {
-    kind: 14,
-    created_at: Math.floor(Date.now() / 1e3),
-    tags: [
-      ["a", coordinate],
-      ["viewKey", summary.viewKey]
-    ],
-    content: `Formstr form view key for ${naddr}`
-  };
+  if (!summary?.signingKey) {
+    throw new Error("Not the form owner or form keys unavailable");
+  }
+  const signingKeyBytes = hexToBytes3(summary.signingKey);
+  const signingPubkey = getPublicKey(signingKeyBytes);
+  const formSigner = new LocalSigner2(signingKeyBytes);
+  const now2 = () => Math.round(Date.now() / 1e3);
+  const editors = new Set(params.editors ?? []);
+  const targets = [.../* @__PURE__ */ new Set([...params.recipients, ...editors])];
   const failed = [];
   let published = 0;
-  for (const recipient of params.recipients) {
+  for (const recipient of targets) {
     try {
-      const wraps = await wrapManyEvents3(rumor, signer, [recipient]);
-      for (const wrap of wraps) await nostrRuntime.publish(relays, wrap);
+      const accessTags = [];
+      if (editors.has(recipient)) accessTags.push(["EditAccess", summary.signingKey]);
+      if (summary.viewKey) accessTags.push(["ViewAccess", summary.viewKey]);
+      const rumor = {
+        kind: 18,
+        pubkey: signingPubkey,
+        created_at: now2(),
+        content: "",
+        tags: accessTags
+      };
+      rumor.id = getEventHash(rumor);
+      const seal = finalizeEvent(
+        {
+          kind: 13,
+          content: await formSigner.nip44Encrypt(recipient, JSON.stringify(rumor)),
+          created_at: now2(),
+          tags: []
+        },
+        signingKeyBytes
+      );
+      const randomKey = generateSecretKey();
+      const wrap = finalizeEvent(
+        {
+          kind: 1059,
+          content: await new LocalSigner2(randomKey).nip44Encrypt(recipient, JSON.stringify(seal)),
+          created_at: now2(),
+          tags: [["p", accessGrantAlias(signingPubkey, params.formId, recipient)]]
+        },
+        randomKey
+      );
+      await nostrRuntime.publish(relays, wrap);
       published++;
     } catch {
       failed.push(recipient);
@@ -31790,32 +32600,32 @@ async function importForm(summary) {
   if (current.some((f) => f.id === summary.id && f.pubkey === summary.pubkey)) return;
   await saveToMyForms([...current, summary]);
 }
-function buildFieldTag(field) {
-  const options = field.options ? JSON.stringify(field.options.map((o) => [o.id, o.label])) : "[]";
-  const config2 = JSON.stringify({ required: field.required, placeholder: field.placeholder });
-  return ["field", field.id, field.type, field.label, options, config2];
-}
-function parseFormEvent(event) {
-  const dTag = event.tags.find((t) => t[0] === "d")?.[1] ?? "";
-  const nameTag = event.tags.find((t) => t[0] === "name")?.[1] ?? "Untitled";
-  const settingsTag = event.tags.find((t) => t[0] === "settings")?.[1];
+function parseFormEvent(event, decryptedRows) {
+  const merged = decryptedRows ? [...event.tags, ...decryptedRows] : event.tags;
+  const dTag = merged.find((t) => t[0] === "d")?.[1] ?? "";
+  const nameTag = merged.find((t) => t[0] === "name")?.[1] ?? "Untitled";
+  const settingsTag = merged.find((t) => t[0] === "settings")?.[1];
   const encTag = event.tags.find((t) => t[0] === "encryption")?.[1];
-  const fields = event.tags.filter((t) => t[0] === "field").map((t) => ({
-    id: t[1],
-    type: t[2],
-    label: t[3],
-    options: t[4] ? safeParseOptions(t[4]) : void 0,
-    required: t[5] ? JSON.parse(t[5])?.required : void 0
-  }));
-  const isEncrypted = encTag != null ? encTag === "view-key" : event.content.length > 0 && fields.length === 0;
+  const relays = event.tags.filter((t) => t[0] === "relay" && t[1]).map((t) => t[1]);
+  const fields = merged.filter((t) => t[0] === "field").map(parseFieldTag);
+  const outerHasFields = event.tags.some((t) => t[0] === "field");
+  const isEncrypted = encTag != null ? encTag === "view-key" : event.content.length > 0 && !outerHasFields;
+  let settings = {};
+  if (settingsTag) {
+    try {
+      settings = JSON.parse(settingsTag);
+    } catch {
+    }
+  }
   return {
     id: dTag,
     name: nameTag,
     fields,
-    settings: settingsTag ? JSON.parse(settingsTag) : {},
+    settings,
     pubkey: event.pubkey,
     createdAt: event.created_at,
     isEncrypted,
+    ...relays.length > 0 && { relays },
     event
   };
 }
@@ -31831,15 +32641,6 @@ function parseResponseEvent(event) {
     event
   };
 }
-function safeParseOptions(json) {
-  try {
-    const arr = JSON.parse(json);
-    if (!Array.isArray(arr)) return void 0;
-    return arr.map((o) => ({ id: o[0], label: o[1] }));
-  } catch {
-    return void 0;
-  }
-}
 
 // ../agent/src/services/calendar/service.ts
 var service_exports2 = {};
@@ -31854,9 +32655,14 @@ __export(service_exports2, {
   fetchCalendarLists: () => fetchCalendarLists,
   fetchDeletions: () => fetchDeletions,
   fetchInvitationsSync: () => fetchInvitationsSync,
+  fetchParticipantRemovals: () => fetchParticipantRemovals,
+  fetchRelayListsForPubkeys: () => fetchRelayListsForPubkeys,
+  getInvitationInboxRelays: () => getInvitationInboxRelays,
   isEventDeleted: () => isEventDeleted,
+  lookupEventViewKey: () => lookupEventViewKey,
   moveEventBetweenCalendarLists: () => moveEventBetweenCalendarLists,
   parseCalendarEvent: () => parseCalendarEvent,
+  publishParticipantRemovalEvent: () => publishParticipantRemovalEvent,
   publishPrivateCalendarEvent: () => publishPrivateCalendarEvent,
   publishPublicCalendarEvent: () => publishPublicCalendarEvent,
   removeEventFromCalendarList: () => removeEventFromCalendarList,
@@ -31873,6 +32679,7 @@ function encodeCalendarList(list) {
     ["content", list.description ?? ""],
     ["color", list.color]
   ];
+  if (list.notificationPreference === "disabled") tags.push(["notifications", "disabled"]);
   for (const ref of list.eventRefs) tags.push(["a", ...ref]);
   return tags;
 }
@@ -31880,6 +32687,7 @@ function decodeCalendarList(tags, dTag, eventId) {
   let title = DEFAULT_TITLE;
   let description = "";
   let color = DEFAULT_COLOR;
+  let notificationPreference;
   const eventRefs = [];
   for (const tag of tags) {
     if (!Array.isArray(tag) || tag.length === 0) continue;
@@ -31893,6 +32701,9 @@ function decodeCalendarList(tags, dTag, eventId) {
       case "color":
         color = tag[1] || DEFAULT_COLOR;
         break;
+      case "notifications":
+        notificationPreference = tag[1] === "disabled" ? "disabled" : "enabled";
+        break;
       case "a":
         if (tag[1] === "a") {
           const coord = tag[2] ?? "";
@@ -31911,7 +32722,8 @@ function decodeCalendarList(tags, dTag, eventId) {
     color,
     eventRefs,
     createdAt: 0,
-    isVisible: true
+    isVisible: true,
+    notificationPreference
   };
 }
 
@@ -31936,6 +32748,8 @@ var CALENDAR_KINDS = {
   rsvpGiftWrap: 1055,
   rsvpRumor: 55,
   participantRemoval: 84,
+  /** Public free/busy list, one per (user, YYYY-MM month). */
+  publicBusyList: 31926,
   // Appointment scheduling (Calendly-style booking links).
   schedulingPage: 31927,
   schedulingPagesList: 32680,
@@ -32181,13 +32995,14 @@ async function publishPrivateCalendarEvent(draft, calendarId) {
   const eventData = [
     ["title", draft.title],
     ["description", draft.description],
-    ["start", String(Math.floor(draft.begin.getTime() / 1e3))],
-    ["end", String(Math.floor(draft.end.getTime() / 1e3))],
+    ["start", Math.floor(draft.begin.getTime() / 1e3)],
+    ["end", Math.floor(draft.end.getTime() / 1e3)],
     ["d", eventId]
   ];
   if (draft.image) eventData.push(["image", draft.image]);
   if (draft.location) eventData.push(["location", draft.location]);
   for (const cat of draft.categories ?? []) eventData.push(["t", cat]);
+  eventData.push(["p", pubkey]);
   for (const p of draft.participants ?? []) eventData.push(["p", p]);
   if (draft.startTzid) eventData.push(["start_tzid", draft.startTzid]);
   if (draft.endTzid) eventData.push(["end_tzid", draft.endTzid]);
@@ -32195,7 +33010,12 @@ async function publishPrivateCalendarEvent(draft, calendarId) {
     eventData.push(["L", "rrule"]);
     eventData.push(["l", draft.rrule]);
   }
-  if (draft.registrationFormRef) eventData.push(["form", draft.registrationFormRef]);
+  if (draft.notificationPreference) eventData.push(["notification", draft.notificationPreference]);
+  if (draft.registrationFormRef) {
+    eventData.push(
+      draft.registrationFormViewKey ? ["form", draft.registrationFormRef, draft.registrationFormViewKey] : ["form", draft.registrationFormRef]
+    );
+  }
   const viewKeyNsec = draft.viewKey ?? generateViewKey().nsec;
   const content = await encryptWithViewKey(viewKeyNsec, JSON.stringify(eventData));
   const event = {
@@ -32210,6 +33030,7 @@ async function publishPrivateCalendarEvent(draft, calendarId) {
   const relayHint = relays[0] ?? "";
   const coordinate = `${CALENDAR_KINDS.privateEvent}:${pubkey}:${eventId}`;
   if (draft.participants?.length) {
+    const relayLists = await fetchRelayListsForPubkeys(draft.participants);
     for (const participant of draft.participants) {
       const wrap = await wrapEvent3(
         {
@@ -32224,7 +33045,7 @@ async function publishPrivateCalendarEvent(draft, calendarId) {
         participant,
         CALENDAR_KINDS.giftWrap
       );
-      await nostrRuntime.publish(relays, wrap);
+      await nostrRuntime.publish(relayLists.get(participant) ?? relays, wrap);
     }
   }
   return {
@@ -32250,9 +33071,37 @@ async function publishPrivateCalendarEvent(draft, calendarId) {
     startTzid: draft.startTzid,
     endTzid: draft.endTzid,
     registrationFormRef: draft.registrationFormRef,
+    registrationFormViewKey: draft.registrationFormViewKey,
+    notificationPreference: draft.notificationPreference,
     event: signed
   };
 }
+async function fetchRelayListsForPubkeys(pubkeys) {
+  const result = /* @__PURE__ */ new Map();
+  if (pubkeys.length === 0) return result;
+  const relays = relayManager.getRelaysForModule("calendar");
+  const events = await nostrRuntime.querySync(relays, { kinds: [10002], authors: pubkeys });
+  const newest = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const prev = newest.get(event.pubkey);
+    if (!prev || event.created_at > prev.created_at) newest.set(event.pubkey, event);
+  }
+  for (const [pubkey, event] of newest) {
+    const urls = event.tags.filter((t) => t[0] === "r" && t[1]).map((t) => t[1]);
+    if (urls.length > 0) result.set(pubkey, urls);
+  }
+  return result;
+}
+async function getInvitationInboxRelays(pubkey) {
+  const relays = relayManager.getRelaysForModule("calendar");
+  try {
+    const configs = await relayManager.fetchUserRelays(pubkey);
+    const readRelays = configs.filter((c) => c.read).map((c) => c.url);
+    return [.../* @__PURE__ */ new Set([...relays, ...readRelays])];
+  } catch {
+    return relays;
+  }
+}
 function subscribeToCalendarEvents(params, onEvent, onEose) {
   const relays = relayManager.getRelaysForModule("calendar");
   const filter = {
@@ -32539,6 +33388,42 @@ async function deleteCalendarList(coordinate) {
   const relays = relayManager.getRelaysForModule("calendar");
   await nostrRuntime.publish(relays, signed);
 }
+async function publishParticipantRemovalEvent({
+  kinds,
+  eventIds = [],
+  coordinates = [],
+  reason = ""
+}) {
+  const signer = await signerManager.getSigner();
+  const tags = [];
+  for (const id of eventIds) tags.push(["e", id]);
+  for (const coord of coordinates) tags.push(["a", coord]);
+  for (const kind of kinds) tags.push(["k", String(kind)]);
+  const event = {
+    kind: CALENDAR_KINDS.participantRemoval,
+    created_at: Math.floor(Date.now() / 1e3),
+    tags,
+    content: reason
+  };
+  const signed = await signer.signEvent(event);
+  const relays = relayManager.getRelaysForModule("calendar");
+  await nostrRuntime.publish(relays, signed);
+}
+async function fetchParticipantRemovals(pubkey, relays = relayManager.getRelaysForModule("calendar")) {
+  const ids = /* @__PURE__ */ new Set();
+  const coordinates = /* @__PURE__ */ new Set();
+  const events = await nostrRuntime.querySync(relays, {
+    kinds: [CALENDAR_KINDS.participantRemoval],
+    authors: [pubkey]
+  });
+  for (const ev of events) {
+    for (const tag of ev.tags) {
+      if (tag[0] === "e" && tag[1]) ids.add(tag[1]);
+      else if (tag[0] === "a" && tag[1]) coordinates.add(tag[1]);
+    }
+  }
+  return { ids, coordinates };
+}
 async function parseCalendarEvent(event, viewKey) {
   const dTag = event.tags.find((t) => t[0] === "d")?.[1] ?? "";
   const isPrivate = event.kind !== CALENDAR_KINDS.publicEvent;
@@ -32566,7 +33451,10 @@ async function parseCalendarEvent(event, viewKey) {
   const rrule = tags.find((t) => t[0] === "l" && t[2] === "rrule")?.[1] ?? (hasRruleLabel ? tags.find((t) => t[0] === "l")?.[1] : void 0) ?? tags.find((t) => t[0] === "rrule")?.[1] ?? null;
   const startTzid = tags.find((t) => t[0] === "start_tzid")?.[1];
   const endTzid = tags.find((t) => t[0] === "end_tzid")?.[1];
-  const registrationFormRef = tags.find((t) => t[0] === "form")?.[1];
+  const formTag = tags.find((t) => t[0] === "form");
+  const registrationFormRef = formTag?.[1];
+  const registrationFormViewKey = formTag?.[2];
+  const notificationPreference = tags.find((t) => t[0] === "notification")?.[1];
   return {
     id: dTag,
     eventId: event.id,
@@ -32588,13 +33476,16 @@ async function parseCalendarEvent(event, viewKey) {
     startTzid,
     endTzid,
     registrationFormRef,
+    registrationFormViewKey,
+    notificationPreference,
     event
   };
 }
 async function fetchInvitationsSync() {
   const signer = await signerManager.getSigner();
   const pubkey = await signer.getPublicKey();
-  const relays = relayManager.getRelaysForModule("calendar");
+  const relays = await getInvitationInboxRelays(pubkey);
+  const removals = await fetchParticipantRemovals(pubkey, relays);
   const wraps = await nostrRuntime.querySync(relays, {
     kinds: [CALENDAR_KINDS.giftWrap, CALENDAR_KINDS.rsvpGiftWrap],
     "#p": [pubkey]
@@ -32602,7 +33493,7 @@ async function fetchInvitationsSync() {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
   for (const wrap of wraps) {
-    if (seen.has(wrap.id)) continue;
+    if (seen.has(wrap.id) || removals.ids.has(wrap.id)) continue;
     seen.add(wrap.id);
     const invitation = await extractInvitationFromWrap(wrap);
     if (!invitation) continue;
@@ -32614,6 +33505,15 @@ async function fetchInvitationsSync() {
   }
   return out;
 }
+async function lookupEventViewKey(eventCoordinate) {
+  const lists = await fetchCalendarLists();
+  for (const list of lists) {
+    for (const ref of list.eventRefs) {
+      if (ref[0] === eventCoordinate && ref[2]) return ref[2];
+    }
+  }
+  return void 0;
+}
 
 // ../agent/src/services/calendar/booking.ts
 var booking_exports = {};
@@ -32624,6 +33524,122 @@ __export(booking_exports, {
   fetchBookingRequests: () => fetchBookingRequests,
   fetchSchedulingPages: () => fetchSchedulingPages
 });
+
+// ../agent/src/services/calendar/busyList.ts
+var MONTH_KEY_RE = /^\d{4}-\d{2}$/;
+function busyListMonthKey(value) {
+  const d = typeof value === "number" ? new Date(value) : value;
+  const month = String(d.getUTCMonth() + 1).padStart(2, "0");
+  return `${d.getUTCFullYear()}-${month}`;
+}
+function busyListMonthKeysForRange(startMs, endMs) {
+  if (!Number.isFinite(startMs) || !Number.isFinite(endMs)) return [];
+  const start = Math.min(startMs, endMs);
+  const end = Math.max(startMs, endMs);
+  const keys = [];
+  const cursor = new Date(
+    Date.UTC(new Date(start).getUTCFullYear(), new Date(start).getUTCMonth(), 1)
+  );
+  const endMonth = new Date(
+    Date.UTC(new Date(end).getUTCFullYear(), new Date(end).getUTCMonth(), 1)
+  );
+  while (cursor.getTime() <= endMonth.getTime()) {
+    keys.push(busyListMonthKey(cursor));
+    cursor.setUTCMonth(cursor.getUTCMonth() + 1);
+  }
+  return keys;
+}
+function busyListToTags(list) {
+  const tags = [
+    ["d", list.monthKey],
+    ["t", list.monthKey],
+    ["t", "busy"]
+  ];
+  for (const r of list.ranges) {
+    tags.push(["block", String(Math.floor(r.start / 1e3)), String(Math.floor(r.end / 1e3))]);
+  }
+  return tags;
+}
+function parseBusyListEvent(event) {
+  const dTag = event.tags.find((t) => t[0] === "d")?.[1] ?? "";
+  if (!MONTH_KEY_RE.test(dTag)) return null;
+  const ranges = [];
+  for (const tag of event.tags) {
+    if (tag[0] !== "block") continue;
+    const start = Number(tag[1]) * 1e3;
+    const end = Number(tag[2]) * 1e3;
+    if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start) continue;
+    ranges.push({ start, end });
+  }
+  ranges.sort((a, b) => a.start - b.start || a.end - b.end);
+  const deduped = [];
+  for (const r of ranges) {
+    const last = deduped[deduped.length - 1];
+    if (last && last.start === r.start && last.end === r.end) continue;
+    deduped.push(r);
+  }
+  return {
+    user: event.pubkey,
+    monthKey: dTag,
+    ranges: deduped,
+    eventId: event.id,
+    createdAt: event.created_at
+  };
+}
+async function fetchBusyListsForUser(pubkey, monthKeys) {
+  if (monthKeys.length === 0) return [];
+  const relays = relayManager.getRelaysForModule("calendar");
+  const events = await nostrRuntime.querySync(relays, {
+    kinds: [CALENDAR_KINDS.publicBusyList],
+    authors: [pubkey],
+    "#d": monthKeys
+  });
+  const newestPerMonth = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const list = parseBusyListEvent(event);
+    if (!list) continue;
+    const prev = newestPerMonth.get(list.monthKey);
+    if (!prev || list.createdAt > prev.createdAt) newestPerMonth.set(list.monthKey, list);
+  }
+  return [...newestPerMonth.values()];
+}
+async function publishBusyList(list) {
+  const signer = await signerManager.getSigner();
+  const event = {
+    kind: CALENDAR_KINDS.publicBusyList,
+    created_at: Math.floor(Date.now() / 1e3),
+    tags: busyListToTags(list),
+    content: ""
+  };
+  const signed = await signer.signEvent(event);
+  const relays = relayManager.getRelaysForModule("calendar");
+  await nostrRuntime.publish(relays, signed);
+}
+var sameRange = (a, b) => a.start === b.start && a.end === b.end;
+async function addBusyRange(range) {
+  const signer = await signerManager.getSigner();
+  const pubkey = await signer.getPublicKey();
+  const monthKeys = busyListMonthKeysForRange(range.start, range.end);
+  const existing = new Map(
+    (await fetchBusyListsForUser(pubkey, monthKeys)).map((l) => [l.monthKey, l])
+  );
+  for (const monthKey of monthKeys) {
+    const list = existing.get(monthKey) ?? {
+      user: pubkey,
+      monthKey,
+      ranges: [],
+      eventId: "",
+      createdAt: 0
+    };
+    if (list.ranges.some((r) => sameRange(r, range))) continue;
+    const ranges = [...list.ranges, { start: range.start, end: range.end }].sort(
+      (a, b) => a.start - b.start || a.end - b.end
+    );
+    await publishBusyList({ ...list, ranges });
+  }
+}
+
+// ../agent/src/services/calendar/booking.ts
 var BOOKING_HOST = "https://calendar.formstr.app";
 async function fetchSchedulingPages() {
   const signer = await signerManager.getSigner();
@@ -32782,6 +33798,10 @@ async function approveBookingRequest(request, calendar) {
     event.viewKey ?? request.viewKey ?? ""
   ];
   const updatedCalendar = await addEventToCalendarList(calendar, eventRef);
+  try {
+    await addBusyRange({ start: request.start, end: request.end });
+  } catch {
+  }
   await sendBookingResponse({
     schedulingPageRef: request.schedulingPageRef,
     bookerPubkey: request.bookerPubkey,
@@ -32809,7 +33829,9 @@ var service_exports3 = {};
 __export(service_exports3, {
   addSharedPage: () => addSharedPage,
   deletePage: () => deletePage,
+  fetchAllDocMetadata: () => fetchAllDocMetadata,
   fetchDeletions: () => fetchDeletions2,
+  fetchDocMetadata: () => fetchDocMetadata,
   fetchDocTags: () => fetchDocTags,
   fetchMyPages: () => fetchMyPages,
   fetchPage: () => fetchPage,
@@ -32817,17 +33839,22 @@ __export(service_exports3, {
   fetchSharedPages: () => fetchSharedPages,
   generateShareLink: () => generateShareLink,
   isPageDeleted: () => isPageDeleted,
+  saveDocMetadata: () => saveDocMetadata,
   savePage: () => savePage,
-  saveSharedList: () => saveSharedList,
+  setDocSharedAs: () => setDocSharedAs,
   setDocTags: () => setDocTags,
+  setDocTitle: () => setDocTitle,
   sharePage: () => sharePage
 });
 
 // ../agent/src/services/pages/types.ts
 var PAGES_KINDS = {
   document: 33457,
+  /** Legacy super-app shared-with-me list — read-only migration source; upstream
+   *  (nostr-docs) has no such kind. Shares now live in kind-34579 doc metadata. */
   sharedPagesList: 11234,
   docMetadata: 34579,
+  comment: 1494,
   crdtOp: 22457
 };
 
@@ -32894,6 +33921,7 @@ async function fetchMyPages(viewKeys) {
     authors: [pubkey]
   });
   const deletions = await fetchDeletions2(relays, [pubkey]);
+  const metadata = await fetchAllDocMetadata().catch(() => /* @__PURE__ */ new Map());
   const newest = /* @__PURE__ */ new Map();
   for (const ev of events) {
     if (isPageDeleted(ev, deletions)) continue;
@@ -32904,15 +33932,18 @@ async function fetchMyPages(viewKeys) {
   const summaries = [];
   for (const [dTag, ev] of newest) {
     const address = `${PAGES_KINDS.document}:${ev.pubkey}:${dTag}`;
-    let title = `Document ${dTag}`;
-    try {
-      title = extractTitle(await nip44SelfDecrypt(signer, ev.content));
-    } catch {
-      const vk = viewKeys?.get(address);
-      if (vk) {
-        try {
-          title = extractTitle(await decryptWithViewKey2(vk, ev.content));
-        } catch {
+    const meta = metadata.get(address);
+    const viewKey = meta?.viewKey ?? viewKeys?.get(address);
+    let title = meta?.title || `Document ${dTag}`;
+    if (!meta?.title) {
+      try {
+        title = extractTitle(await nip44SelfDecrypt(signer, ev.content));
+      } catch {
+        if (viewKey) {
+          try {
+            title = extractTitle(await decryptWithViewKey2(viewKey, ev.content));
+          } catch {
+          }
         }
       }
     }
@@ -32923,7 +33954,9 @@ async function fetchMyPages(viewKeys) {
       pubkey: ev.pubkey,
       createdAt: ev.created_at,
       isEncrypted: ev.content.length > 0,
-      viewKey: viewKeys?.get(address)
+      viewKey,
+      ...Array.isArray(meta?.tags) && meta.tags.length > 0 ? { tags: meta.tags } : {},
+      ...meta?.sharedAs ? { sharedAs: meta.sharedAs } : {}
     });
   }
   return summaries;
@@ -32943,6 +33976,17 @@ async function fetchPage(pubkey, docId, viewKey) {
     decrypted = true;
   } catch {
   }
+  if (!decrypted && !viewKey) {
+    try {
+      const meta = await fetchDocMetadata(`${PAGES_KINDS.document}:${pubkey}:${docId}`);
+      if (meta?.viewKey) {
+        content = await decryptWithViewKey2(meta.viewKey, event.content);
+        viewKey = meta.viewKey;
+        decrypted = true;
+      }
+    } catch {
+    }
+  }
   return {
     id: docId,
     address: `${PAGES_KINDS.document}:${event.pubkey}:${docId}`,
@@ -32957,12 +34001,24 @@ async function fetchPage(pubkey, docId, viewKey) {
 }
 async function deletePage(address) {
   const signer = await signerManager.getSigner();
+  const [kindStr, pubkey, dTag] = address.split(":");
+  let versionIds = [];
+  try {
+    const versions = await nostrRuntime.querySync(RELAYS(), {
+      kinds: [Number(kindStr)],
+      authors: [pubkey],
+      "#d": [dTag]
+    });
+    versionIds = versions.map((v) => v.id);
+  } catch {
+  }
   const event = {
     kind: 5,
     created_at: Math.floor(Date.now() / 1e3),
     tags: [
       ["a", address],
-      ["k", String(PAGES_KINDS.document)]
+      ["k", String(PAGES_KINDS.document)],
+      ...versionIds.map((id) => ["e", id])
     ],
     content: "Deleted via Formstr"
   };
@@ -33003,9 +34059,16 @@ function generateShareLink(address, viewKey, editKey) {
 }
 async function sharePage(params) {
   const signer = await signerManager.getSigner();
-  const [, , dTag] = params.address.split(":");
-  const viewKeyHex = params.viewKey ?? generateViewKey2().hex;
-  const editKeyHex = params.canEdit ? params.editKey ?? generateViewKey2().hex : void 0;
+  const [, ownerPubkey, dTag] = params.address.split(":");
+  const originalMeta = await fetchDocMetadata(params.address).catch(() => void 0);
+  if (params.canEdit && originalMeta?.sharedAs) {
+    const sharedMeta = await fetchDocMetadata(originalMeta.sharedAs).catch(() => void 0);
+    if (sharedMeta?.viewKey && sharedMeta.editKey) {
+      return generateShareLink(originalMeta.sharedAs, sharedMeta.viewKey, sharedMeta.editKey);
+    }
+  }
+  const viewKeyHex = params.viewKey ?? originalMeta?.viewKey ?? generateViewKey2().hex;
+  const editKeyHex = params.canEdit ? params.editKey ?? originalMeta?.editKey ?? generateViewKey2().hex : void 0;
   const encrypted = await encryptWithViewKey2(viewKeyHex, params.content);
   const template = {
     kind: PAGES_KINDS.document,
@@ -33016,9 +34079,36 @@ async function sharePage(params) {
   const signed = editKeyHex ? finalizeEvent(template, hexToBytes4(editKeyHex)) : await signer.signEvent(template);
   await nostrRuntime.publish(RELAYS(), signed);
   const newAddress = `${PAGES_KINDS.document}:${signed.pubkey}:${dTag}`;
+  await saveDocMetadata(newAddress, {
+    viewKey: viewKeyHex,
+    ...editKeyHex ? { editKey: editKeyHex } : {}
+  });
+  if (editKeyHex && ownerPubkey === await signer.getPublicKey()) {
+    await saveDocMetadata(params.address, { sharedAs: newAddress });
+  }
   return generateShareLink(newAddress, viewKeyHex, editKeyHex);
 }
 async function fetchSharedList() {
+  const metadata = await fetchAllDocMetadata();
+  const entries = [];
+  for (const [address, meta] of metadata) {
+    if (typeof meta.viewKey !== "string" || !meta.viewKey) continue;
+    entries.push(
+      typeof meta.editKey === "string" && meta.editKey ? [address, meta.viewKey, meta.editKey] : [address, meta.viewKey]
+    );
+  }
+  for (const entry of await fetchLegacySharedList()) {
+    const [address, viewKey, editKey] = entry;
+    if (metadata.get(address)?.viewKey) continue;
+    entries.push(entry);
+    try {
+      await saveDocMetadata(address, { viewKey, ...editKey ? { editKey } : {} });
+    } catch {
+    }
+  }
+  return entries;
+}
+async function fetchLegacySharedList() {
   const signer = await signerManager.getSigner();
   const pubkey = await signer.getPublicKey();
   const events = await nostrRuntime.querySync(RELAYS(), {
@@ -33034,30 +34124,19 @@ async function fetchSharedList() {
   }
   return [];
 }
-async function saveSharedList(entries) {
-  const signer = await signerManager.getSigner();
-  const content = await nip44SelfEncrypt(signer, JSON.stringify(entries));
-  const signed = await signer.signEvent({
-    kind: PAGES_KINDS.sharedPagesList,
-    created_at: Math.floor(Date.now() / 1e3),
-    tags: [],
-    content
-  });
-  await nostrRuntime.publish(RELAYS(), signed);
-}
 async function addSharedPage(entry) {
-  const existing = await fetchSharedList();
-  const next = existing.filter((e) => e[0] !== entry[0]);
-  next.push(entry);
-  await saveSharedList(next);
-  return next;
+  const [address, viewKey, editKey] = entry;
+  await saveDocMetadata(address, { viewKey, ...editKey ? { editKey } : {} });
 }
 async function fetchSharedPages() {
+  const signer = await signerManager.getSigner();
+  const userPubkey = await signer.getPublicKey();
   const entries = await fetchSharedList();
   const out = [];
   for (const [address, viewKey, editKey] of entries) {
     const [, pubkey, dTag] = address.split(":");
     if (!pubkey || !dTag) continue;
+    if (pubkey === userPubkey) continue;
     const doc = await fetchPage(pubkey, dTag, viewKey);
     if (!doc) continue;
     out.push({
@@ -33074,15 +34153,19 @@ async function fetchSharedPages() {
   }
   return out;
 }
-async function fetchDocTags(addresses) {
-  const result = /* @__PURE__ */ new Map();
-  if (addresses.length === 0) return result;
+function parseMetadataJson(json) {
+  const parsed = JSON.parse(json);
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    return parsed;
+  }
+  return void 0;
+}
+async function fetchAllDocMetadata() {
   const signer = await signerManager.getSigner();
   const pubkey = await signer.getPublicKey();
   const events = await nostrRuntime.querySync(RELAYS(), {
     kinds: [PAGES_KINDS.docMetadata],
-    authors: [pubkey],
-    "#d": addresses
+    authors: [pubkey]
   });
   const newest = /* @__PURE__ */ new Map();
   for (const ev of events) {
@@ -33090,18 +34173,37 @@ async function fetchDocTags(addresses) {
     const prev = newest.get(addr);
     if (!prev || ev.created_at > prev.created_at) newest.set(addr, ev);
   }
+  const result = /* @__PURE__ */ new Map();
   for (const [addr, ev] of newest) {
     try {
-      const parsed = JSON.parse(await nip44SelfDecrypt(signer, ev.content));
-      if (Array.isArray(parsed.tags)) result.set(addr, parsed.tags);
+      const meta = parseMetadataJson(await nip44SelfDecrypt(signer, ev.content));
+      if (meta) result.set(addr, meta);
     } catch {
     }
   }
   return result;
 }
-async function setDocTags(address, tags) {
+async function fetchDocMetadata(address) {
+  const signer = await signerManager.getSigner();
+  const pubkey = await signer.getPublicKey();
+  const events = await nostrRuntime.querySync(RELAYS(), {
+    kinds: [PAGES_KINDS.docMetadata],
+    authors: [pubkey],
+    "#d": [address]
+  });
+  if (events.length === 0) return void 0;
+  const newest = events.reduce((a, b) => b.created_at > a.created_at ? b : a);
+  try {
+    return parseMetadataJson(await nip44SelfDecrypt(signer, newest.content));
+  } catch {
+    return void 0;
+  }
+}
+async function saveDocMetadata(address, patch) {
+  const existing = await fetchDocMetadata(address) ?? {};
+  const merged = { ...existing, ...patch };
   const signer = await signerManager.getSigner();
-  const content = await nip44SelfEncrypt(signer, JSON.stringify({ tags }));
+  const content = await nip44SelfEncrypt(signer, JSON.stringify(merged));
   const signed = await signer.signEvent({
     kind: PAGES_KINDS.docMetadata,
     created_at: Math.floor(Date.now() / 1e3),
@@ -33109,6 +34211,41 @@ async function setDocTags(address, tags) {
     content
   });
   await nostrRuntime.publish(RELAYS(), signed);
+  return merged;
+}
+async function fetchDocTags(addresses) {
+  const result = /* @__PURE__ */ new Map();
+  if (addresses.length === 0) return result;
+  const signer = await signerManager.getSigner();
+  const pubkey = await signer.getPublicKey();
+  const events = await nostrRuntime.querySync(RELAYS(), {
+    kinds: [PAGES_KINDS.docMetadata],
+    authors: [pubkey],
+    "#d": addresses
+  });
+  const newest = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    const addr = ev.tags.find((t) => t[0] === "d")?.[1] ?? "";
+    const prev = newest.get(addr);
+    if (!prev || ev.created_at > prev.created_at) newest.set(addr, ev);
+  }
+  for (const [addr, ev] of newest) {
+    try {
+      const meta = parseMetadataJson(await nip44SelfDecrypt(signer, ev.content));
+      if (meta && Array.isArray(meta.tags)) result.set(addr, meta.tags);
+    } catch {
+    }
+  }
+  return result;
+}
+async function setDocTags(address, tags) {
+  await saveDocMetadata(address, { tags });
+}
+async function setDocTitle(address, title) {
+  await saveDocMetadata(address, { title: title || void 0 });
+}
+async function setDocSharedAs(address, sharedAs) {
+  await saveDocMetadata(address, { sharedAs });
 }
 function extractTitle(markdown) {
   const firstLine = markdown.trim().split("\n")[0] ?? "";
@@ -33123,11 +34260,82 @@ function randomId(length) {
   return result;
 }
 
+// ../agent/src/services/pages/comments.ts
+var comments_exports = {};
+__export(comments_exports, {
+  fetchPageComments: () => fetchPageComments,
+  parsePageComment: () => parsePageComment,
+  publishPageComment: () => publishPageComment
+});
+var RELAYS2 = () => relayManager.getRelaysForModule("pages");
+async function publishPageComment(draft, viewKey, docAddress, docEventId) {
+  const signer = await signerManager.getSigner();
+  const innerTags = [
+    ["content", draft.content],
+    ["type", draft.type]
+  ];
+  if (draft.quote !== void 0) innerTags.push(["quote", draft.quote]);
+  if (draft.context !== void 0) {
+    innerTags.push(["context", draft.context.prefix, draft.context.suffix]);
+  }
+  const docOwnerPubkey = docAddress.split(":")[1];
+  const event = {
+    kind: PAGES_KINDS.comment,
+    created_at: Math.floor(Date.now() / 1e3),
+    content: await encryptWithViewKey2(viewKey, JSON.stringify(innerTags)),
+    tags: [
+      ["a", docAddress],
+      ["e", docEventId],
+      ["p", docOwnerPubkey]
+    ]
+  };
+  const signed = await signer.signEvent(event);
+  await nostrRuntime.publish(RELAYS2(), signed);
+  return signed;
+}
+async function parsePageComment(event, viewKey) {
+  try {
+    const inner = JSON.parse(await decryptWithViewKey2(viewKey, event.content));
+    if (!Array.isArray(inner)) return void 0;
+    const rows = inner;
+    const find = (name) => rows.find((r) => Array.isArray(r) && r[0] === name);
+    const content = find("content")?.[1];
+    if (typeof content !== "string") return void 0;
+    const type = find("type")?.[1] === "suggestion" ? "suggestion" : "comment";
+    const quote = find("quote")?.[1];
+    const contextRow = find("context");
+    return {
+      id: event.id,
+      author: event.pubkey,
+      createdAt: event.created_at,
+      content,
+      type,
+      ...quote !== void 0 ? { quote } : {},
+      ...contextRow ? { context: { prefix: contextRow[1] ?? "", suffix: contextRow[2] ?? "" } } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function fetchPageComments(docAddress, viewKey) {
+  const events = await nostrRuntime.querySync(RELAYS2(), {
+    kinds: [PAGES_KINDS.comment],
+    "#a": [docAddress]
+  });
+  const out = [];
+  for (const event of events) {
+    const comment = await parsePageComment(event, viewKey);
+    if (comment) out.push(comment);
+  }
+  return out.sort((a, b) => a.createdAt - b.createdAt);
+}
+
 // ../agent/src/services/drive/service.ts
 var service_exports4 = {};
 __export(service_exports4, {
   deleteFile: () => deleteFile,
   downloadFile: () => downloadFile,
+  downloadPreview: () => downloadPreview,
   extractFolders: () => extractFolders,
   fetchBlossomServers: () => fetchBlossomServers,
   fetchFileIndex: () => fetchFileIndex,
@@ -33143,8 +34351,8 @@ var DRIVE_KINDS = {
   fileMetadata: 34578
 };
 var DEFAULT_BLOSSOM_SERVERS = [
-  "https://blossom.primal.net",
   "https://nostr.download",
+  "https://blossom.primal.net",
   "https://blossom.oxtr.dev"
 ];
 
@@ -33159,6 +34367,21 @@ async function uploadFile(params) {
   const authEvent = await createBlossomAuthEvent("upload", await sha256Hex2(encryptedBytes), signer);
   const blossom = new BlossomClient(server);
   const result = await blossom.upload(encryptedBytes, authEvent, params.file.type);
+  let previewHash;
+  if (params.preview) {
+    try {
+      const encryptedPreview = new TextEncoder().encode(
+        await encryptFileWithExistingKey(params.preview, privateKeyHex)
+      );
+      const previewAuth = await createBlossomAuthEvent(
+        "upload",
+        await sha256Hex2(encryptedPreview),
+        signer
+      );
+      previewHash = (await blossom.upload(encryptedPreview, previewAuth, "image/webp")).sha256;
+    } catch {
+    }
+  }
   const metadata = {
     name: params.file.name,
     hash: result.sha256,
@@ -33167,11 +34390,26 @@ async function uploadFile(params) {
     folder: params.folder ?? "/",
     uploadedAt: Date.now(),
     server,
-    encryptionKey: privateKeyHex
+    ...previewHash ? { previewHash } : {},
+    encryptionKey: privateKeyHex,
+    encryptionAlgorithm: "aes-gcm"
   };
   await saveFileMetadata(metadata);
   return metadata;
 }
+async function downloadPreview(metadata) {
+  if (!metadata.previewHash) return null;
+  const blossom = new BlossomClient(metadata.server);
+  let authEvent;
+  try {
+    const signer = await signerManager.getSigner();
+    authEvent = await createBlossomAuthEvent("get", metadata.previewHash, signer);
+  } catch {
+  }
+  const encryptedBytes = await blossom.download(metadata.previewHash, authEvent);
+  const ciphertext = new TextDecoder().decode(encryptedBytes);
+  return decryptFileWithKey(ciphertext, metadata.encryptionKey);
+}
 async function downloadFile(metadata) {
   const blossom = new BlossomClient(metadata.server);
   let authEvent;
@@ -33215,7 +34453,11 @@ async function fetchFileIndex() {
 }
 async function saveFileMetadata(metadata) {
   const signer = await signerManager.getSigner();
-  const encrypted = await nip44SelfEncrypt(signer, JSON.stringify(metadata));
+  const full = {
+    ...metadata,
+    encryptionAlgorithm: metadata.encryptionAlgorithm ?? "aes-gcm"
+  };
+  const encrypted = await nip44SelfEncrypt(signer, JSON.stringify(full));
   const event = {
     kind: DRIVE_KINDS.fileMetadata,
     created_at: Math.floor(Date.now() / 1e3),
@@ -33311,6 +34553,28 @@ __export(service_exports5, {
   submitPollResponse: () => submitPollResponse
 });
 
+// ../agent/src/services/polls/pow.ts
+function minePollEvent(unsigned, difficulty) {
+  const event = unsigned;
+  const nonceTag = ["nonce", "0", difficulty.toString()];
+  event.tags.push(nonceTag);
+  event.tags.push(["W", difficulty.toString()]);
+  let count = 0;
+  for (; ; ) {
+    const now2 = Math.floor(Date.now() / 1e3);
+    if (now2 !== event.created_at) {
+      count = 0;
+      event.created_at = now2;
+    }
+    nonceTag[1] = (++count).toString();
+    event.id = getEventHash(event);
+    if (nip13_exports.getPow(event.id) >= difficulty) return event;
+  }
+}
+function hasValidPow(event, difficulty) {
+  return nip13_exports.getPow(event.id) >= difficulty;
+}
+
 // ../agent/src/services/polls/types.ts
 var POLLS_KINDS = {
   poll: 1068,
@@ -33365,7 +34629,7 @@ async function createPoll(draft) {
 function withModuleRelays(pollRelays) {
   return Array.from(/* @__PURE__ */ new Set([...pollRelays ?? [], ...relayManager.getRelaysForModule("polls")]));
 }
-async function submitPollResponse(pollId, pollAuthor, selectedOptionIds, pollRelays) {
+async function submitPollResponse(pollId, pollAuthor, selectedOptionIds, pollRelays, powDifficulty) {
   const signer = await signerManager.getSigner();
   const relays = withModuleRelays(pollRelays);
   const tags = [
@@ -33375,12 +34639,22 @@ async function submitPollResponse(pollId, pollAuthor, selectedOptionIds, pollRel
   for (const optionId of selectedOptionIds) {
     tags.push(["response", optionId]);
   }
-  const event = {
+  let event = {
     kind: POLLS_KINDS.response,
     created_at: Math.floor(Date.now() / 1e3),
     tags,
     content: ""
   };
+  if (powDifficulty && powDifficulty > 0) {
+    const unsigned = { ...event, pubkey: await signer.getPublicKey() };
+    const mined = minePollEvent(unsigned, powDifficulty);
+    event = {
+      kind: mined.kind,
+      created_at: mined.created_at,
+      tags: mined.tags,
+      content: mined.content
+    };
+  }
   const signed = await signer.signEvent(event);
   await nostrRuntime.publish(relays, signed);
 }
@@ -33428,11 +34702,12 @@ async function fetchPoll(eventId) {
 function resultRelays(poll) {
   return withModuleRelays(poll.relays);
 }
-function latestResponsesByVoter(events, deleted) {
+function latestResponsesByVoter(events, deleted, powDifficulty = 0) {
   const latest = /* @__PURE__ */ new Map();
   for (const e of events) {
     if (isPollDeleted(e, deleted)) continue;
     if (!e.tags.some((t) => t[0] === "response")) continue;
+    if (powDifficulty > 0 && !hasValidPow(e, powDifficulty)) continue;
     const prev = latest.get(e.pubkey);
     if (!prev || e.created_at > prev.created_at) latest.set(e.pubkey, e);
   }
@@ -33450,11 +34725,13 @@ async function fetchPollResults(poll) {
   const events = await nostrRuntime.querySync(relays, {
     kinds: [POLLS_KINDS.response, POLLS_KINDS.responseLegacy],
     "#e": [poll.id],
-    ...poll.endsAt ? { until: poll.endsAt } : {}
+    ...poll.endsAt ? { until: poll.endsAt } : {},
+    // PoW polls: upstream queries votes by their ["W", difficulty] tag.
+    ...poll.powDifficulty ? { "#W": [String(poll.powDifficulty)] } : {}
   });
   const authors = Array.from(new Set(events.map((e) => e.pubkey)));
   const deleted = await fetchDeletions3(relays, authors);
-  return computeResults(latestResponsesByVoter(events, deleted));
+  return computeResults(latestResponsesByVoter(events, deleted, poll.powDifficulty ?? 0));
 }
 async function fetchRecentPolls(limit = 20) {
   const relays = relayManager.getRelaysForModule("polls");
@@ -33523,7 +34800,7 @@ function computeResults(responses) {
   for (const [pubkey, selected] of responses) {
     for (const optionId of selected) {
       const existing = counts.get(optionId) ?? [];
-      existing.push(pubkey);
+      if (!existing.includes(pubkey)) existing.push(pubkey);
       counts.set(optionId, existing);
     }
   }
@@ -33816,11 +35093,12 @@ function buildCalendarTools() {
   server.registerTool(
     "rsvp_event",
     {
-      description: "RSVP to a calendar event on your identity. Optionally suggest a new time (suggestedStart/suggestedEnd, unix seconds) and add a note (comment). Requires confirm:true.",
+      description: "RSVP to a calendar event on your identity. Optionally suggest a new time (suggestedStart/suggestedEnd, unix seconds) and add a note (comment). For private events pass the event's viewKey (nsec) if known \u2014 otherwise it is looked up from your calendar lists. Requires confirm:true.",
       inputSchema: {
         eventCoordinate: external_exports.string(),
         status: external_exports.enum(["accepted", "declined", "tentative"]),
         isPrivate: external_exports.boolean().optional(),
+        viewKey: external_exports.string().optional(),
         suggestedStart: external_exports.number().optional(),
         suggestedEnd: external_exports.number().optional(),
         comment: external_exports.string().optional(),
@@ -33831,6 +35109,7 @@ function buildCalendarTools() {
       eventCoordinate,
       status,
       isPrivate,
+      viewKey,
       suggestedStart,
       suggestedEnd,
       comment,
@@ -33838,16 +35117,13 @@ function buildCalendarTools() {
     }) => {
       const blocked = requireConfirm("rsvp_event", { confirm }, `sends "${status}" RSVP`);
       if (blocked) return blocked;
-      const hasExtra = suggestedStart !== void 0 || suggestedEnd !== void 0 || comment !== void 0;
-      if (hasExtra) {
-        await rsvp_exports.rsvpToEvent(eventCoordinate, status, Boolean(isPrivate), {
-          suggestedStart,
-          suggestedEnd,
-          comment
-        });
-      } else {
-        await rsvp_exports.rsvpToEvent(eventCoordinate, status, Boolean(isPrivate));
+      let key = viewKey;
+      if (isPrivate && !key) {
+        key = await service_exports2.lookupEventViewKey(eventCoordinate);
       }
+      const hasExtra = suggestedStart !== void 0 || suggestedEnd !== void 0 || comment !== void 0;
+      const extra = hasExtra ? { suggestedStart, suggestedEnd, comment } : void 0;
+      await rsvp_exports.rsvpToEvent(eventCoordinate, status, Boolean(isPrivate), extra, key);
       return ok(`RSVP "${status}" sent.`);
     }
   );
@@ -33887,6 +35163,9 @@ function buildCalendarTools() {
         rrule: args.rrule ?? existing.repeat.rrule ?? void 0,
         startTzid: args.startTzid ?? existing.startTzid,
         registrationFormRef: existing.registrationFormRef,
+        registrationFormViewKey: existing.registrationFormViewKey,
+        notificationPreference: existing.notificationPreference,
+        viewKey: existing.viewKey,
         existingId: existing.id
       };
       const event = existing.isPrivate ? await service_exports2.publishPrivateCalendarEvent(draft, existing.calendarId ?? "default") : await service_exports2.publishPublicCalendarEvent(draft);
@@ -33926,6 +35205,8 @@ function buildCalendarTools() {
         rrule: existing.repeat.rrule ?? void 0,
         startTzid: existing.startTzid,
         registrationFormRef: formRef,
+        notificationPreference: existing.notificationPreference,
+        viewKey: existing.viewKey,
         existingId: existing.id
       };
       const event = existing.isPrivate ? await service_exports2.publishPrivateCalendarEvent(draft, existing.calendarId ?? "default") : await service_exports2.publishPublicCalendarEvent(draft);
@@ -34208,8 +35489,13 @@ function normalizePubkeyList(values) {
   return values.map((v) => typeof v === "string" ? normalizePubkey(v) : null).filter((p) => !!p);
 }
 var ANSWER_TYPES = new Set(Object.values(AnswerType));
+var LEGACY_TYPE_ALIASES = {
+  multiChoiceGrid: "multipleChoiceGrid" /* multipleChoiceGrid */
+};
 function coerceType(type) {
-  return type && ANSWER_TYPES.has(type) ? type : "shortText" /* shortText */;
+  if (!type) return "shortText" /* shortText */;
+  if (LEGACY_TYPE_ALIASES[type]) return LEGACY_TYPE_ALIASES[type];
+  return ANSWER_TYPES.has(type) ? type : "shortText" /* shortText */;
 }
 function normalizeOptions(options) {
   if (!options) return void 0;
@@ -34229,7 +35515,8 @@ function aiFieldsToFormFields(value) {
     validation: f.validation,
     gridRows: f.gridRows,
     gridCols: f.gridCols,
-    fileConfig: f.fileConfig
+    fileConfig: f.fileConfig,
+    maxStars: f.maxStars
   }));
 }
 
@@ -34253,6 +35540,7 @@ var fieldShape = external_exports.object({
   }).optional(),
   gridRows: external_exports.array(external_exports.string()).optional(),
   gridCols: external_exports.array(external_exports.string()).optional(),
+  maxStars: external_exports.number().optional(),
   fileConfig: external_exports.object({
     blossomServer: external_exports.string().optional(),
     maxBytes: external_exports.number().optional(),
@@ -34351,7 +35639,13 @@ ${form.settings.description}`);
       const signingKey = mine.find(
         (f) => f.pubkey === formAuthorPubkey && f.id === formId
       )?.signingKey;
-      const responses = await service_exports.fetchResponses(formAuthorPubkey, formId, signingKey);
+      const template = await service_exports.fetchForm(formAuthorPubkey, formId);
+      const responses = await service_exports.fetchResponses(
+        formAuthorPubkey,
+        formId,
+        signingKey,
+        template?.relays
+      );
       const blocks = responses.map((r) => {
         const when = new Date(r.createdAt * 1e3).toISOString();
         const answers = r.responses.length ? r.responses.map((a) => `- ${a.fieldId}: ${a.answer}`).join("\n") : r.wasEncrypted ? "_(encrypted \u2014 you are not the form owner)_" : "_(no answers)_";
@@ -34466,24 +35760,32 @@ To let collaborators decrypt it, run \`share_form\` with their npubs.` : ""),
   },
   {
     name: "share_form",
-    description: "Share an encrypted form's view key with collaborators via NIP-59 gift-wrap so they can decrypt it. Requires confirm:true.",
+    description: "Share an encrypted form's view key with collaborators via NIP-59 gift-wrap so they can decrypt it. Pubkeys in `editors` additionally receive the signing key (edit access). Requires confirm:true.",
     inputSchema: {
       formId: external_exports.string(),
       formPubkey: external_exports.string(),
       recipients: external_exports.array(external_exports.string()),
+      editors: external_exports.array(external_exports.string()).optional(),
       confirm: external_exports.boolean().optional()
     },
     write: true,
-    handler: async ({ formId, formPubkey, recipients, confirm }) => {
+    handler: async ({ formId, formPubkey, recipients, editors, confirm }) => {
       const recipientHex = normalizePubkeyList(recipients);
-      if (recipientHex.length === 0) return fail("No valid recipients provided.", "BAD_INPUT");
+      const editorHex = normalizePubkeyList(editors ?? []);
+      if (recipientHex.length === 0 && editorHex.length === 0)
+        return fail("No valid recipients provided.", "BAD_INPUT");
       const blocked = requireConfirm(
         "share_form",
         { confirm },
-        `gift-wraps the view key of form ${formId} to ${recipientHex.length} recipient(s)`
+        `gift-wraps the access keys of form ${formId} to ${recipientHex.length + editorHex.length} recipient(s)`
       );
       if (blocked) return blocked;
-      const result = await service_exports.shareForm({ formId, formPubkey, recipients: recipientHex });
+      const result = await service_exports.shareForm({
+        formId,
+        formPubkey,
+        recipients: recipientHex,
+        editors: editorHex
+      });
       const failedNote = result.failed.length ? ` (${result.failed.length} failed)` : "";
       return ok(`Shared view key with ${result.published} recipient(s)${failedNote}.`, {
         published: result.published,
@@ -34527,6 +35829,7 @@ To let collaborators decrypt it, run \`share_form\` with their npubs.` : ""),
         `publicly submits ${answers.length} answer(s) to form ${formId}`
       );
       if (blocked) return blocked;
+      const template = await service_exports.fetchForm(formAuthorPubkey, formId);
       await service_exports.submitResponse(
         formAuthorPubkey,
         formId,
@@ -34535,7 +35838,9 @@ To let collaborators decrypt it, run \`share_form\` with their npubs.` : ""),
           answer: a.answer,
           metadata: a.metadata
         })),
-        Boolean(encrypt7)
+        Boolean(encrypt7),
+        void 0,
+        template?.relays
       );
       return ok(`Submitted ${answers.length} answer(s) to form ${formId}.`);
     }
@@ -34590,7 +35895,7 @@ function buildPagesTools() {
   server.registerTool(
     "list_shared_pages",
     {
-      description: "List documents others have shared with you (kind-11234 inbox).",
+      description: "List documents others have shared with you (kind-34579 doc-metadata entries carrying a viewKey).",
       inputSchema: {}
     },
     async () => {
@@ -34615,6 +35920,25 @@ function buildPagesTools() {
       return ok("Tags fetched.", { address, tags: map.get(address) ?? [] });
     }
   );
+  server.registerTool(
+    "list_page_comments",
+    {
+      description: "List the inline comments/suggestions on a shared document (kind 1494; needs the doc's viewKey).",
+      inputSchema: { address: external_exports.string(), viewKey: external_exports.string() }
+    },
+    async ({ address, viewKey }) => {
+      const comments = await comments_exports.fetchPageComments(address, viewKey);
+      return ok(`${comments.length} comment(s).`, {
+        comments: comments.map((c) => ({
+          author: c.author,
+          createdAt: c.createdAt,
+          type: c.type,
+          content: c.content,
+          quote: c.quote
+        }))
+      });
+    }
+  );
   server.registerTool(
     "create_page",
     {
@@ -34721,6 +36045,44 @@ function buildPagesTools() {
       });
     }
   );
+  server.registerTool(
+    "add_page_comment",
+    {
+      description: "Add an inline comment or suggestion to a shared document (kind 1494). Requires confirm:true.",
+      inputSchema: {
+        address: external_exports.string(),
+        eventId: external_exports.string(),
+        viewKey: external_exports.string(),
+        content: external_exports.string(),
+        type: external_exports.enum(["comment", "suggestion"]).optional(),
+        quote: external_exports.string().optional(),
+        confirm: external_exports.boolean().optional()
+      }
+    },
+    async ({
+      address,
+      eventId,
+      viewKey,
+      content,
+      type,
+      quote,
+      confirm
+    }) => {
+      const blocked = requireConfirm(
+        "add_page_comment",
+        { confirm },
+        `publishes a comment on ${address}`
+      );
+      if (blocked) return blocked;
+      const event = await comments_exports.publishPageComment(
+        { content, type: type ?? "comment", ...quote !== void 0 ? { quote } : {} },
+        viewKey,
+        address,
+        eventId
+      );
+      return ok("Comment published.", { id: event.id });
+    }
+  );
   return tools;
 }
 
@@ -34857,7 +36219,13 @@ function buildPollsTools() {
       if (blocked) return blocked;
       const poll = await service_exports5.fetchPoll(pollEventId);
       if (!poll) return fail("Poll not found.");
-      await service_exports5.submitPollResponse(pollEventId, poll.pubkey, optionIds, poll.relays);
+      await service_exports5.submitPollResponse(
+        pollEventId,
+        poll.pubkey,
+        optionIds,
+        poll.relays,
+        poll.powDifficulty
+      );
       return ok(`Voted on poll ${pollEventId}.`);
     }
   );
@@ -45086,7 +46454,7 @@ function adapt(r) {
   };
 }
 function buildServer(ctx) {
-  const server = new McpServer({ name: "formstr", version: "0.1.1" });
+  const server = new McpServer({ name: "formstr", version: "0.1.0" });
   for (const t of toolRegistry) {
     if (t.write && !ctx.allowWrites) continue;
     server.registerTool(
@@ -45106,7 +46474,17 @@ async function startStdio(ctx) {
 // src/index.ts
 async function runServer(cli) {
   const cfg = resolveConfig(cli, process.env);
-  const account = await bootstrap({ account: cfg.account, relays: cfg.relays });
+  const deps = process.stdin.isTTY ? {
+    promptPassphrase: async (question) => {
+      const io = createTerminalIo();
+      try {
+        return await io.promptPassphrase(question);
+      } finally {
+        io.close();
+      }
+    }
+  } : {};
+  const account = await bootstrap({ account: cfg.account, relays: cfg.relays }, deps);
   console.error(
     `formstr-mcp: signed in as ${account.npub} (${account.method}), writes ${cfg.allowWrites ? "ENABLED" : "disabled"}`
   );
@@ -45115,13 +46493,14 @@ async function runServer(cli) {
 }
 async function runLogin(cli) {
   const io = createTerminalIo();
+  const pool = createPatchedPool();
   try {
     const account = await doLogin({
       signer: await buildMcpSigner(),
       prompt: io.prompt,
       promptPassphrase: io.promptPassphrase,
       printQr,
-      pool: createPatchedPool(),
+      pool,
       relays: cli.relays
     });
     console.error(
@@ -45129,6 +46508,10 @@ async function runLogin(cli) {
     );
   } finally {
     io.close();
+    try {
+      pool.destroy();
+    } catch {
+    }
   }
 }
 async function main() {
@@ -45136,18 +46519,18 @@ async function main() {
   switch (cli.command) {
     case "login":
       await runLogin(cli);
-      return;
+      return cli.command;
     case "logout": {
       await doLogout(await buildMcpSigner(), cli.account);
       console.error("formstr-mcp: signed out.");
-      return;
+      return cli.command;
     }
     case "whoami": {
       const who = whoami(await buildMcpSigner());
       console.error(
         who ? `formstr-mcp: ${who.npub} (${who.method})` : "formstr-mcp: not signed in."
       );
-      return;
+      return cli.command;
     }
     case "accounts": {
       const signer = await buildMcpSigner();
@@ -45155,26 +46538,45 @@ async function main() {
       const accounts = listAccounts(signer);
       if (accounts.length === 0) {
         console.error("formstr-mcp: no accounts. Run `formstr-mcp login`.");
-        return;
+        return cli.command;
       }
       for (const a of accounts) {
         const marker = active && a.pubkey === active.pubkey ? "* " : "  ";
         console.error(`${marker}${a.npub} (${a.method})`);
       }
-      return;
+      return cli.command;
+    }
+    case "switch": {
+      if (!cli.target) {
+        throw new Error(
+          "Usage: formstr-mcp switch <npub|hex>. Run `formstr-mcp accounts` to list them."
+        );
+      }
+      const account = await doSwitch(await buildMcpSigner(), cli.target);
+      console.error(`formstr-mcp: active account is now ${account.npub} (${account.method}).`);
+      return cli.command;
     }
+    case "help":
+      console.error(helpText());
+      return cli.command;
     case "run":
     default:
       await runServer(cli);
+      return "run";
   }
 }
-main().catch((err) => {
-  console.error("formstr-mcp: fatal:", err instanceof Error ? err.message : err);
+main().then((command) => {
+  if (command !== "run") process.exit(0);
+}).catch((err) => {
+  const debug = !!(process.env.FORMSTR_MCP_DEBUG || process.env.DEBUG);
+  console.error("formstr-mcp: fatal:", formatFatal(err, debug));
+  if (!debug) console.error("formstr-mcp: (set FORMSTR_MCP_DEBUG=1 for a full stack trace)");
   process.exit(1);
 });
 /*! Bundled license information:
 
 @noble/hashes/utils.js:
+@noble/hashes/esm/utils.js:
   (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 
 @noble/curves/utils.js: