@kehto/paja 0.3.4 → 0.3.6

package/dist/browser-host.js

@@ -607,7 +607,7 @@ function deserialize2(json) {
   return defaultConfig();
 }
 
-// ../../node_modules/.pnpm/@napplet+core@0.23.0/node_modules/@napplet/core/dist/index.js
+// ../../node_modules/.pnpm/@napplet+core@0.24.0/node_modules/@napplet/core/dist/index.js
 function createDispatch() {
   const handlers = /* @__PURE__ */ new Map();
   function registerNap2(domain, handler) {
@@ -1697,13 +1697,13 @@ function legacyScopedKey(pubkey, dTag, aggregateHash, userKey) {
 }
 function byteLength(str) {
   let bytes = 0;
-  for (let i = 0; i < str.length; i++) {
-    const c = str.charCodeAt(i);
+  for (let i2 = 0; i2 < str.length; i2++) {
+    const c = str.charCodeAt(i2);
     if (c < 128) bytes += 1;
     else if (c < 2048) bytes += 2;
     else if (c < 55296 || c >= 57344) bytes += 3;
     else {
-      i++;
+      i2++;
       bytes += 4;
     }
   }
@@ -2003,13 +2003,13 @@ function createNapEnvelopeDispatcher(handlers) {
 }
 function utf8ByteLength(str) {
   let bytes = 0;
-  for (let i = 0; i < str.length; i++) {
-    const c = str.charCodeAt(i);
+  for (let i2 = 0; i2 < str.length; i2++) {
+    const c = str.charCodeAt(i2);
     if (c < 128) bytes += 1;
     else if (c < 2048) bytes += 2;
     else if (c < 55296 || c >= 57344) bytes += 3;
     else {
-      i++;
+      i2++;
       bytes += 4;
     }
   }
@@ -2252,8 +2252,8 @@ function bytesToHex(bytes) {
 }
 function hexToBytes(hex) {
   const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < hex.length; i += 2) {
-    bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+  for (let i2 = 0; i2 < hex.length; i2 += 2) {
+    bytes[i2 / 2] = parseInt(hex.substring(i2, i2 + 2), 16);
   }
   return bytes;
 }
@@ -2427,8 +2427,8 @@ function createStatePersistence() {
     clear(prefix) {
       try {
         const keysToRemove = [];
-        for (let i = 0; i < localStorage.length; i++) {
-          const key = localStorage.key(i);
+        for (let i2 = 0; i2 < localStorage.length; i2++) {
+          const key = localStorage.key(i2);
           if (key?.startsWith(prefix)) keysToRemove.push(key);
         }
         for (const key of keysToRemove) localStorage.removeItem(key);
@@ -2438,8 +2438,8 @@ function createStatePersistence() {
     keys(prefix) {
       try {
         const result = [];
-        for (let i = 0; i < localStorage.length; i++) {
-          const key = localStorage.key(i);
+        for (let i2 = 0; i2 < localStorage.length; i2++) {
+          const key = localStorage.key(i2);
           if (key?.startsWith(prefix)) result.push(key);
         }
         return result;
@@ -2450,8 +2450,8 @@ function createStatePersistence() {
     calculateBytes(prefix, excludeKey) {
       try {
         let total = 0;
-        for (let i = 0; i < localStorage.length; i++) {
-          const key = localStorage.key(i);
+        for (let i2 = 0; i2 < localStorage.length; i2++) {
+          const key = localStorage.key(i2);
           if (!key?.startsWith(prefix)) continue;
           if (excludeKey && key === excludeKey) continue;
           const value = localStorage.getItem(key) ?? "";
@@ -3465,6 +3465,12 @@ function createShellBridge(hooks) {
 function isBytes(a) {
   return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
 }
+function anumber(n, title = "") {
+  if (!Number.isSafeInteger(n) || n < 0) {
+    const prefix = title && `"${title}" `;
+    throw new Error(`${prefix}expected integer >= 0, got ${n}`);
+  }
+}
 function abytes(value, length, title = "") {
   const bytes = isBytes(value);
   const len = value?.length;
@@ -3477,18 +3483,42 @@ function abytes(value, length, title = "") {
   }
   return value;
 }
+function aexists(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 aoutput(out, instance) {
+  abytes(out, void 0, "digestInto() output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error('"digestInto() output" expected to be of length >=' + min);
+  }
+}
+function clean(...arrays) {
+  for (let i2 = 0; i2 < arrays.length; i2++) {
+    arrays[i2].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
 var hasHexBuiltin = /* @__PURE__ */ (() => (
   // @ts-ignore
   typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function"
 ))();
-var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i2) => i2.toString(16).padStart(2, "0"));
 function bytesToHex2(bytes) {
   abytes(bytes);
   if (hasHexBuiltin)
     return bytes.toHex();
   let hex = "";
-  for (let i = 0; i < bytes.length; i++) {
-    hex += hexes[bytes[i]];
+  for (let i2 = 0; i2 < bytes.length; i2++) {
+    hex += hexes[bytes[i2]];
   }
   return hex;
 }
@@ -3525,19 +3555,37 @@ function hexToBytes2(hex) {
 }
 function concatBytes(...arrays) {
   let sum = 0;
-  for (let i = 0; i < arrays.length; i++) {
-    const a = arrays[i];
+  for (let i2 = 0; i2 < arrays.length; i2++) {
+    const a = arrays[i2];
     abytes(a);
     sum += a.length;
   }
   const res = new Uint8Array(sum);
-  for (let i = 0, pad = 0; i < arrays.length; i++) {
-    const a = arrays[i];
+  for (let i2 = 0, pad = 0; i2 < arrays.length; i2++) {
+    const a = arrays[i2];
     res.set(a, pad);
     pad += a.length;
   }
   return res;
 }
+function createHasher(hashCons, info = {}) {
+  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(void 0);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+function randomBytes(bytesLength = 32) {
+  const cr = typeof globalThis === "object" ? globalThis.crypto : null;
+  if (typeof cr?.getRandomValues !== "function")
+    throw new Error("crypto.getRandomValues must be defined");
+  return cr.getRandomValues(new Uint8Array(bytesLength));
+}
+var oidNist = (suffix) => ({
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+});
 
 // ../../node_modules/.pnpm/@scure+base@2.0.0/node_modules/@scure/base/index.js
 function isBytes2(a) {
@@ -3564,7 +3612,7 @@ function astr(label, input) {
     throw new Error(`${label}: string expected`);
   return true;
 }
-function anumber(n) {
+function anumber2(n) {
   if (!Number.isSafeInteger(n))
     throw new Error(`invalid integer: ${n}`);
 }
@@ -3593,24 +3641,24 @@ function alphabet(letters) {
   const lettersA = typeof letters === "string" ? letters.split("") : letters;
   const len = lettersA.length;
   astrArr("alphabet", lettersA);
-  const indexes = new Map(lettersA.map((l, i) => [l, i]));
+  const indexes = new Map(lettersA.map((l, i2) => [l, i2]));
   return {
     encode: (digits) => {
       aArr(digits);
-      return digits.map((i) => {
-        if (!Number.isSafeInteger(i) || i < 0 || i >= len)
-          throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
-        return lettersA[i];
+      return digits.map((i2) => {
+        if (!Number.isSafeInteger(i2) || i2 < 0 || i2 >= len)
+          throw new Error(`alphabet.encode: digit index outside alphabet "${i2}". Allowed: ${letters}`);
+        return lettersA[i2];
       });
     },
     decode: (input) => {
       aArr(input);
       return input.map((letter) => {
         astr("alphabet.decode", letter);
-        const i = indexes.get(letter);
-        if (i === void 0)
+        const i2 = indexes.get(letter);
+        if (i2 === void 0)
           throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
-        return i;
+        return i2;
       });
     }
   };
@@ -3633,8 +3681,8 @@ var gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
 var radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to));
 var powers = /* @__PURE__ */ (() => {
   let res = [];
-  for (let i = 0; i < 40; i++)
-    res.push(2 ** i);
+  for (let i2 = 0; i2 < 40; i2++)
+    res.push(2 ** i2);
   return res;
 })();
 function convertRadix2(data, from, to, padding) {
@@ -3652,7 +3700,7 @@ function convertRadix2(data, from, to, padding) {
   const mask = powers[to] - 1;
   const res = [];
   for (const n of data) {
-    anumber(n);
+    anumber2(n);
     if (n >= max)
       throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
     carry = carry << from | n;
@@ -3677,7 +3725,7 @@ function convertRadix2(data, from, to, padding) {
 }
 // @__NO_SIDE_EFFECTS__
 function radix2(bits, revPadding = false) {
-  anumber(bits);
+  anumber2(bits);
   if (bits <= 0 || bits > 32)
     throw new Error("radix2: bits should be in (0..32]");
   if (/* @__PURE__ */ radix2carry(8, bits) > 32 || /* @__PURE__ */ radix2carry(bits, 8) > 32)
@@ -3708,27 +3756,27 @@ var POLYMOD_GENERATORS = [996825010, 642813549, 513874426, 1027748829, 705979059
 function bech32Polymod(pre) {
   const b = pre >> 25;
   let chk = (pre & 33554431) << 5;
-  for (let i = 0; i < POLYMOD_GENERATORS.length; i++) {
-    if ((b >> i & 1) === 1)
-      chk ^= POLYMOD_GENERATORS[i];
+  for (let i2 = 0; i2 < POLYMOD_GENERATORS.length; i2++) {
+    if ((b >> i2 & 1) === 1)
+      chk ^= POLYMOD_GENERATORS[i2];
   }
   return chk;
 }
 function bechChecksum(prefix, words, encodingConst = 1) {
   const len = prefix.length;
   let chk = 1;
-  for (let i = 0; i < len; i++) {
-    const c = prefix.charCodeAt(i);
+  for (let i2 = 0; i2 < len; i2++) {
+    const c = prefix.charCodeAt(i2);
     if (c < 33 || c > 126)
       throw new Error(`Invalid prefix (${prefix})`);
     chk = bech32Polymod(chk) ^ c >> 5;
   }
   chk = bech32Polymod(chk);
-  for (let i = 0; i < len; i++)
-    chk = bech32Polymod(chk) ^ prefix.charCodeAt(i) & 31;
+  for (let i2 = 0; i2 < len; i2++)
+    chk = bech32Polymod(chk) ^ prefix.charCodeAt(i2) & 31;
   for (let v of words)
     chk = bech32Polymod(chk) ^ v;
-  for (let i = 0; i < 6; i++)
+  for (let i2 = 0; i2 < 6; i2++)
     chk = bech32Polymod(chk);
   chk ^= encodingConst;
   return BECH_ALPHABET.encode(convertRadix2([chk % powers[30]], 30, 5, false));
@@ -3951,6 +3999,1668 @@ function encodeTLV(tlv) {
   return concatBytes(...entries);
 }
 
+// ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/_md.js
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+var HashMD = class {
+  blockLen;
+  outputLen;
+  padOffset;
+  isLE;
+  // For partial updates less than block size
+  buffer;
+  view;
+  finished = false;
+  length = 0;
+  pos = 0;
+  destroyed = false;
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    abytes(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 = createView(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) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i2 = pos; i2 < blockLen; i2++)
+      buffer[i2] = 0;
+    view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen must 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 i2 = 0; i2 < outLen; i2++)
+      oview.setUint32(4 * i2, state[i2], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(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_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/sha2.js
+var SHA256_K = /* @__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_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA2_32B = class extends HashMD {
+  constructor(outputLen) {
+    super(64, outputLen, 8, false);
+  }
+  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 i2 = 0; i2 < 16; i2++, offset += 4)
+      SHA256_W[i2] = view.getUint32(offset, false);
+    for (let i2 = 16; i2 < 64; i2++) {
+      const W15 = SHA256_W[i2 - 15];
+      const W2 = SHA256_W[i2 - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i2] = s1 + SHA256_W[i2 - 7] + s0 + SHA256_W[i2 - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i2 = 0; i2 < 64; i2++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i2] + SHA256_W[i2] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(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() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+};
+var _SHA256 = class extends SHA2_32B {
+  // We cannot use array here since array allows indexing by variable
+  // which means optimizer/compiler cannot use registers.
+  A = SHA256_IV[0] | 0;
+  B = SHA256_IV[1] | 0;
+  C = SHA256_IV[2] | 0;
+  D = SHA256_IV[3] | 0;
+  E = SHA256_IV[4] | 0;
+  F = SHA256_IV[5] | 0;
+  G = SHA256_IV[6] | 0;
+  H = SHA256_IV[7] | 0;
+  constructor() {
+    super(32);
+  }
+};
+var sha256 = /* @__PURE__ */ createHasher(
+  () => new _SHA256(),
+  /* @__PURE__ */ oidNist(1)
+);
+
+// ../../node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/utils.js
+var _0n = /* @__PURE__ */ BigInt(0);
+var _1n = /* @__PURE__ */ BigInt(1);
+function abool(value, title = "") {
+  if (typeof value !== "boolean") {
+    const prefix = title && `"${title}" `;
+    throw new Error(prefix + "expected boolean, got type=" + typeof value);
+  }
+  return value;
+}
+function abignumber(n) {
+  if (typeof n === "bigint") {
+    if (!isPosBig(n))
+      throw new Error("positive bigint expected, got " + n);
+  } else
+    anumber(n);
+  return n;
+}
+function hexToNumber(hex) {
+  if (typeof hex !== "string")
+    throw new Error("hex string expected, got " + typeof hex);
+  return hex === "" ? _0n : BigInt("0x" + hex);
+}
+function bytesToNumberBE(bytes) {
+  return hexToNumber(bytesToHex2(bytes));
+}
+function bytesToNumberLE(bytes) {
+  return hexToNumber(bytesToHex2(copyBytes(abytes(bytes)).reverse()));
+}
+function numberToBytesBE(n, len) {
+  anumber(len);
+  n = abignumber(n);
+  const res = hexToBytes2(n.toString(16).padStart(len * 2, "0"));
+  if (res.length !== len)
+    throw new Error("number too large");
+  return res;
+}
+function numberToBytesLE(n, len) {
+  return numberToBytesBE(n, len).reverse();
+}
+function copyBytes(bytes) {
+  return Uint8Array.from(bytes);
+}
+function asciiToBytes(ascii) {
+  return Uint8Array.from(ascii, (c, i2) => {
+    const charCode = c.charCodeAt(0);
+    if (c.length !== 1 || charCode > 127) {
+      throw new Error(`string contains non-ASCII character "${ascii[i2]}" with code ${charCode} at position ${i2}`);
+    }
+    return charCode;
+  });
+}
+var isPosBig = (n) => typeof n === "bigint" && _0n <= n;
+function bitLen(n) {
+  let len;
+  for (len = 0; n > _0n; n >>= _1n, len += 1)
+    ;
+  return len;
+}
+var bitMask = (n) => (_1n << BigInt(n)) - _1n;
+function validateObject(object, fields = {}, optFields = {}) {
+  if (!object || typeof object !== "object")
+    throw new Error("expected valid options object");
+  function checkField(fieldName, expectedType, isOpt) {
+    const val = object[fieldName];
+    if (isOpt && val === void 0)
+      return;
+    const current = typeof val;
+    if (current !== expectedType || val === null)
+      throw new Error(`param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`);
+  }
+  const iter = (f, isOpt) => Object.entries(f).forEach(([k, v]) => checkField(k, v, isOpt));
+  iter(fields, false);
+  iter(optFields, true);
+}
+function memoized(fn) {
+  const map = /* @__PURE__ */ new WeakMap();
+  return (arg, ...args) => {
+    const val = map.get(arg);
+    if (val !== void 0)
+      return val;
+    const computed = fn(arg, ...args);
+    map.set(arg, computed);
+    return computed;
+  };
+}
+
+// ../../node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/abstract/modular.js
+var _0n2 = /* @__PURE__ */ BigInt(0);
+var _1n2 = /* @__PURE__ */ BigInt(1);
+var _2n = /* @__PURE__ */ BigInt(2);
+var _3n = /* @__PURE__ */ BigInt(3);
+var _4n = /* @__PURE__ */ BigInt(4);
+var _5n = /* @__PURE__ */ BigInt(5);
+var _7n = /* @__PURE__ */ BigInt(7);
+var _8n = /* @__PURE__ */ BigInt(8);
+var _9n = /* @__PURE__ */ BigInt(9);
+var _16n = /* @__PURE__ */ BigInt(16);
+function mod(a, b) {
+  const result = a % b;
+  return result >= _0n2 ? result : b + result;
+}
+function pow2(x, power, modulo) {
+  let res = x;
+  while (power-- > _0n2) {
+    res *= res;
+    res %= modulo;
+  }
+  return res;
+}
+function invert(number, modulo) {
+  if (number === _0n2)
+    throw new Error("invert: expected non-zero number");
+  if (modulo <= _0n2)
+    throw new Error("invert: expected positive modulus, got " + modulo);
+  let a = mod(number, modulo);
+  let b = modulo;
+  let x = _0n2, y = _1n2, u = _1n2, v = _0n2;
+  while (a !== _0n2) {
+    const q = b / a;
+    const r = b % a;
+    const m = x - u * q;
+    const n = y - v * q;
+    b = a, a = r, x = u, y = v, u = m, v = n;
+  }
+  const gcd2 = b;
+  if (gcd2 !== _1n2)
+    throw new Error("invert: does not exist");
+  return mod(x, modulo);
+}
+function assertIsSquare(Fp, root, n) {
+  if (!Fp.eql(Fp.sqr(root), n))
+    throw new Error("Cannot find square root");
+}
+function sqrt3mod4(Fp, n) {
+  const p1div4 = (Fp.ORDER + _1n2) / _4n;
+  const root = Fp.pow(n, p1div4);
+  assertIsSquare(Fp, root, n);
+  return root;
+}
+function sqrt5mod8(Fp, n) {
+  const p5div8 = (Fp.ORDER - _5n) / _8n;
+  const n2 = Fp.mul(n, _2n);
+  const v = Fp.pow(n2, p5div8);
+  const nv = Fp.mul(n, v);
+  const i2 = Fp.mul(Fp.mul(nv, _2n), v);
+  const root = Fp.mul(nv, Fp.sub(i2, Fp.ONE));
+  assertIsSquare(Fp, root, n);
+  return root;
+}
+function sqrt9mod16(P) {
+  const Fp_ = Field(P);
+  const tn = tonelliShanks(P);
+  const c1 = tn(Fp_, Fp_.neg(Fp_.ONE));
+  const c2 = tn(Fp_, c1);
+  const c3 = tn(Fp_, Fp_.neg(c1));
+  const c4 = (P + _7n) / _16n;
+  return (Fp, n) => {
+    let tv1 = Fp.pow(n, c4);
+    let tv2 = Fp.mul(tv1, c1);
+    const tv3 = Fp.mul(tv1, c2);
+    const tv4 = Fp.mul(tv1, c3);
+    const e1 = Fp.eql(Fp.sqr(tv2), n);
+    const e2 = Fp.eql(Fp.sqr(tv3), n);
+    tv1 = Fp.cmov(tv1, tv2, e1);
+    tv2 = Fp.cmov(tv4, tv3, e2);
+    const e3 = Fp.eql(Fp.sqr(tv2), n);
+    const root = Fp.cmov(tv1, tv2, e3);
+    assertIsSquare(Fp, root, n);
+    return root;
+  };
+}
+function tonelliShanks(P) {
+  if (P < _3n)
+    throw new Error("sqrt is not defined for small field");
+  let Q = P - _1n2;
+  let S = 0;
+  while (Q % _2n === _0n2) {
+    Q /= _2n;
+    S++;
+  }
+  let Z = _2n;
+  const _Fp = Field(P);
+  while (FpLegendre(_Fp, Z) === 1) {
+    if (Z++ > 1e3)
+      throw new Error("Cannot find square root: probably non-prime P");
+  }
+  if (S === 1)
+    return sqrt3mod4;
+  let cc = _Fp.pow(Z, Q);
+  const Q1div2 = (Q + _1n2) / _2n;
+  return function tonelliSlow(Fp, n) {
+    if (Fp.is0(n))
+      return n;
+    if (FpLegendre(Fp, n) !== 1)
+      throw new Error("Cannot find square root");
+    let M = S;
+    let c = Fp.mul(Fp.ONE, cc);
+    let t = Fp.pow(n, Q);
+    let R = Fp.pow(n, Q1div2);
+    while (!Fp.eql(t, Fp.ONE)) {
+      if (Fp.is0(t))
+        return Fp.ZERO;
+      let i2 = 1;
+      let t_tmp = Fp.sqr(t);
+      while (!Fp.eql(t_tmp, Fp.ONE)) {
+        i2++;
+        t_tmp = Fp.sqr(t_tmp);
+        if (i2 === M)
+          throw new Error("Cannot find square root");
+      }
+      const exponent = _1n2 << BigInt(M - i2 - 1);
+      const b = Fp.pow(c, exponent);
+      M = i2;
+      c = Fp.sqr(b);
+      t = Fp.mul(t, c);
+      R = Fp.mul(R, b);
+    }
+    return R;
+  };
+}
+function FpSqrt(P) {
+  if (P % _4n === _3n)
+    return sqrt3mod4;
+  if (P % _8n === _5n)
+    return sqrt5mod8;
+  if (P % _16n === _9n)
+    return sqrt9mod16(P);
+  return tonelliShanks(P);
+}
+var FIELD_FIELDS = [
+  "create",
+  "isValid",
+  "is0",
+  "neg",
+  "inv",
+  "sqrt",
+  "sqr",
+  "eql",
+  "add",
+  "sub",
+  "mul",
+  "pow",
+  "div",
+  "addN",
+  "subN",
+  "mulN",
+  "sqrN"
+];
+function validateField(field) {
+  const initial = {
+    ORDER: "bigint",
+    BYTES: "number",
+    BITS: "number"
+  };
+  const opts = FIELD_FIELDS.reduce((map, val) => {
+    map[val] = "function";
+    return map;
+  }, initial);
+  validateObject(field, opts);
+  return field;
+}
+function FpPow(Fp, num2, power) {
+  if (power < _0n2)
+    throw new Error("invalid exponent, negatives unsupported");
+  if (power === _0n2)
+    return Fp.ONE;
+  if (power === _1n2)
+    return num2;
+  let p = Fp.ONE;
+  let d = num2;
+  while (power > _0n2) {
+    if (power & _1n2)
+      p = Fp.mul(p, d);
+    d = Fp.sqr(d);
+    power >>= _1n2;
+  }
+  return p;
+}
+function FpInvertBatch(Fp, nums, passZero = false) {
+  const inverted = new Array(nums.length).fill(passZero ? Fp.ZERO : void 0);
+  const multipliedAcc = nums.reduce((acc, num2, i2) => {
+    if (Fp.is0(num2))
+      return acc;
+    inverted[i2] = acc;
+    return Fp.mul(acc, num2);
+  }, Fp.ONE);
+  const invertedAcc = Fp.inv(multipliedAcc);
+  nums.reduceRight((acc, num2, i2) => {
+    if (Fp.is0(num2))
+      return acc;
+    inverted[i2] = Fp.mul(acc, inverted[i2]);
+    return Fp.mul(acc, num2);
+  }, invertedAcc);
+  return inverted;
+}
+function FpLegendre(Fp, n) {
+  const p1mod2 = (Fp.ORDER - _1n2) / _2n;
+  const powered = Fp.pow(n, p1mod2);
+  const yes = Fp.eql(powered, Fp.ONE);
+  const zero = Fp.eql(powered, Fp.ZERO);
+  const no = Fp.eql(powered, Fp.neg(Fp.ONE));
+  if (!yes && !zero && !no)
+    throw new Error("invalid Legendre symbol result");
+  return yes ? 1 : zero ? 0 : -1;
+}
+function nLength(n, nBitLength) {
+  if (nBitLength !== void 0)
+    anumber(nBitLength);
+  const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
+  const nByteLength = Math.ceil(_nBitLength / 8);
+  return { nBitLength: _nBitLength, nByteLength };
+}
+var _Field = class {
+  ORDER;
+  BITS;
+  BYTES;
+  isLE;
+  ZERO = _0n2;
+  ONE = _1n2;
+  _lengths;
+  _sqrt;
+  // cached sqrt
+  _mod;
+  constructor(ORDER, opts = {}) {
+    if (ORDER <= _0n2)
+      throw new Error("invalid field: expected ORDER > 0, got " + ORDER);
+    let _nbitLength = void 0;
+    this.isLE = false;
+    if (opts != null && typeof opts === "object") {
+      if (typeof opts.BITS === "number")
+        _nbitLength = opts.BITS;
+      if (typeof opts.sqrt === "function")
+        this.sqrt = opts.sqrt;
+      if (typeof opts.isLE === "boolean")
+        this.isLE = opts.isLE;
+      if (opts.allowedLengths)
+        this._lengths = opts.allowedLengths?.slice();
+      if (typeof opts.modFromBytes === "boolean")
+        this._mod = opts.modFromBytes;
+    }
+    const { nBitLength, nByteLength } = nLength(ORDER, _nbitLength);
+    if (nByteLength > 2048)
+      throw new Error("invalid field: expected ORDER of <= 2048 bytes");
+    this.ORDER = ORDER;
+    this.BITS = nBitLength;
+    this.BYTES = nByteLength;
+    this._sqrt = void 0;
+    Object.preventExtensions(this);
+  }
+  create(num2) {
+    return mod(num2, this.ORDER);
+  }
+  isValid(num2) {
+    if (typeof num2 !== "bigint")
+      throw new Error("invalid field element: expected bigint, got " + typeof num2);
+    return _0n2 <= num2 && num2 < this.ORDER;
+  }
+  is0(num2) {
+    return num2 === _0n2;
+  }
+  // is valid and invertible
+  isValidNot0(num2) {
+    return !this.is0(num2) && this.isValid(num2);
+  }
+  isOdd(num2) {
+    return (num2 & _1n2) === _1n2;
+  }
+  neg(num2) {
+    return mod(-num2, this.ORDER);
+  }
+  eql(lhs, rhs) {
+    return lhs === rhs;
+  }
+  sqr(num2) {
+    return mod(num2 * num2, this.ORDER);
+  }
+  add(lhs, rhs) {
+    return mod(lhs + rhs, this.ORDER);
+  }
+  sub(lhs, rhs) {
+    return mod(lhs - rhs, this.ORDER);
+  }
+  mul(lhs, rhs) {
+    return mod(lhs * rhs, this.ORDER);
+  }
+  pow(num2, power) {
+    return FpPow(this, num2, power);
+  }
+  div(lhs, rhs) {
+    return mod(lhs * invert(rhs, this.ORDER), this.ORDER);
+  }
+  // Same as above, but doesn't normalize
+  sqrN(num2) {
+    return num2 * num2;
+  }
+  addN(lhs, rhs) {
+    return lhs + rhs;
+  }
+  subN(lhs, rhs) {
+    return lhs - rhs;
+  }
+  mulN(lhs, rhs) {
+    return lhs * rhs;
+  }
+  inv(num2) {
+    return invert(num2, this.ORDER);
+  }
+  sqrt(num2) {
+    if (!this._sqrt)
+      this._sqrt = FpSqrt(this.ORDER);
+    return this._sqrt(this, num2);
+  }
+  toBytes(num2) {
+    return this.isLE ? numberToBytesLE(num2, this.BYTES) : numberToBytesBE(num2, this.BYTES);
+  }
+  fromBytes(bytes, skipValidation = false) {
+    abytes(bytes);
+    const { _lengths: allowedLengths, BYTES, isLE, ORDER, _mod: modFromBytes } = this;
+    if (allowedLengths) {
+      if (!allowedLengths.includes(bytes.length) || bytes.length > BYTES) {
+        throw new Error("Field.fromBytes: expected " + allowedLengths + " bytes, got " + bytes.length);
+      }
+      const padded = new Uint8Array(BYTES);
+      padded.set(bytes, isLE ? 0 : padded.length - bytes.length);
+      bytes = padded;
+    }
+    if (bytes.length !== BYTES)
+      throw new Error("Field.fromBytes: expected " + BYTES + " bytes, got " + bytes.length);
+    let scalar = isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);
+    if (modFromBytes)
+      scalar = mod(scalar, ORDER);
+    if (!skipValidation) {
+      if (!this.isValid(scalar))
+        throw new Error("invalid field element: outside of range 0..ORDER");
+    }
+    return scalar;
+  }
+  // TODO: we don't need it here, move out to separate fn
+  invertBatch(lst) {
+    return FpInvertBatch(this, lst);
+  }
+  // We can't move this out because Fp6, Fp12 implement it
+  // and it's unclear what to return in there.
+  cmov(a, b, condition) {
+    return condition ? b : a;
+  }
+};
+function Field(ORDER, opts = {}) {
+  return new _Field(ORDER, opts);
+}
+function getFieldBytesLength(fieldOrder) {
+  if (typeof fieldOrder !== "bigint")
+    throw new Error("field order must be bigint");
+  const bitLength = fieldOrder.toString(2).length;
+  return Math.ceil(bitLength / 8);
+}
+function getMinHashLength(fieldOrder) {
+  const length = getFieldBytesLength(fieldOrder);
+  return length + Math.ceil(length / 2);
+}
+function mapHashToField(key, fieldOrder, isLE = false) {
+  abytes(key);
+  const len = key.length;
+  const fieldLen = getFieldBytesLength(fieldOrder);
+  const minLen = getMinHashLength(fieldOrder);
+  if (len < 16 || len < minLen || len > 1024)
+    throw new Error("expected " + minLen + "-1024 bytes of input, got " + len);
+  const num2 = isLE ? bytesToNumberLE(key) : bytesToNumberBE(key);
+  const reduced = mod(num2, fieldOrder - _1n2) + _1n2;
+  return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
+}
+
+// ../../node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/abstract/curve.js
+var _0n3 = /* @__PURE__ */ BigInt(0);
+var _1n3 = /* @__PURE__ */ BigInt(1);
+function negateCt(condition, item) {
+  const neg = item.negate();
+  return condition ? neg : item;
+}
+function normalizeZ(c, points) {
+  const invertedZs = FpInvertBatch(c.Fp, points.map((p) => p.Z));
+  return points.map((p, i2) => c.fromAffine(p.toAffine(invertedZs[i2])));
+}
+function validateW(W, bits) {
+  if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
+    throw new Error("invalid window size, expected [1.." + bits + "], got W=" + W);
+}
+function calcWOpts(W, scalarBits) {
+  validateW(W, scalarBits);
+  const windows = Math.ceil(scalarBits / W) + 1;
+  const windowSize = 2 ** (W - 1);
+  const maxNumber = 2 ** W;
+  const mask = bitMask(W);
+  const shiftBy = BigInt(W);
+  return { windows, windowSize, mask, maxNumber, shiftBy };
+}
+function calcOffsets(n, window2, wOpts) {
+  const { windowSize, mask, maxNumber, shiftBy } = wOpts;
+  let wbits = Number(n & mask);
+  let nextN = n >> shiftBy;
+  if (wbits > windowSize) {
+    wbits -= maxNumber;
+    nextN += _1n3;
+  }
+  const offsetStart = window2 * windowSize;
+  const offset = offsetStart + Math.abs(wbits) - 1;
+  const isZero = wbits === 0;
+  const isNeg = wbits < 0;
+  const isNegF = window2 % 2 !== 0;
+  const offsetF = offsetStart;
+  return { nextN, offset, isZero, isNeg, isNegF, offsetF };
+}
+var pointPrecomputes = /* @__PURE__ */ new WeakMap();
+var pointWindowSizes = /* @__PURE__ */ new WeakMap();
+function getW(P) {
+  return pointWindowSizes.get(P) || 1;
+}
+function assert0(n) {
+  if (n !== _0n3)
+    throw new Error("invalid wNAF");
+}
+var wNAF = class {
+  BASE;
+  ZERO;
+  Fn;
+  bits;
+  // Parametrized with a given Point class (not individual point)
+  constructor(Point, bits) {
+    this.BASE = Point.BASE;
+    this.ZERO = Point.ZERO;
+    this.Fn = Point.Fn;
+    this.bits = bits;
+  }
+  // non-const time multiplication ladder
+  _unsafeLadder(elm, n, p = this.ZERO) {
+    let d = elm;
+    while (n > _0n3) {
+      if (n & _1n3)
+        p = p.add(d);
+      d = d.double();
+      n >>= _1n3;
+    }
+    return p;
+  }
+  /**
+   * Creates a wNAF precomputation window. Used for caching.
+   * Default window size is set by `utils.precompute()` and is equal to 8.
+   * Number of precomputed points depends on the curve size:
+   * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
+   * - 𝑊 is the window size
+   * - 𝑛 is the bitlength of the curve order.
+   * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
+   * @param point Point instance
+   * @param W window size
+   * @returns precomputed point tables flattened to a single array
+   */
+  precomputeWindow(point, W) {
+    const { windows, windowSize } = calcWOpts(W, this.bits);
+    const points = [];
+    let p = point;
+    let base = p;
+    for (let window2 = 0; window2 < windows; window2++) {
+      base = p;
+      points.push(base);
+      for (let i2 = 1; i2 < windowSize; i2++) {
+        base = base.add(p);
+        points.push(base);
+      }
+      p = base.double();
+    }
+    return points;
+  }
+  /**
+   * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
+   * More compact implementation:
+   * https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541
+   * @returns real and fake (for const-time) points
+   */
+  wNAF(W, precomputes, n) {
+    if (!this.Fn.isValid(n))
+      throw new Error("invalid scalar");
+    let p = this.ZERO;
+    let f = this.BASE;
+    const wo = calcWOpts(W, this.bits);
+    for (let window2 = 0; window2 < wo.windows; window2++) {
+      const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window2, wo);
+      n = nextN;
+      if (isZero) {
+        f = f.add(negateCt(isNegF, precomputes[offsetF]));
+      } else {
+        p = p.add(negateCt(isNeg, precomputes[offset]));
+      }
+    }
+    assert0(n);
+    return { p, f };
+  }
+  /**
+   * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.
+   * @param acc accumulator point to add result of multiplication
+   * @returns point
+   */
+  wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {
+    const wo = calcWOpts(W, this.bits);
+    for (let window2 = 0; window2 < wo.windows; window2++) {
+      if (n === _0n3)
+        break;
+      const { nextN, offset, isZero, isNeg } = calcOffsets(n, window2, wo);
+      n = nextN;
+      if (isZero) {
+        continue;
+      } else {
+        const item = precomputes[offset];
+        acc = acc.add(isNeg ? item.negate() : item);
+      }
+    }
+    assert0(n);
+    return acc;
+  }
+  getPrecomputes(W, point, transform) {
+    let comp = pointPrecomputes.get(point);
+    if (!comp) {
+      comp = this.precomputeWindow(point, W);
+      if (W !== 1) {
+        if (typeof transform === "function")
+          comp = transform(comp);
+        pointPrecomputes.set(point, comp);
+      }
+    }
+    return comp;
+  }
+  cached(point, scalar, transform) {
+    const W = getW(point);
+    return this.wNAF(W, this.getPrecomputes(W, point, transform), scalar);
+  }
+  unsafe(point, scalar, transform, prev) {
+    const W = getW(point);
+    if (W === 1)
+      return this._unsafeLadder(point, scalar, prev);
+    return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform), scalar, prev);
+  }
+  // We calculate precomputes for elliptic curve point multiplication
+  // using windowed method. This specifies window size and
+  // stores precomputed values. Usually only base point would be precomputed.
+  createCache(P, W) {
+    validateW(W, this.bits);
+    pointWindowSizes.set(P, W);
+    pointPrecomputes.delete(P);
+  }
+  hasCache(elm) {
+    return getW(elm) !== 1;
+  }
+};
+function mulEndoUnsafe(Point, point, k1, k2) {
+  let acc = point;
+  let p1 = Point.ZERO;
+  let p2 = Point.ZERO;
+  while (k1 > _0n3 || k2 > _0n3) {
+    if (k1 & _1n3)
+      p1 = p1.add(acc);
+    if (k2 & _1n3)
+      p2 = p2.add(acc);
+    acc = acc.double();
+    k1 >>= _1n3;
+    k2 >>= _1n3;
+  }
+  return { p1, p2 };
+}
+function createField(order, field, isLE) {
+  if (field) {
+    if (field.ORDER !== order)
+      throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
+    validateField(field);
+    return field;
+  } else {
+    return Field(order, { isLE });
+  }
+}
+function createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {
+  if (FpFnLE === void 0)
+    FpFnLE = type === "edwards";
+  if (!CURVE || typeof CURVE !== "object")
+    throw new Error(`expected valid ${type} CURVE object`);
+  for (const p of ["p", "n", "h"]) {
+    const val = CURVE[p];
+    if (!(typeof val === "bigint" && val > _0n3))
+      throw new Error(`CURVE.${p} must be positive bigint`);
+  }
+  const Fp = createField(CURVE.p, curveOpts.Fp, FpFnLE);
+  const Fn = createField(CURVE.n, curveOpts.Fn, FpFnLE);
+  const _b = type === "weierstrass" ? "b" : "d";
+  const params = ["Gx", "Gy", "a", _b];
+  for (const p of params) {
+    if (!Fp.isValid(CURVE[p]))
+      throw new Error(`CURVE.${p} must be valid field element of CURVE.Fp`);
+  }
+  CURVE = Object.freeze(Object.assign({}, CURVE));
+  return { CURVE, Fp, Fn };
+}
+function createKeygen(randomSecretKey, getPublicKey2) {
+  return function keygen(seed) {
+    const secretKey = randomSecretKey(seed);
+    return { secretKey, publicKey: getPublicKey2(secretKey) };
+  };
+}
+
+// ../../node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/abstract/weierstrass.js
+var divNearest = (num2, den) => (num2 + (num2 >= 0 ? den : -den) / _2n2) / den;
+function _splitEndoScalar(k, basis, n) {
+  const [[a1, b1], [a2, b2]] = basis;
+  const c1 = divNearest(b2 * k, n);
+  const c2 = divNearest(-b1 * k, n);
+  let k1 = k - c1 * a1 - c2 * a2;
+  let k2 = -c1 * b1 - c2 * b2;
+  const k1neg = k1 < _0n4;
+  const k2neg = k2 < _0n4;
+  if (k1neg)
+    k1 = -k1;
+  if (k2neg)
+    k2 = -k2;
+  const MAX_NUM = bitMask(Math.ceil(bitLen(n) / 2)) + _1n4;
+  if (k1 < _0n4 || k1 >= MAX_NUM || k2 < _0n4 || k2 >= MAX_NUM) {
+    throw new Error("splitScalar (endomorphism): failed, k=" + k);
+  }
+  return { k1neg, k1, k2neg, k2 };
+}
+var _0n4 = BigInt(0);
+var _1n4 = BigInt(1);
+var _2n2 = BigInt(2);
+var _3n2 = BigInt(3);
+var _4n2 = BigInt(4);
+function weierstrass(params, extraOpts = {}) {
+  const validated = createCurveFields("weierstrass", params, extraOpts);
+  const { Fp, Fn } = validated;
+  let CURVE = validated.CURVE;
+  const { h: cofactor, n: CURVE_ORDER } = CURVE;
+  validateObject(extraOpts, {}, {
+    allowInfinityPoint: "boolean",
+    clearCofactor: "function",
+    isTorsionFree: "function",
+    fromBytes: "function",
+    toBytes: "function",
+    endo: "object"
+  });
+  const { endo } = extraOpts;
+  if (endo) {
+    if (!Fp.is0(CURVE.a) || typeof endo.beta !== "bigint" || !Array.isArray(endo.basises)) {
+      throw new Error('invalid endo: expected "beta": bigint and "basises": array');
+    }
+  }
+  const lengths = getWLengths(Fp, Fn);
+  function assertCompressionIsSupported() {
+    if (!Fp.isOdd)
+      throw new Error("compression is not supported: Field does not have .isOdd()");
+  }
+  function pointToBytes2(_c, point, isCompressed) {
+    const { x, y } = point.toAffine();
+    const bx = Fp.toBytes(x);
+    abool(isCompressed, "isCompressed");
+    if (isCompressed) {
+      assertCompressionIsSupported();
+      const hasEvenY = !Fp.isOdd(y);
+      return concatBytes(pprefix(hasEvenY), bx);
+    } else {
+      return concatBytes(Uint8Array.of(4), bx, Fp.toBytes(y));
+    }
+  }
+  function pointFromBytes(bytes) {
+    abytes(bytes, void 0, "Point");
+    const { publicKey: comp, publicKeyUncompressed: uncomp } = lengths;
+    const length = bytes.length;
+    const head = bytes[0];
+    const tail = bytes.subarray(1);
+    if (length === comp && (head === 2 || head === 3)) {
+      const x = Fp.fromBytes(tail);
+      if (!Fp.isValid(x))
+        throw new Error("bad point: is not on curve, wrong x");
+      const y2 = weierstrassEquation(x);
+      let y;
+      try {
+        y = Fp.sqrt(y2);
+      } catch (sqrtError) {
+        const err = sqrtError instanceof Error ? ": " + sqrtError.message : "";
+        throw new Error("bad point: is not on curve, sqrt error" + err);
+      }
+      assertCompressionIsSupported();
+      const evenY = Fp.isOdd(y);
+      const evenH = (head & 1) === 1;
+      if (evenH !== evenY)
+        y = Fp.neg(y);
+      return { x, y };
+    } else if (length === uncomp && head === 4) {
+      const L = Fp.BYTES;
+      const x = Fp.fromBytes(tail.subarray(0, L));
+      const y = Fp.fromBytes(tail.subarray(L, L * 2));
+      if (!isValidXY(x, y))
+        throw new Error("bad point: is not on curve");
+      return { x, y };
+    } else {
+      throw new Error(`bad point: got length ${length}, expected compressed=${comp} or uncompressed=${uncomp}`);
+    }
+  }
+  const encodePoint = extraOpts.toBytes || pointToBytes2;
+  const decodePoint = extraOpts.fromBytes || pointFromBytes;
+  function weierstrassEquation(x) {
+    const x2 = Fp.sqr(x);
+    const x3 = Fp.mul(x2, x);
+    return Fp.add(Fp.add(x3, Fp.mul(x, CURVE.a)), CURVE.b);
+  }
+  function isValidXY(x, y) {
+    const left = Fp.sqr(y);
+    const right = weierstrassEquation(x);
+    return Fp.eql(left, right);
+  }
+  if (!isValidXY(CURVE.Gx, CURVE.Gy))
+    throw new Error("bad curve params: generator point");
+  const _4a3 = Fp.mul(Fp.pow(CURVE.a, _3n2), _4n2);
+  const _27b2 = Fp.mul(Fp.sqr(CURVE.b), BigInt(27));
+  if (Fp.is0(Fp.add(_4a3, _27b2)))
+    throw new Error("bad curve params: a or b");
+  function acoord(title, n, banZero = false) {
+    if (!Fp.isValid(n) || banZero && Fp.is0(n))
+      throw new Error(`bad point coordinate ${title}`);
+    return n;
+  }
+  function aprjpoint(other) {
+    if (!(other instanceof Point))
+      throw new Error("Weierstrass Point expected");
+  }
+  function splitEndoScalarN(k) {
+    if (!endo || !endo.basises)
+      throw new Error("no endo");
+    return _splitEndoScalar(k, endo.basises, Fn.ORDER);
+  }
+  const toAffineMemo = memoized((p, iz) => {
+    const { X, Y, Z } = p;
+    if (Fp.eql(Z, Fp.ONE))
+      return { x: X, y: Y };
+    const is0 = p.is0();
+    if (iz == null)
+      iz = is0 ? Fp.ONE : Fp.inv(Z);
+    const x = Fp.mul(X, iz);
+    const y = Fp.mul(Y, iz);
+    const zz = Fp.mul(Z, iz);
+    if (is0)
+      return { x: Fp.ZERO, y: Fp.ZERO };
+    if (!Fp.eql(zz, Fp.ONE))
+      throw new Error("invZ was invalid");
+    return { x, y };
+  });
+  const assertValidMemo = memoized((p) => {
+    if (p.is0()) {
+      if (extraOpts.allowInfinityPoint && !Fp.is0(p.Y))
+        return;
+      throw new Error("bad point: ZERO");
+    }
+    const { x, y } = p.toAffine();
+    if (!Fp.isValid(x) || !Fp.isValid(y))
+      throw new Error("bad point: x or y not field elements");
+    if (!isValidXY(x, y))
+      throw new Error("bad point: equation left != right");
+    if (!p.isTorsionFree())
+      throw new Error("bad point: not in prime-order subgroup");
+    return true;
+  });
+  function finishEndo(endoBeta, k1p, k2p, k1neg, k2neg) {
+    k2p = new Point(Fp.mul(k2p.X, endoBeta), k2p.Y, k2p.Z);
+    k1p = negateCt(k1neg, k1p);
+    k2p = negateCt(k2neg, k2p);
+    return k1p.add(k2p);
+  }
+  class Point {
+    // base / generator point
+    static BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);
+    // zero / infinity / identity point
+    static ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);
+    // 0, 1, 0
+    // math field
+    static Fp = Fp;
+    // scalar field
+    static Fn = Fn;
+    X;
+    Y;
+    Z;
+    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+    constructor(X, Y, Z) {
+      this.X = acoord("x", X);
+      this.Y = acoord("y", Y, true);
+      this.Z = acoord("z", Z);
+      Object.freeze(this);
+    }
+    static CURVE() {
+      return CURVE;
+    }
+    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+    static fromAffine(p) {
+      const { x, y } = p || {};
+      if (!p || !Fp.isValid(x) || !Fp.isValid(y))
+        throw new Error("invalid affine point");
+      if (p instanceof Point)
+        throw new Error("projective point not allowed");
+      if (Fp.is0(x) && Fp.is0(y))
+        return Point.ZERO;
+      return new Point(x, y, Fp.ONE);
+    }
+    static fromBytes(bytes) {
+      const P = Point.fromAffine(decodePoint(abytes(bytes, void 0, "point")));
+      P.assertValidity();
+      return P;
+    }
+    static fromHex(hex) {
+      return Point.fromBytes(hexToBytes2(hex));
+    }
+    get x() {
+      return this.toAffine().x;
+    }
+    get y() {
+      return this.toAffine().y;
+    }
+    /**
+     *
+     * @param windowSize
+     * @param isLazy true will defer table computation until the first multiplication
+     * @returns
+     */
+    precompute(windowSize = 8, isLazy = true) {
+      wnaf.createCache(this, windowSize);
+      if (!isLazy)
+        this.multiply(_3n2);
+      return this;
+    }
+    // TODO: return `this`
+    /** A point on curve is valid if it conforms to equation. */
+    assertValidity() {
+      assertValidMemo(this);
+    }
+    hasEvenY() {
+      const { y } = this.toAffine();
+      if (!Fp.isOdd)
+        throw new Error("Field doesn't support isOdd");
+      return !Fp.isOdd(y);
+    }
+    /** Compare one point to another. */
+    equals(other) {
+      aprjpoint(other);
+      const { X: X1, Y: Y1, Z: Z1 } = this;
+      const { X: X2, Y: Y2, Z: Z2 } = other;
+      const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));
+      const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));
+      return U1 && U2;
+    }
+    /** Flips point to one corresponding to (x, -y) in Affine coordinates. */
+    negate() {
+      return new Point(this.X, Fp.neg(this.Y), this.Z);
+    }
+    // Renes-Costello-Batina exception-free doubling formula.
+    // There is 30% faster Jacobian formula, but it is not complete.
+    // https://eprint.iacr.org/2015/1060, algorithm 3
+    // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
+    double() {
+      const { a, b } = CURVE;
+      const b3 = Fp.mul(b, _3n2);
+      const { X: X1, Y: Y1, Z: Z1 } = this;
+      let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
+      let t0 = Fp.mul(X1, X1);
+      let t1 = Fp.mul(Y1, Y1);
+      let t2 = Fp.mul(Z1, Z1);
+      let t3 = Fp.mul(X1, Y1);
+      t3 = Fp.add(t3, t3);
+      Z3 = Fp.mul(X1, Z1);
+      Z3 = Fp.add(Z3, Z3);
+      X3 = Fp.mul(a, Z3);
+      Y3 = Fp.mul(b3, t2);
+      Y3 = Fp.add(X3, Y3);
+      X3 = Fp.sub(t1, Y3);
+      Y3 = Fp.add(t1, Y3);
+      Y3 = Fp.mul(X3, Y3);
+      X3 = Fp.mul(t3, X3);
+      Z3 = Fp.mul(b3, Z3);
+      t2 = Fp.mul(a, t2);
+      t3 = Fp.sub(t0, t2);
+      t3 = Fp.mul(a, t3);
+      t3 = Fp.add(t3, Z3);
+      Z3 = Fp.add(t0, t0);
+      t0 = Fp.add(Z3, t0);
+      t0 = Fp.add(t0, t2);
+      t0 = Fp.mul(t0, t3);
+      Y3 = Fp.add(Y3, t0);
+      t2 = Fp.mul(Y1, Z1);
+      t2 = Fp.add(t2, t2);
+      t0 = Fp.mul(t2, t3);
+      X3 = Fp.sub(X3, t0);
+      Z3 = Fp.mul(t2, t1);
+      Z3 = Fp.add(Z3, Z3);
+      Z3 = Fp.add(Z3, Z3);
+      return new Point(X3, Y3, Z3);
+    }
+    // Renes-Costello-Batina exception-free addition formula.
+    // There is 30% faster Jacobian formula, but it is not complete.
+    // https://eprint.iacr.org/2015/1060, algorithm 1
+    // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
+    add(other) {
+      aprjpoint(other);
+      const { X: X1, Y: Y1, Z: Z1 } = this;
+      const { X: X2, Y: Y2, Z: Z2 } = other;
+      let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
+      const a = CURVE.a;
+      const b3 = Fp.mul(CURVE.b, _3n2);
+      let t0 = Fp.mul(X1, X2);
+      let t1 = Fp.mul(Y1, Y2);
+      let t2 = Fp.mul(Z1, Z2);
+      let t3 = Fp.add(X1, Y1);
+      let t4 = Fp.add(X2, Y2);
+      t3 = Fp.mul(t3, t4);
+      t4 = Fp.add(t0, t1);
+      t3 = Fp.sub(t3, t4);
+      t4 = Fp.add(X1, Z1);
+      let t5 = Fp.add(X2, Z2);
+      t4 = Fp.mul(t4, t5);
+      t5 = Fp.add(t0, t2);
+      t4 = Fp.sub(t4, t5);
+      t5 = Fp.add(Y1, Z1);
+      X3 = Fp.add(Y2, Z2);
+      t5 = Fp.mul(t5, X3);
+      X3 = Fp.add(t1, t2);
+      t5 = Fp.sub(t5, X3);
+      Z3 = Fp.mul(a, t4);
+      X3 = Fp.mul(b3, t2);
+      Z3 = Fp.add(X3, Z3);
+      X3 = Fp.sub(t1, Z3);
+      Z3 = Fp.add(t1, Z3);
+      Y3 = Fp.mul(X3, Z3);
+      t1 = Fp.add(t0, t0);
+      t1 = Fp.add(t1, t0);
+      t2 = Fp.mul(a, t2);
+      t4 = Fp.mul(b3, t4);
+      t1 = Fp.add(t1, t2);
+      t2 = Fp.sub(t0, t2);
+      t2 = Fp.mul(a, t2);
+      t4 = Fp.add(t4, t2);
+      t0 = Fp.mul(t1, t4);
+      Y3 = Fp.add(Y3, t0);
+      t0 = Fp.mul(t5, t4);
+      X3 = Fp.mul(t3, X3);
+      X3 = Fp.sub(X3, t0);
+      t0 = Fp.mul(t3, t1);
+      Z3 = Fp.mul(t5, Z3);
+      Z3 = Fp.add(Z3, t0);
+      return new Point(X3, Y3, Z3);
+    }
+    subtract(other) {
+      return this.add(other.negate());
+    }
+    is0() {
+      return this.equals(Point.ZERO);
+    }
+    /**
+     * Constant time multiplication.
+     * Uses wNAF method. Windowed method may be 10% faster,
+     * but takes 2x longer to generate and consumes 2x memory.
+     * Uses precomputes when available.
+     * Uses endomorphism for Koblitz curves.
+     * @param scalar by which the point would be multiplied
+     * @returns New point
+     */
+    multiply(scalar) {
+      const { endo: endo2 } = extraOpts;
+      if (!Fn.isValidNot0(scalar))
+        throw new Error("invalid scalar: out of range");
+      let point, fake;
+      const mul = (n) => wnaf.cached(this, n, (p) => normalizeZ(Point, p));
+      if (endo2) {
+        const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(scalar);
+        const { p: k1p, f: k1f } = mul(k1);
+        const { p: k2p, f: k2f } = mul(k2);
+        fake = k1f.add(k2f);
+        point = finishEndo(endo2.beta, k1p, k2p, k1neg, k2neg);
+      } else {
+        const { p, f } = mul(scalar);
+        point = p;
+        fake = f;
+      }
+      return normalizeZ(Point, [point, fake])[0];
+    }
+    /**
+     * Non-constant-time multiplication. Uses double-and-add algorithm.
+     * It's faster, but should only be used when you don't care about
+     * an exposed secret key e.g. sig verification, which works over *public* keys.
+     */
+    multiplyUnsafe(sc) {
+      const { endo: endo2 } = extraOpts;
+      const p = this;
+      if (!Fn.isValid(sc))
+        throw new Error("invalid scalar: out of range");
+      if (sc === _0n4 || p.is0())
+        return Point.ZERO;
+      if (sc === _1n4)
+        return p;
+      if (wnaf.hasCache(this))
+        return this.multiply(sc);
+      if (endo2) {
+        const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(sc);
+        const { p1, p2 } = mulEndoUnsafe(Point, p, k1, k2);
+        return finishEndo(endo2.beta, p1, p2, k1neg, k2neg);
+      } else {
+        return wnaf.unsafe(p, sc);
+      }
+    }
+    /**
+     * Converts Projective point to affine (x, y) coordinates.
+     * @param invertedZ Z^-1 (inverted zero) - optional, precomputation is useful for invertBatch
+     */
+    toAffine(invertedZ) {
+      return toAffineMemo(this, invertedZ);
+    }
+    /**
+     * Checks whether Point is free of torsion elements (is in prime subgroup).
+     * Always torsion-free for cofactor=1 curves.
+     */
+    isTorsionFree() {
+      const { isTorsionFree } = extraOpts;
+      if (cofactor === _1n4)
+        return true;
+      if (isTorsionFree)
+        return isTorsionFree(Point, this);
+      return wnaf.unsafe(this, CURVE_ORDER).is0();
+    }
+    clearCofactor() {
+      const { clearCofactor } = extraOpts;
+      if (cofactor === _1n4)
+        return this;
+      if (clearCofactor)
+        return clearCofactor(Point, this);
+      return this.multiplyUnsafe(cofactor);
+    }
+    isSmallOrder() {
+      return this.multiplyUnsafe(cofactor).is0();
+    }
+    toBytes(isCompressed = true) {
+      abool(isCompressed, "isCompressed");
+      this.assertValidity();
+      return encodePoint(Point, this, isCompressed);
+    }
+    toHex(isCompressed = true) {
+      return bytesToHex2(this.toBytes(isCompressed));
+    }
+    toString() {
+      return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+    }
+  }
+  const bits = Fn.BITS;
+  const wnaf = new wNAF(Point, extraOpts.endo ? Math.ceil(bits / 2) : bits);
+  Point.BASE.precompute(8);
+  return Point;
+}
+function pprefix(hasEvenY) {
+  return Uint8Array.of(hasEvenY ? 2 : 3);
+}
+function getWLengths(Fp, Fn) {
+  return {
+    secretKey: Fn.BYTES,
+    publicKey: 1 + Fp.BYTES,
+    publicKeyUncompressed: 1 + 2 * Fp.BYTES,
+    publicKeyHasPrefix: true,
+    signature: 2 * Fn.BYTES
+  };
+}
+
+// ../../node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/secp256k1.js
+var secp256k1_CURVE = {
+  p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"),
+  n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),
+  h: BigInt(1),
+  a: BigInt(0),
+  b: BigInt(7),
+  Gx: BigInt("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),
+  Gy: BigInt("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8")
+};
+var secp256k1_ENDO = {
+  beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
+  basises: [
+    [BigInt("0x3086d221a7d46bcde86c90e49284eb15"), -BigInt("0xe4437ed6010e88286f547fa90abfe4c3")],
+    [BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), BigInt("0x3086d221a7d46bcde86c90e49284eb15")]
+  ]
+};
+var _0n5 = /* @__PURE__ */ BigInt(0);
+var _2n3 = /* @__PURE__ */ BigInt(2);
+function sqrtMod(y) {
+  const P = secp256k1_CURVE.p;
+  const _3n3 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
+  const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
+  const b2 = y * y * y % P;
+  const b3 = b2 * b2 * y % P;
+  const b6 = pow2(b3, _3n3, P) * b3 % P;
+  const b9 = pow2(b6, _3n3, P) * b3 % P;
+  const b11 = pow2(b9, _2n3, P) * b2 % P;
+  const b22 = pow2(b11, _11n, P) * b11 % P;
+  const b44 = pow2(b22, _22n, P) * b22 % P;
+  const b88 = pow2(b44, _44n, P) * b44 % P;
+  const b176 = pow2(b88, _88n, P) * b88 % P;
+  const b220 = pow2(b176, _44n, P) * b44 % P;
+  const b223 = pow2(b220, _3n3, P) * b3 % P;
+  const t1 = pow2(b223, _23n, P) * b22 % P;
+  const t2 = pow2(t1, _6n, P) * b2 % P;
+  const root = pow2(t2, _2n3, P);
+  if (!Fpk1.eql(Fpk1.sqr(root), y))
+    throw new Error("Cannot find square root");
+  return root;
+}
+var Fpk1 = Field(secp256k1_CURVE.p, { sqrt: sqrtMod });
+var Pointk1 = /* @__PURE__ */ weierstrass(secp256k1_CURVE, {
+  Fp: Fpk1,
+  endo: secp256k1_ENDO
+});
+var TAGGED_HASH_PREFIXES = {};
+function taggedHash(tag, ...messages) {
+  let tagP = TAGGED_HASH_PREFIXES[tag];
+  if (tagP === void 0) {
+    const tagH = sha256(asciiToBytes(tag));
+    tagP = concatBytes(tagH, tagH);
+    TAGGED_HASH_PREFIXES[tag] = tagP;
+  }
+  return sha256(concatBytes(tagP, ...messages));
+}
+var pointToBytes = (point) => point.toBytes(true).slice(1);
+var hasEven = (y) => y % _2n3 === _0n5;
+function schnorrGetExtPubKey(priv) {
+  const { Fn, BASE } = Pointk1;
+  const d_ = Fn.fromBytes(priv);
+  const p = BASE.multiply(d_);
+  const scalar = hasEven(p.y) ? d_ : Fn.neg(d_);
+  return { scalar, bytes: pointToBytes(p) };
+}
+function lift_x(x) {
+  const Fp = Fpk1;
+  if (!Fp.isValidNot0(x))
+    throw new Error("invalid x: Fail if x \u2265 p");
+  const xx = Fp.create(x * x);
+  const c = Fp.create(xx * x + BigInt(7));
+  let y = Fp.sqrt(c);
+  if (!hasEven(y))
+    y = Fp.neg(y);
+  const p = Pointk1.fromAffine({ x, y });
+  p.assertValidity();
+  return p;
+}
+var num = bytesToNumberBE;
+function challenge(...args) {
+  return Pointk1.Fn.create(num(taggedHash("BIP0340/challenge", ...args)));
+}
+function schnorrGetPublicKey(secretKey) {
+  return schnorrGetExtPubKey(secretKey).bytes;
+}
+function schnorrSign(message, secretKey, auxRand = randomBytes(32)) {
+  const { Fn } = Pointk1;
+  const m = abytes(message, void 0, "message");
+  const { bytes: px, scalar: d } = schnorrGetExtPubKey(secretKey);
+  const a = abytes(auxRand, 32, "auxRand");
+  const t = Fn.toBytes(d ^ num(taggedHash("BIP0340/aux", a)));
+  const rand = taggedHash("BIP0340/nonce", t, px, m);
+  const { bytes: rx, scalar: k } = schnorrGetExtPubKey(rand);
+  const e = challenge(rx, px, m);
+  const sig = new Uint8Array(64);
+  sig.set(rx, 0);
+  sig.set(Fn.toBytes(Fn.create(k + e * d)), 32);
+  if (!schnorrVerify(sig, m, px))
+    throw new Error("sign: Invalid signature produced");
+  return sig;
+}
+function schnorrVerify(signature, message, publicKey) {
+  const { Fp, Fn, BASE } = Pointk1;
+  const sig = abytes(signature, 64, "signature");
+  const m = abytes(message, void 0, "message");
+  const pub = abytes(publicKey, 32, "publicKey");
+  try {
+    const P = lift_x(num(pub));
+    const r = num(sig.subarray(0, 32));
+    if (!Fp.isValidNot0(r))
+      return false;
+    const s = num(sig.subarray(32, 64));
+    if (!Fn.isValidNot0(s))
+      return false;
+    const e = challenge(Fn.toBytes(r), pointToBytes(P), m);
+    const R = BASE.multiplyUnsafe(s).add(P.multiplyUnsafe(Fn.neg(e)));
+    const { x, y } = R.toAffine();
+    if (R.is0() || !hasEven(y) || x !== r)
+      return false;
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+var schnorr = /* @__PURE__ */ (() => {
+  const size = 32;
+  const seedLength = 48;
+  const randomSecretKey = (seed = randomBytes(seedLength)) => {
+    return mapHashToField(seed, secp256k1_CURVE.n);
+  };
+  return {
+    keygen: createKeygen(randomSecretKey, schnorrGetPublicKey),
+    getPublicKey: schnorrGetPublicKey,
+    sign: schnorrSign,
+    verify: schnorrVerify,
+    Point: Pointk1,
+    utils: {
+      randomSecretKey,
+      taggedHash,
+      lift_x,
+      pointToBytes
+    },
+    lengths: {
+      secretKey: size,
+      publicKey: size,
+      publicKeyHasPrefix: false,
+      signature: size * 2,
+      seed: seedLength
+    }
+  };
+})();
+
+// ../../node_modules/.pnpm/nostr-tools@2.23.3_typescript@5.9.3/node_modules/nostr-tools/lib/esm/pure.js
+var verifiedSymbol = /* @__PURE__ */ Symbol("verified");
+var isRecord = (obj) => obj instanceof Object;
+function validateEvent(event) {
+  if (!isRecord(event))
+    return false;
+  if (typeof event.kind !== "number")
+    return false;
+  if (typeof event.content !== "string")
+    return false;
+  if (typeof event.created_at !== "number")
+    return false;
+  if (typeof event.pubkey !== "string")
+    return false;
+  if (!event.pubkey.match(/^[a-f0-9]{64}$/))
+    return false;
+  if (!Array.isArray(event.tags))
+    return false;
+  for (let i2 = 0; i2 < event.tags.length; i2++) {
+    let tag = event.tags[i2];
+    if (!Array.isArray(tag))
+      return false;
+    for (let j = 0; j < tag.length; j++) {
+      if (typeof tag[j] !== "string")
+        return false;
+    }
+  }
+  return true;
+}
+var utf8Decoder2 = new TextDecoder("utf-8");
+var utf8Encoder2 = new TextEncoder();
+var JS = class {
+  generateSecretKey() {
+    return schnorr.utils.randomSecretKey();
+  }
+  getPublicKey(secretKey) {
+    return bytesToHex2(schnorr.getPublicKey(secretKey));
+  }
+  finalizeEvent(t, secretKey) {
+    const event = t;
+    event.pubkey = bytesToHex2(schnorr.getPublicKey(secretKey));
+    event.id = getEventHash(event);
+    event.sig = bytesToHex2(schnorr.sign(hexToBytes2(getEventHash(event)), secretKey));
+    event[verifiedSymbol] = true;
+    return event;
+  }
+  verifyEvent(event) {
+    if (typeof event[verifiedSymbol] === "boolean")
+      return event[verifiedSymbol];
+    try {
+      const hash = getEventHash(event);
+      if (hash !== event.id) {
+        event[verifiedSymbol] = false;
+        return false;
+      }
+      const valid = schnorr.verify(hexToBytes2(event.sig), hexToBytes2(hash), hexToBytes2(event.pubkey));
+      event[verifiedSymbol] = valid;
+      return valid;
+    } catch (err) {
+      event[verifiedSymbol] = false;
+      return false;
+    }
+  }
+};
+function serializeEvent(evt) {
+  if (!validateEvent(evt))
+    throw new Error("can't serialize event with wrong or missing properties");
+  return JSON.stringify([0, evt.pubkey, evt.created_at, evt.kind, evt.tags, evt.content]);
+}
+function getEventHash(event) {
+  let eventHash = sha256(utf8Encoder2.encode(serializeEvent(event)));
+  return bytesToHex2(eventHash);
+}
+var i = new JS();
+var generateSecretKey = i.generateSecretKey;
+var getPublicKey = i.getPublicKey;
+var finalizeEvent = i.finalizeEvent;
+var verifyEvent = i.verifyEvent;
+
 // ../services/dist/index.js
 var NOTIFICATION_SERVICE_VERSION = "1.0.0";
 var DEFAULT_MAX_PER_WINDOW = 100;
@@ -4412,11 +6122,11 @@ function parseChord(chord) {
   if (chord.length === 0) throw new Error("empty chord");
   const parts = chord.split("+");
   const out = { ctrl: false, alt: false, shift: false, meta: false, key: "" };
-  for (let i = 0; i < parts.length - 1; i++) {
-    const tok = parts[i].trim().toLowerCase();
+  for (let i2 = 0; i2 < parts.length - 1; i2++) {
+    const tok = parts[i2].trim().toLowerCase();
     if (tok.length === 0) continue;
     const slot = MODIFIER_ALIASES[tok];
-    if (!slot) throw new Error(`unknown modifier: ${parts[i]}`);
+    if (!slot) throw new Error(`unknown modifier: ${parts[i2]}`);
     out[slot] = true;
   }
   const keyTok = parts[parts.length - 1].trim();
@@ -5313,8 +7023,8 @@ function arrayBufferToBase64(buf) {
   const bytes = new Uint8Array(buf);
   const CHUNK = 32768;
   let binary = "";
-  for (let i = 0; i < bytes.length; i += CHUNK) {
-    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+  for (let i2 = 0; i2 < bytes.length; i2 += CHUNK) {
+    binary += String.fromCharCode(...bytes.subarray(i2, i2 + CHUNK));
   }
   return btoa(binary);
 }
@@ -6858,16 +8568,6 @@ function settleAction(action, pubkeys, context, send, resultType, id, unavailabl
   );
 }
 
-// src/simulation.ts
-function summarizePajaSimulation(simulation) {
-  const relay = simulation.relay.mode === "memory" ? `relay:${simulation.relay.urls.length}` : "relay:off";
-  const identity = simulation.identity.mode === "fixed" ? "identity:fixed" : "identity:anon";
-  const storage = `storage:${simulation.storage.mode}`;
-  const theme = `theme:${simulation.theme.mode}`;
-  const disabled = simulation.capabilities.disabledDomains.length > 0 ? `off:${simulation.capabilities.disabledDomains.join(",")}` : "off:none";
-  return `${identity} ${relay} ${storage} ${theme} ${disabled}`;
-}
-
 // src/development-services.ts
 var DEV_LISTS_EVENT_ID = "3".repeat(64);
 var DEV_SERIAL_LABEL = "Paja serial";
@@ -7043,10 +8743,12 @@ function createDevWebrtcController() {
   };
 }
 
-// src/browser-host.ts
+// src/browser-adapter.ts
 var DEV_INTENT_ARCHETYPE = "paja-target";
 var DEV_COMMON_PUBKEY = "1".repeat(64);
 var DEV_COMMON_EVENT_ID = "2".repeat(64);
+var DEV_SIGNER_SECRET_KEY = generateSecretKey();
+var PAJA_DEV_SIGNER_PUBKEY = getPublicKey(DEV_SIGNER_SECRET_KEY);
 var DEV_CVM_SERVER = {
   pubkey: "0".repeat(64),
   name: "Kehto Paja ContextVM",
@@ -7054,33 +8756,6 @@ var DEV_CVM_SERVER = {
   relays: ["wss://relay.kehto.dev"],
   capabilities: ["echo"]
 };
-function readConfig() {
-  const script = document.getElementById("kehto-paja-config");
-  if (!script?.textContent) {
-    throw new Error("Missing Kehto Paja config.");
-  }
-  return JSON.parse(script.textContent);
-}
-function setStatus(state, status) {
-  state.status = status;
-  const statusEl = document.getElementById("lifecycle-status");
-  if (statusEl) statusEl.textContent = status;
-}
-function setSimulationStatus(state) {
-  const statusEl = document.getElementById("simulation-status");
-  if (statusEl) statusEl.textContent = summarizePajaSimulation(state.simulation);
-  const themeSelect = document.getElementById("simulation-theme");
-  if (themeSelect instanceof HTMLSelectElement) themeSelect.value = state.simulation.theme.mode;
-}
-function getFrame() {
-  const frame = document.getElementById("napplet-frame");
-  if (!(frame instanceof HTMLIFrameElement)) {
-    throw new Error("Missing Kehto Paja iframe.");
-  }
-  frame.sandbox.add("allow-scripts");
-  frame.sandbox.remove("allow-same-origin");
-  return frame;
-}
 function matchesFilter2(event, filter) {
   const ids = filter.ids;
   if (ids && !ids.includes(event.id)) return false;
@@ -7093,7 +8768,7 @@ function matchesFilter2(event, filter) {
 function matchesAnyFilter2(event, filters) {
   return filters.length === 0 || filters.some((filter) => matchesFilter2(event, filter));
 }
-function createMemoryRelayPool(getSimulation) {
+function createMemoryRelayPool(getSimulation, confirmRequest) {
   const events = getSimulation().relay.fixtures.flatMap(toNostrEvent);
   const subscribers = /* @__PURE__ */ new Set();
   return {
@@ -7121,6 +8796,7 @@ function createMemoryRelayPool(getSimulation) {
     },
     publish(_relayUrls, event) {
       if (getSimulation().relay.mode === "disabled") return;
+      if (!confirmRequest({ action: "publish", event })) return;
       events.push(event);
       for (const subscriber of subscribers) {
         if (matchesAnyFilter2(event, subscriber.filters)) subscriber.next(event);
@@ -7261,7 +8937,7 @@ function createDevCvmTransport(getSimulation) {
     }
   };
 }
-function createOutboxRouter(pool, getSimulation) {
+function createOutboxRouter(pool, getSimulation, confirmRequest) {
   return {
     async query(filters) {
       const relayUrls = getRelayUrls(getSimulation());
@@ -7284,16 +8960,13 @@ function createOutboxRouter(pool, getSimulation) {
       return { close: () => sub.unsubscribe() };
     },
     async publish(template) {
-      const event = {
-        id: crypto.randomUUID().replace(/-/g, "").padEnd(64, "0").slice(0, 64),
-        pubkey: "0".repeat(64),
+      const event = await createDevSigner(getSimulation, confirmRequest).signEvent({
         created_at: Math.floor(Date.now() / 1e3),
         kind: 1,
         tags: [],
         content: "",
-        sig: "0".repeat(128),
         ...template
-      };
+      });
       const relayUrls = getRelayUrls(getSimulation());
       pool.publish(relayUrls, event);
       return { ok: true, event, eventId: event.id, relays: { [relayUrls[0] ?? "dev"]: true } };
@@ -7313,13 +8986,23 @@ function createDevTheme(mode, values) {
     }
   };
 }
-function createDevSigner(getSimulation) {
+function createDevSigner(getSimulation, confirmRequest) {
   return {
-    getPublicKey: () => getSimulation().identity.pubkey,
-    getRelays: () => Object.fromEntries(getRelayUrls(getSimulation()).map((relay) => [relay, { read: true, write: true }]))
+    getPublicKey: () => getSimulation().identity.pubkey || PAJA_DEV_SIGNER_PUBKEY,
+    getRelays: () => Object.fromEntries(getRelayUrls(getSimulation()).map((relay) => [relay, { read: true, write: true }])),
+    async signEvent(event) {
+      if (!confirmRequest({ action: "sign", event })) {
+        throw new Error("Paja signing request denied");
+      }
+      const template = { ...event };
+      template.created_at ??= Math.floor(Date.now() / 1e3);
+      template.tags ??= [];
+      template.content ??= "";
+      return finalizeEvent(template, DEV_SIGNER_SECRET_KEY);
+    }
   };
 }
-function createDevServices(pool, getSimulation, onThemeService) {
+function createDevServices(pool, getSimulation, onThemeService, confirmRequest) {
   const notification = createNotificationService({ maxPerWindow: 50 });
   const theme = createThemeService({
     initialTheme: createDevTheme(getSimulation().theme.mode, getSimulation().theme.values),
@@ -7360,12 +9043,10 @@ function createDevServices(pool, getSimulation, onThemeService) {
       selectRelayTier: () => getRelayUrls(getSimulation()),
       isAvailable: () => getSimulation().relay.mode === "memory"
     });
-    services.outbox = createOutboxService({ router: createOutboxRouter(pool, getSimulation) });
+    services.outbox = createOutboxService({ router: createOutboxRouter(pool, getSimulation, confirmRequest) });
   }
-  if (getSimulation().identity.mode === "fixed") {
-    services.identity = createIdentityService({ getSigner: () => createDevSigner(getSimulation) });
-  } else if (getSimulation().capabilities.domains.identity) {
-    services.identity = createIdentityService({ getSigner: () => null });
+  if (getSimulation().capabilities.domains.identity) {
+    services.identity = createIdentityService({ getSigner: () => createDevSigner(getSimulation, confirmRequest) });
   }
   if (getSimulation().notifications.enabled) {
     services.notifications = notification;
@@ -7438,8 +9119,8 @@ function createDevServices(pool, getSimulation, onThemeService) {
   }
   return services;
 }
-function createPajaAdapter(config, getSimulation, onThemeService) {
-  const pool = createMemoryRelayPool(getSimulation);
+function createPajaAdapter(config, getSimulation, onThemeService, confirmRequest) {
+  const pool = createMemoryRelayPool(getSimulation, confirmRequest);
   const workerRelayEvents = [];
   return {
     relayPool: createRelayHooks(pool, getSimulation),
@@ -7456,11 +9137,13 @@ function createPajaAdapter(config, getSimulation, onThemeService) {
     },
     windowManager: { createWindow: () => null },
     auth: {
-      getUserPubkey: () => getSimulation().identity.pubkey,
-      getSigner: () => getSimulation().identity.mode === "fixed" ? createDevSigner(getSimulation) : null
+      getUserPubkey: () => getSimulation().identity.pubkey || PAJA_DEV_SIGNER_PUBKEY,
+      getSigner: () => createDevSigner(getSimulation, confirmRequest)
+    },
+    services: createDevServices(pool, getSimulation, onThemeService, confirmRequest),
+    get capabilities() {
+      return { disabledDomains: getSimulation().capabilities.disabledDomains };
     },
-    services: createDevServices(pool, getSimulation, onThemeService),
-    capabilities: { disabledDomains: getSimulation().capabilities.disabledDomains },
     config: { getNappUpdateBehavior: () => "auto-grant" },
     hotkeys: { executeHotkeyFromForward: () => {
     } },
@@ -7482,6 +9165,259 @@ function createPajaAdapter(config, getSimulation, onThemeService) {
     })
   };
 }
+
+// src/simulation.ts
+var PAJA_SIMULATION_DOMAINS = [
+  "relay",
+  "outbox",
+  "storage",
+  "identity",
+  "keys",
+  "config",
+  "resource",
+  "theme",
+  "notify",
+  "media",
+  "upload",
+  "intent",
+  "link",
+  "common",
+  "lists",
+  "serial",
+  "ble",
+  "webrtc",
+  "cvm",
+  "inc"
+];
+function summarizePajaSimulation(simulation) {
+  const relay = simulation.relay.mode === "memory" ? `relay:${simulation.relay.urls.length}` : "relay:off";
+  const identity = simulation.identity.mode === "fixed" ? "identity:fixed" : "identity:anon";
+  const storage = `storage:${simulation.storage.mode}`;
+  const theme = `theme:${simulation.theme.mode}`;
+  const disabled = simulation.capabilities.disabledDomains.length > 0 ? `off:${simulation.capabilities.disabledDomains.join(",")}` : "off:none";
+  return `${identity} ${relay} ${storage} ${theme} ${disabled}`;
+}
+
+// src/browser-devtools.ts
+var PAJA_LOG_LIMIT = 500;
+var proxyToReal = /* @__PURE__ */ new WeakMap();
+function isNappletMessage(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.type === "string";
+}
+function describeMessage(raw) {
+  if (isNappletMessage(raw)) return raw.type;
+  if (Array.isArray(raw) && typeof raw[0] === "string") return raw[0];
+  return "unknown";
+}
+function previewMessage(raw) {
+  try {
+    return JSON.stringify(raw);
+  } catch (error) {
+    return `unserializable:${error instanceof Error ? error.message : String(error)}`;
+  }
+}
+function domainEnabled(simulation, domain) {
+  return simulation.capabilities.domains[domain] === true;
+}
+function getTargetIdentity(config) {
+  return {
+    pubkey: "",
+    dTag: config.window.dTag,
+    aggregateHash: config.window.aggregateHash
+  };
+}
+function appendPajaMessageLog(state, direction, raw, windowId) {
+  if (!state) return;
+  state.messageLog.push({
+    index: state.messageLog.length,
+    timestamp: Date.now(),
+    direction,
+    type: describeMessage(raw),
+    windowId,
+    preview: previewMessage(raw)
+  });
+  if (state.messageLog.length > PAJA_LOG_LIMIT) {
+    state.messageLog.splice(0, state.messageLog.length - PAJA_LOG_LIMIT);
+  }
+  renderPajaMessageLog(state);
+}
+function createPajaPostMessageProxy(realWin, state, windowId) {
+  const proxy = new Proxy(realWin, {
+    get(target, prop) {
+      if (prop === "postMessage") {
+        return (msg, targetOrigin, transfer) => {
+          appendPajaMessageLog(state, "shell->napplet", msg, windowId);
+          return target.postMessage(msg, targetOrigin, transfer);
+        };
+      }
+      try {
+        const val = Reflect.get(target, prop, target);
+        return typeof val === "function" ? val.bind(target) : val;
+      } catch {
+        return void 0;
+      }
+    }
+  });
+  proxyToReal.set(proxy, realWin);
+  return proxy;
+}
+function installPajaOriginRegistryProxy(originRegistry2, stateRef) {
+  const originalGetIframeWindow = originRegistry2.getIframeWindow.bind(originRegistry2);
+  originRegistry2.getIframeWindow = (windowId) => {
+    const win = originalGetIframeWindow(windowId);
+    if (!win) return null;
+    return createPajaPostMessageProxy(win, stateRef(), windowId);
+  };
+  const originalGetWindowId = originRegistry2.getWindowId.bind(originRegistry2);
+  originRegistry2.getWindowId = (win) => {
+    const result = originalGetWindowId(win);
+    if (result) return result;
+    const real = proxyToReal.get(win);
+    return real ? originalGetWindowId(real) : void 0;
+  };
+}
+function renderPajaDevtools(state, options) {
+  renderInterfaceControls(state);
+  renderAclControls(state, options.bridge);
+  renderSignerStatus(state, options.signerPubkey);
+}
+function renderPajaMessageLog(state) {
+  const container = document.getElementById("message-log");
+  if (!container) return;
+  const filter = state.messageFilter.trim().toLowerCase();
+  const rows = state.messageLog.filter((entry) => filter.length === 0 || `${entry.direction} ${entry.type} ${entry.preview}`.toLowerCase().includes(filter)).slice(-120).map((entry) => {
+    const row = document.createElement("div");
+    row.className = "log-row";
+    row.dataset.messageType = entry.type;
+    const dir = document.createElement("div");
+    dir.className = "log-dir";
+    dir.textContent = entry.direction;
+    const type = document.createElement("div");
+    type.className = "log-type";
+    type.title = entry.preview;
+    type.textContent = entry.type;
+    row.append(dir, type);
+    return row;
+  });
+  container.replaceChildren(...rows);
+  container.scrollTop = container.scrollHeight;
+}
+function renderInterfaceControls(state) {
+  const container = document.getElementById("interface-toggles");
+  if (!container) return;
+  container.replaceChildren(...PAJA_SIMULATION_DOMAINS.map((domain) => {
+    const enabled = domainEnabled(state.simulation, domain);
+    const button = document.createElement("button");
+    button.type = "button";
+    button.className = "toggle";
+    button.dataset.interfaceDomain = domain;
+    button.dataset.enabled = String(enabled);
+    button.textContent = domain;
+    button.title = `${domain} injection ${enabled ? "enabled" : "disabled"}`;
+    button.addEventListener("click", () => {
+      state.setDomainEnabled(domain, !domainEnabled(state.simulation, domain));
+    });
+    return button;
+  }));
+}
+function renderAclControls(state, bridge) {
+  const container = document.getElementById("acl-controls");
+  if (!container) return;
+  const identity = getTargetIdentity(state.config);
+  container.replaceChildren(...ALL_CAPABILITIES.map((capability) => {
+    const allowed = bridge?.runtime.aclState.check(
+      identity.pubkey,
+      identity.dTag,
+      identity.aggregateHash,
+      capability
+    ) ?? true;
+    const button = document.createElement("button");
+    button.type = "button";
+    button.className = "toggle";
+    button.dataset.aclCapability = capability;
+    button.dataset.enabled = String(allowed);
+    button.textContent = capability;
+    button.title = `${capability} ${allowed ? "allowed" : "blocked"}`;
+    button.addEventListener("click", () => state.setAclCapability(capability, !allowed));
+    return button;
+  }));
+}
+function renderSignerStatus(state, signerPubkey) {
+  const el = document.getElementById("signer-status");
+  if (!el) return;
+  const pubkey = state.simulation.identity.pubkey || signerPubkey;
+  el.textContent = `pubkey ${pubkey} \xB7 every sign/publish request prompts`;
+}
+
+// src/browser-host.ts
+var bridgeRef = null;
+function readConfig() {
+  const script = document.getElementById("kehto-paja-config");
+  if (!script?.textContent) {
+    throw new Error("Missing Kehto Paja config.");
+  }
+  return JSON.parse(script.textContent);
+}
+async function readLatestConfig(fallback) {
+  try {
+    const response = await fetch("/__kehto/config.json", { cache: "no-store" });
+    if (!response.ok) return fallback;
+    return await response.json();
+  } catch (error) {
+    console.warn("[paja] config refresh failed; using embedded config", error);
+    return fallback;
+  }
+}
+function setTargetUrlDisplay(config, frame) {
+  const targetEl = document.querySelector(".target");
+  if (targetEl) {
+    targetEl.textContent = config.target.url;
+    targetEl.setAttribute("title", config.target.url);
+  }
+  frame.dataset.targetUrl = config.target.url;
+}
+function setStatus(state, status) {
+  state.status = status;
+  const statusEl = document.getElementById("lifecycle-status");
+  if (statusEl) statusEl.textContent = status;
+}
+function setSimulationStatus(state) {
+  const statusEl = document.getElementById("simulation-status");
+  if (statusEl) statusEl.textContent = summarizePajaSimulation(state.simulation);
+  const themeSelect = document.getElementById("simulation-theme");
+  if (themeSelect instanceof HTMLSelectElement) themeSelect.value = state.simulation.theme.mode;
+  renderPajaDevtools(state, { bridge: bridgeRef, signerPubkey: PAJA_DEV_SIGNER_PUBKEY });
+}
+function getFrame() {
+  const frame = document.getElementById("napplet-frame");
+  if (!(frame instanceof HTMLIFrameElement)) {
+    throw new Error("Missing Kehto Paja iframe.");
+  }
+  frame.sandbox.add("allow-scripts");
+  frame.sandbox.remove("allow-same-origin");
+  return frame;
+}
+function confirmPajaRequest(state, request) {
+  const event = request.event;
+  const kind = typeof event.kind === "number" ? event.kind : "unknown";
+  const content = typeof event.content === "string" && event.content.length > 0 ? `
+
+${event.content.slice(0, 240)}` : "";
+  const allowed = window.confirm(`Paja ${request.action} request
+kind: ${kind}${content}`);
+  appendPajaMessageLog(state, "paja", {
+    type: `paja.${request.action}.${allowed ? "confirmed" : "denied"}`,
+    kind
+  });
+  return allowed;
+}
+function getTargetIdentity2(config) {
+  return {
+    pubkey: "",
+    dTag: config.window.dTag,
+    aggregateHash: config.window.aggregateHash
+  };
+}
 function registerFrameForGeneration(bridge, frame, config, generation) {
   const win = frame.contentWindow;
   if (!win) return null;
@@ -7490,6 +9426,15 @@ function registerFrameForGeneration(bridge, frame, config, generation) {
     dTag: config.window.dTag,
     aggregateHash: config.window.aggregateHash
   });
+  bridge.runtime.sessionRegistry.register(windowId, {
+    ...getTargetIdentity2(config),
+    windowId,
+    origin: "null",
+    type: "napplet",
+    registeredAt: Date.now(),
+    instanceId: `${windowId}:${Date.now()}`,
+    provenance: "nip-5d"
+  });
   return windowId;
 }
 function navigateFrame(bridge, frame, config, generation) {
@@ -7497,16 +9442,20 @@ function navigateFrame(bridge, frame, config, generation) {
   frame.src = config.target.url;
   return windowId;
 }
-function installPajaHost() {
-  const config = readConfig();
+async function installPajaHost() {
+  const config = await readLatestConfig(readConfig());
   const frame = getFrame();
+  setTargetUrlDisplay(config, frame);
   let currentSimulation = config.simulation;
   const getSimulation = () => currentSimulation;
   let themeService = null;
+  let stateRef = null;
   const adapter = createPajaAdapter(config, getSimulation, (theme) => {
     themeService = theme;
-  });
+  }, (request) => confirmPajaRequest(stateRef, request));
   const bridge = createShellBridge(adapter);
+  bridgeRef = bridge;
+  installPajaOriginRegistryProxy(originRegistry, () => stateRef);
   const capabilities = buildShellCapabilities(adapter);
   const services = Object.keys(adapter.services ?? {}).sort();
   let currentWindowId = null;
@@ -7518,6 +9467,8 @@ function installPajaHost() {
     simulation: currentSimulation,
     generation: 0,
     status: "booting",
+    messageFilter: "",
+    messageLog: [],
     reload() {
       if (currentWindowId) {
         bridge.runtime.destroyWindow(currentWindowId);
@@ -7541,21 +9492,63 @@ function installPajaHost() {
       themeService?.publishTheme(createDevTheme(currentSimulation.theme.mode, currentSimulation.theme.values));
       setSimulationStatus(this);
     },
+    setDomainEnabled(domain, enabled) {
+      currentSimulation = {
+        ...currentSimulation,
+        capabilities: {
+          domains: {
+            ...currentSimulation.capabilities.domains,
+            [domain]: enabled
+          },
+          disabledDomains: PAJA_SIMULATION_DOMAINS.filter(
+            (entry) => entry === domain ? !enabled : !currentSimulation.capabilities.domains[entry]
+          )
+        }
+      };
+      this.simulation = currentSimulation;
+      this.services = Object.keys(adapter.services ?? {}).filter((name) => currentSimulation.capabilities.domains[name] !== false).sort();
+      setSimulationStatus(this);
+      appendPajaMessageLog(this, "paja", { type: `paja.interface.${enabled ? "enabled" : "disabled"}`, domain });
+      this.reload();
+    },
+    setAclCapability(capability, enabled) {
+      const identity = getTargetIdentity2(config);
+      if (enabled) bridge.runtime.aclState.grant(identity.pubkey, identity.dTag, identity.aggregateHash, capability);
+      else bridge.runtime.aclState.revoke(identity.pubkey, identity.dTag, identity.aggregateHash, capability);
+      bridge.runtime.aclState.persist();
+      appendPajaMessageLog(this, "paja", { type: `paja.acl.${enabled ? "grant" : "revoke"}`, capability });
+      renderPajaDevtools(this, { bridge, signerPubkey: PAJA_DEV_SIGNER_PUBKEY });
+    },
+    clearLog() {
+      this.messageLog.length = 0;
+      renderPajaMessageLog(this);
+    },
     getState() {
       return {
         generation: this.generation,
         status: this.status,
         iframeCount: document.querySelectorAll("iframe").length,
         initSent: initReceivedGeneration === this.generation,
-        services,
-        simulation: currentSimulation
+        services: this.services,
+        simulation: currentSimulation,
+        messageLog: [...this.messageLog]
       };
     }
   };
+  stateRef = state;
   window.__KEHTO_PAJA__ = state;
   window.addEventListener("message", (event) => {
     if (event.source !== frame.contentWindow) return;
-    bridge.handleMessage(event);
+    appendPajaMessageLog(state, "napplet->shell", event.data, currentWindowId ?? void 0);
+    const proxiedSource = createPajaPostMessageProxy(event.source, state, currentWindowId ?? void 0);
+    const syntheticEvent = new Proxy(event, {
+      get(target, prop) {
+        if (prop === "source") return proxiedSource;
+        const val = Reflect.get(target, prop, target);
+        return typeof val === "function" ? val.bind(target) : val;
+      }
+    });
+    bridge.handleMessage(syntheticEvent);
     const data = event.data;
     if (data && typeof data === "object" && data.type === "shell.ready") {
       initReceivedGeneration = state.generation;
@@ -7580,12 +9573,25 @@ function installPajaHost() {
       state.setThemeMode(target.value);
     }
   });
+  document.getElementById("message-filter")?.addEventListener("input", (event) => {
+    const target = event.target;
+    if (!(target instanceof HTMLInputElement)) return;
+    state.messageFilter = target.value;
+    renderPajaMessageLog(state);
+  });
+  document.getElementById("clear-log")?.addEventListener("click", () => {
+    state.clearLog();
+  });
   setStatus(state, "booting");
   setSimulationStatus(state);
   currentWindowId = navigateFrame(bridge, frame, config, state.generation);
 }
 try {
-  installPajaHost();
+  void installPajaHost().catch((error) => {
+    const statusEl = document.getElementById("lifecycle-status");
+    if (statusEl) statusEl.textContent = "error";
+    console.error(error);
+  });
 } catch (error) {
   const statusEl = document.getElementById("lifecycle-status");
   if (statusEl) statusEl.textContent = "error";
@@ -7598,5 +9604,12 @@ try {
 
 @scure/base/index.js:
   (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/utils.js:
+@noble/curves/abstract/modular.js:
+@noble/curves/abstract/curve.js:
+@noble/curves/abstract/weierstrass.js:
+@noble/curves/secp256k1.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
 //# sourceMappingURL=browser-host.js.map