@kehto/paja 0.2.0 → 0.3.1

package/dist/browser-host.js

@@ -1,4 +1,4 @@
-// ../acl/dist/chunk-5FE7VHM4.js
+// ../acl/dist/chunk-6GH7LZSY.js
 var ALL_CAPABILITIES = [
   // v1.1 kept:
   "relay:read",
@@ -224,7 +224,7 @@ function configMap(action) {
   return { senderCap: "config:read", recipientCap: null };
 }
 function resourceMap(action) {
-  if (action === "bytes.result" || action === "bytes.error") {
+  if (action === "bytes.result" || action === "bytes.error" || action === "bytesMany.result" || action === "bytesMany.error") {
     return { senderCap: null, recipientCap: "resource:fetch" };
   }
   return { senderCap: "resource:fetch", recipientCap: null };
@@ -593,7 +593,7 @@ function deserialize2(json) {
   return defaultConfig();
 }
 
-// ../../node_modules/.pnpm/@napplet+core@0.13.0/node_modules/@napplet/core/dist/index.js
+// ../../node_modules/.pnpm/@napplet+core@0.21.0/node_modules/@napplet/core/dist/index.js
 function createDispatch() {
   const handlers = /* @__PURE__ */ new Map();
   function registerNap2(domain, handler) {
@@ -1704,7 +1704,13 @@ function createRuntimeDomainHandlers(context) {
     cvm: (windowId, msg) => handleServiceOnlyMessage(context, "cvm", windowId, msg),
     outbox: (windowId, msg) => handleServiceOnlyMessage(context, "outbox", windowId, msg),
     upload: (windowId, msg) => handleServiceOnlyMessage(context, "upload", windowId, msg),
-    intent: (windowId, msg) => handleServiceOnlyMessage(context, "intent", windowId, msg)
+    intent: (windowId, msg) => handleServiceOnlyMessage(context, "intent", windowId, msg),
+    link: (windowId, msg) => handleServiceOnlyMessage(context, "link", windowId, msg),
+    common: (windowId, msg) => handleServiceOnlyMessage(context, "common", windowId, msg),
+    lists: (windowId, msg) => handleServiceOnlyMessage(context, "lists", windowId, msg),
+    serial: (windowId, msg) => handleServiceOnlyMessage(context, "serial", windowId, msg),
+    ble: (windowId, msg) => handleServiceOnlyMessage(context, "ble", windowId, msg),
+    webrtc: (windowId, msg) => handleServiceOnlyMessage(context, "webrtc", windowId, msg)
   };
 }
 function handleStorageMessage(context, windowId, msg) {
@@ -1845,6 +1851,12 @@ function createNapEnvelopeDispatcher(handlers) {
   napDispatch.registerNap("outbox", adapt(handlers.outbox));
   napDispatch.registerNap("upload", adapt(handlers.upload));
   napDispatch.registerNap("intent", adapt(handlers.intent));
+  napDispatch.registerNap("link", adapt(handlers.link));
+  napDispatch.registerNap("common", adapt(handlers.common));
+  napDispatch.registerNap("lists", adapt(handlers.lists));
+  napDispatch.registerNap("serial", adapt(handlers.serial));
+  napDispatch.registerNap("ble", adapt(handlers.ble));
+  napDispatch.registerNap("webrtc", adapt(handlers.webrtc));
   return (windowId, envelope) => {
     currentWindowId = windowId;
     try {
@@ -3082,6 +3094,12 @@ function buildShellCapabilities(hooks) {
   const domains = hooks.relayPool ? ["relay", "outbox", ...NAP_DOMAINS] : [...NAP_DOMAINS];
   if (hooks.upload) domains.push("upload");
   if (hooks.intent?.isAvailable()) domains.push("intent");
+  if (hooks.link?.isAvailable()) domains.push("link");
+  if (hooks.common?.isAvailable()) domains.push("common");
+  if (hooks.lists?.isAvailable()) domains.push("lists");
+  if (hooks.serial?.isAvailable()) domains.push("serial");
+  if (hooks.ble?.isAvailable()) domains.push("ble");
+  if (hooks.webrtc?.isAvailable()) domains.push("webrtc");
   const sandbox = [];
   domains.push(...sandbox);
   const protocols = {};
@@ -3092,6 +3110,12 @@ function buildShellCapabilities(hooks) {
   const naps = hooks.relayPool ? ["relay", "outbox", ...NAP_DOMAINS, ...NAP_INC_PROTOCOLS] : [...NAP_DOMAINS, ...NAP_INC_PROTOCOLS];
   if (hooks.upload) naps.push("upload");
   if (hooks.intent?.isAvailable()) naps.push("intent");
+  if (hooks.link?.isAvailable()) naps.push("link");
+  if (hooks.common?.isAvailable()) naps.push("common");
+  if (hooks.lists?.isAvailable()) naps.push("lists");
+  if (hooks.serial?.isAvailable()) naps.push("serial");
+  if (hooks.ble?.isAvailable()) naps.push("ble");
+  if (hooks.webrtc?.isAvailable()) naps.push("webrtc");
   return applyCapabilityOverrides(
     { domains, protocols, naps, sandbox },
     hooks.capabilities?.disabledDomains ?? []
@@ -3269,6 +3293,496 @@ function createShellBridge(hooks) {
   };
 }
 
+// ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes(value, length, title = "") {
+  const bytes = isBytes(value);
+  const len = value?.length;
+  const needsLen = length !== void 0;
+  if (!bytes || needsLen && len !== length) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+  }
+  return value;
+}
+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"));
+function bytesToHex2(bytes) {
+  abytes(bytes);
+  if (hasHexBuiltin)
+    return bytes.toHex();
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += hexes[bytes[i]];
+  }
+  return hex;
+}
+var asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function asciiToBase16(ch) {
+  if (ch >= asciis._0 && ch <= asciis._9)
+    return ch - asciis._0;
+  if (ch >= asciis.A && ch <= asciis.F)
+    return ch - (asciis.A - 10);
+  if (ch >= asciis.a && ch <= asciis.f)
+    return ch - (asciis.a - 10);
+  return;
+}
+function hexToBytes2(hex) {
+  if (typeof hex !== "string")
+    throw new Error("hex string expected, got " + typeof hex);
+  if (hasHexBuiltin)
+    return Uint8Array.fromHex(hex);
+  const hl = hex.length;
+  const al = hl / 2;
+  if (hl % 2)
+    throw new Error("hex string expected, got unpadded hex of length " + hl);
+  const array = new Uint8Array(al);
+  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+    const n1 = asciiToBase16(hex.charCodeAt(hi));
+    const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+    if (n1 === void 0 || n2 === void 0) {
+      const char = hex[hi] + hex[hi + 1];
+      throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+    }
+    array[ai] = n1 * 16 + n2;
+  }
+  return array;
+}
+function concatBytes(...arrays) {
+  let sum = 0;
+  for (let i = 0; i < arrays.length; i++) {
+    const a = arrays[i];
+    abytes(a);
+    sum += a.length;
+  }
+  const res = new Uint8Array(sum);
+  for (let i = 0, pad = 0; i < arrays.length; i++) {
+    const a = arrays[i];
+    res.set(a, pad);
+    pad += a.length;
+  }
+  return res;
+}
+
+// ../../node_modules/.pnpm/@scure+base@2.0.0/node_modules/@scure/base/index.js
+function isBytes2(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function isArrayOf(isString, arr) {
+  if (!Array.isArray(arr))
+    return false;
+  if (arr.length === 0)
+    return true;
+  if (isString) {
+    return arr.every((item) => typeof item === "string");
+  } else {
+    return arr.every((item) => Number.isSafeInteger(item));
+  }
+}
+function afn(input) {
+  if (typeof input !== "function")
+    throw new Error("function expected");
+  return true;
+}
+function astr(label, input) {
+  if (typeof input !== "string")
+    throw new Error(`${label}: string expected`);
+  return true;
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n))
+    throw new Error(`invalid integer: ${n}`);
+}
+function aArr(input) {
+  if (!Array.isArray(input))
+    throw new Error("array expected");
+}
+function astrArr(label, input) {
+  if (!isArrayOf(true, input))
+    throw new Error(`${label}: array of strings expected`);
+}
+function anumArr(label, input) {
+  if (!isArrayOf(false, input))
+    throw new Error(`${label}: array of numbers expected`);
+}
+// @__NO_SIDE_EFFECTS__
+function chain(...args) {
+  const id = (a) => a;
+  const wrap = (a, b) => (c) => a(b(c));
+  const encode = args.map((x) => x.encode).reduceRight(wrap, id);
+  const decode2 = args.map((x) => x.decode).reduce(wrap, id);
+  return { encode, decode: decode2 };
+}
+// @__NO_SIDE_EFFECTS__
+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]));
+  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];
+      });
+    },
+    decode: (input) => {
+      aArr(input);
+      return input.map((letter) => {
+        astr("alphabet.decode", letter);
+        const i = indexes.get(letter);
+        if (i === void 0)
+          throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
+        return i;
+      });
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function join(separator = "") {
+  astr("join", separator);
+  return {
+    encode: (from) => {
+      astrArr("join.decode", from);
+      return from.join(separator);
+    },
+    decode: (to) => {
+      astr("join.decode", to);
+      return to.split(separator);
+    }
+  };
+}
+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);
+  return res;
+})();
+function convertRadix2(data, from, to, padding) {
+  aArr(data);
+  if (from <= 0 || from > 32)
+    throw new Error(`convertRadix2: wrong from=${from}`);
+  if (to <= 0 || to > 32)
+    throw new Error(`convertRadix2: wrong to=${to}`);
+  if (/* @__PURE__ */ radix2carry(from, to) > 32) {
+    throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${/* @__PURE__ */ radix2carry(from, to)}`);
+  }
+  let carry = 0;
+  let pos = 0;
+  const max = powers[from];
+  const mask = powers[to] - 1;
+  const res = [];
+  for (const n of data) {
+    anumber(n);
+    if (n >= max)
+      throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
+    carry = carry << from | n;
+    if (pos + from > 32)
+      throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
+    pos += from;
+    for (; pos >= to; pos -= to)
+      res.push((carry >> pos - to & mask) >>> 0);
+    const pow = powers[pos];
+    if (pow === void 0)
+      throw new Error("invalid carry");
+    carry &= pow - 1;
+  }
+  carry = carry << to - pos & mask;
+  if (!padding && pos >= from)
+    throw new Error("Excess padding");
+  if (!padding && carry > 0)
+    throw new Error(`Non-zero padding: ${carry}`);
+  if (padding && pos > 0)
+    res.push(carry >>> 0);
+  return res;
+}
+// @__NO_SIDE_EFFECTS__
+function radix2(bits, revPadding = false) {
+  anumber(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)
+    throw new Error("radix2: carry overflow");
+  return {
+    encode: (bytes) => {
+      if (!isBytes2(bytes))
+        throw new Error("radix2.encode input should be Uint8Array");
+      return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
+    },
+    decode: (digits) => {
+      anumArr("radix2.decode", digits);
+      return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
+    }
+  };
+}
+function unsafeWrapper(fn) {
+  afn(fn);
+  return function(...args) {
+    try {
+      return fn.apply(null, args);
+    } catch (e) {
+    }
+  };
+}
+var BECH_ALPHABET = /* @__PURE__ */ chain(/* @__PURE__ */ alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), /* @__PURE__ */ join(""));
+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];
+  }
+  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);
+    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 v of words)
+    chk = bech32Polymod(chk) ^ v;
+  for (let i = 0; i < 6; i++)
+    chk = bech32Polymod(chk);
+  chk ^= encodingConst;
+  return BECH_ALPHABET.encode(convertRadix2([chk % powers[30]], 30, 5, false));
+}
+// @__NO_SIDE_EFFECTS__
+function genBech32(encoding) {
+  const ENCODING_CONST = encoding === "bech32" ? 1 : 734539939;
+  const _words = /* @__PURE__ */ radix2(5);
+  const fromWords = _words.decode;
+  const toWords = _words.encode;
+  const fromWordsUnsafe = unsafeWrapper(fromWords);
+  function encode(prefix, words, limit = 90) {
+    astr("bech32.encode prefix", prefix);
+    if (isBytes2(words))
+      words = Array.from(words);
+    anumArr("bech32.encode", words);
+    const plen = prefix.length;
+    if (plen === 0)
+      throw new TypeError(`Invalid prefix length ${plen}`);
+    const actualLength = plen + 7 + words.length;
+    if (limit !== false && actualLength > limit)
+      throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);
+    const lowered = prefix.toLowerCase();
+    const sum = bechChecksum(lowered, words, ENCODING_CONST);
+    return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}`;
+  }
+  function decode2(str, limit = 90) {
+    astr("bech32.decode input", str);
+    const slen = str.length;
+    if (slen < 8 || limit !== false && slen > limit)
+      throw new TypeError(`invalid string length: ${slen} (${str}). Expected (8..${limit})`);
+    const lowered = str.toLowerCase();
+    if (str !== lowered && str !== str.toUpperCase())
+      throw new Error(`String must be lowercase or uppercase`);
+    const sepIndex = lowered.lastIndexOf("1");
+    if (sepIndex === 0 || sepIndex === -1)
+      throw new Error(`Letter "1" must be present between prefix and data only`);
+    const prefix = lowered.slice(0, sepIndex);
+    const data = lowered.slice(sepIndex + 1);
+    if (data.length < 6)
+      throw new Error("Data must be at least 6 characters long");
+    const words = BECH_ALPHABET.decode(data).slice(0, -6);
+    const sum = bechChecksum(prefix, words, ENCODING_CONST);
+    if (!data.endsWith(sum))
+      throw new Error(`Invalid checksum in ${str}: expected "${sum}"`);
+    return { prefix, words };
+  }
+  const decodeUnsafe = unsafeWrapper(decode2);
+  function decodeToBytes(str) {
+    const { prefix, words } = decode2(str, false);
+    return { prefix, words, bytes: fromWords(words) };
+  }
+  function encodeFromBytes(prefix, bytes) {
+    return encode(prefix, toWords(bytes));
+  }
+  return {
+    encode,
+    decode: decode2,
+    encodeFromBytes,
+    decodeToBytes,
+    decodeUnsafe,
+    fromWords,
+    fromWordsUnsafe,
+    toWords
+  };
+}
+var bech32 = /* @__PURE__ */ genBech32("bech32");
+
+// ../../node_modules/.pnpm/nostr-tools@2.23.3_typescript@5.9.3/node_modules/nostr-tools/lib/esm/nip19.js
+var utf8Decoder = new TextDecoder("utf-8");
+var utf8Encoder = new TextEncoder();
+var Bech32MaxSize = 5e3;
+function integerToUint8Array(number) {
+  const uint8Array = new Uint8Array(4);
+  uint8Array[0] = number >> 24 & 255;
+  uint8Array[1] = number >> 16 & 255;
+  uint8Array[2] = number >> 8 & 255;
+  uint8Array[3] = number & 255;
+  return uint8Array;
+}
+function decode(code) {
+  let { prefix, words } = bech32.decode(code, Bech32MaxSize);
+  let data = new Uint8Array(bech32.fromWords(words));
+  switch (prefix) {
+    case "nprofile": {
+      let tlv = parseTLV(data);
+      if (!tlv[0]?.[0])
+        throw new Error("missing TLV 0 for nprofile");
+      if (tlv[0][0].length !== 32)
+        throw new Error("TLV 0 should be 32 bytes");
+      return {
+        type: "nprofile",
+        data: {
+          pubkey: bytesToHex2(tlv[0][0]),
+          relays: tlv[1] ? tlv[1].map((d) => utf8Decoder.decode(d)) : []
+        }
+      };
+    }
+    case "nevent": {
+      let tlv = parseTLV(data);
+      if (!tlv[0]?.[0])
+        throw new Error("missing TLV 0 for nevent");
+      if (tlv[0][0].length !== 32)
+        throw new Error("TLV 0 should be 32 bytes");
+      if (tlv[2] && tlv[2][0].length !== 32)
+        throw new Error("TLV 2 should be 32 bytes");
+      if (tlv[3] && tlv[3][0].length !== 4)
+        throw new Error("TLV 3 should be 4 bytes");
+      return {
+        type: "nevent",
+        data: {
+          id: bytesToHex2(tlv[0][0]),
+          relays: tlv[1] ? tlv[1].map((d) => utf8Decoder.decode(d)) : [],
+          author: tlv[2]?.[0] ? bytesToHex2(tlv[2][0]) : void 0,
+          kind: tlv[3]?.[0] ? parseInt(bytesToHex2(tlv[3][0]), 16) : void 0
+        }
+      };
+    }
+    case "naddr": {
+      let tlv = parseTLV(data);
+      if (!tlv[0]?.[0])
+        throw new Error("missing TLV 0 for naddr");
+      if (!tlv[2]?.[0])
+        throw new Error("missing TLV 2 for naddr");
+      if (tlv[2][0].length !== 32)
+        throw new Error("TLV 2 should be 32 bytes");
+      if (!tlv[3]?.[0])
+        throw new Error("missing TLV 3 for naddr");
+      if (tlv[3][0].length !== 4)
+        throw new Error("TLV 3 should be 4 bytes");
+      return {
+        type: "naddr",
+        data: {
+          identifier: utf8Decoder.decode(tlv[0][0]),
+          pubkey: bytesToHex2(tlv[2][0]),
+          kind: parseInt(bytesToHex2(tlv[3][0]), 16),
+          relays: tlv[1] ? tlv[1].map((d) => utf8Decoder.decode(d)) : []
+        }
+      };
+    }
+    case "nsec":
+      return { type: prefix, data };
+    case "npub":
+    case "note":
+      return { type: prefix, data: bytesToHex2(data) };
+    default:
+      throw new Error(`unknown prefix ${prefix}`);
+  }
+}
+function parseTLV(data) {
+  let result = {};
+  let rest = data;
+  while (rest.length > 0) {
+    let t = rest[0];
+    let l = rest[1];
+    let v = rest.slice(2, 2 + l);
+    rest = rest.slice(2 + l);
+    if (v.length < l)
+      throw new Error(`not enough data to read on TLV ${t}`);
+    result[t] = result[t] || [];
+    result[t].push(v);
+  }
+  return result;
+}
+function npubEncode(hex) {
+  return encodeBytes("npub", hexToBytes2(hex));
+}
+function noteEncode(hex) {
+  return encodeBytes("note", hexToBytes2(hex));
+}
+function encodeBech32(prefix, data) {
+  let words = bech32.toWords(data);
+  return bech32.encode(prefix, words, Bech32MaxSize);
+}
+function encodeBytes(prefix, bytes) {
+  return encodeBech32(prefix, bytes);
+}
+function nprofileEncode(profile) {
+  let data = encodeTLV({
+    0: [hexToBytes2(profile.pubkey)],
+    1: (profile.relays || []).map((url) => utf8Encoder.encode(url))
+  });
+  return encodeBech32("nprofile", data);
+}
+function neventEncode(event) {
+  let kindArray;
+  if (event.kind !== void 0) {
+    kindArray = integerToUint8Array(event.kind);
+  }
+  let data = encodeTLV({
+    0: [hexToBytes2(event.id)],
+    1: (event.relays || []).map((url) => utf8Encoder.encode(url)),
+    2: event.author ? [hexToBytes2(event.author)] : [],
+    3: kindArray ? [new Uint8Array(kindArray)] : []
+  });
+  return encodeBech32("nevent", data);
+}
+function naddrEncode(addr) {
+  let kind = new ArrayBuffer(4);
+  new DataView(kind).setUint32(0, addr.kind, false);
+  let data = encodeTLV({
+    0: [utf8Encoder.encode(addr.identifier)],
+    1: (addr.relays || []).map((url) => utf8Encoder.encode(url)),
+    2: [hexToBytes2(addr.pubkey)],
+    3: [new Uint8Array(kind)]
+  });
+  return encodeBech32("naddr", data);
+}
+function encodeTLV(tlv) {
+  let entries = [];
+  Object.entries(tlv).reverse().forEach(([t, vs]) => {
+    vs.forEach((v) => {
+      let entry = new Uint8Array(v.length + 2);
+      entry.set([parseInt(t)], 0);
+      entry.set([v.length], 1);
+      entry.set(v, 2);
+      entries.push(entry);
+    });
+  });
+  return concatBytes(...entries);
+}
+
 // ../services/dist/index.js
 var NOTIFICATION_SERVICE_VERSION = "1.0.0";
 var DEFAULT_MAX_PER_WINDOW = 100;
@@ -4657,19 +5171,35 @@ function untrackRequest(state, requestId) {
     state.perWindow.get(entry.windowId)?.delete(requestId);
   }
 }
-function sendResourceError(send, requestId, code, message) {
+function sendResourceError(send, requestId, code, message, error = toResourceError(code), type = "resource.bytes.error") {
   send({
-    type: "resource.bytes.error",
+    type,
+    id: requestId,
     requestId,
+    error,
     code,
     message
   });
 }
-function parseResourceUrl(send, requestId, url) {
+function sendBytesManyError(send, requestId, code, message, error) {
+  sendResourceError(send, requestId, code, message, error, "resource.bytesMany.error");
+}
+function toResourceError(code) {
+  switch (code) {
+    case "denied":
+      return "blocked-by-policy";
+    case "invalid-url":
+      return "invalid-request";
+    case "canceled":
+      return "timeout";
+    case "network-error":
+      return "network-error";
+  }
+}
+function parseResourceUrl(url) {
   try {
     return new URL(url);
   } catch {
-    sendResourceError(send, requestId, "invalid-url", `invalid URL: ${url}`);
     return null;
   }
 }
@@ -4680,45 +5210,138 @@ function collectResponseHeaders(response) {
   });
   return headers;
 }
-async function handleBytes(options, state, windowId, msg, send) {
-  const { requestId, url, init } = msg;
-  const identity = options.resolveIdentity(windowId);
-  if (!identity) {
-    sendResourceError(send, requestId, "denied", "napplet identity not resolvable");
-    return;
-  }
-  const parsedUrl = parseResourceUrl(send, requestId, url);
-  if (!parsedUrl) return;
+function responseMime(response) {
+  return response.headers.get("content-type") || "application/octet-stream";
+}
+function responseBlob(buffer, mime) {
+  return new Blob([buffer], { type: mime });
+}
+function requestIdFromMessage(message) {
+  if (typeof message.id === "string" && message.id.length > 0) return message.id;
+  if (typeof message.requestId === "string" && message.requestId.length > 0) return message.requestId;
+  return null;
+}
+function resourceInvalidRequest(url, message) {
+  return {
+    ok: false,
+    url,
+    error: "invalid-request",
+    code: "invalid-url",
+    message
+  };
+}
+async function fetchResourceItem(options, identity, url, init, signal) {
+  const parsedUrl = parseResourceUrl(url);
+  if (!parsedUrl) return resourceInvalidRequest(url, `invalid URL: ${url}`);
   const origin = parsedUrl.origin;
   const grants = options.getConnectGrants(identity.dTag, identity.aggregateHash);
   if (!options.isOriginGranted(origin, grants)) {
-    sendResourceError(send, requestId, "denied", `origin ${origin} not granted`);
-    return;
+    return {
+      ok: false,
+      url,
+      error: "blocked-by-policy",
+      code: "denied",
+      message: `origin ${origin} not granted`
+    };
   }
-  const controller = new AbortController();
-  trackRequest(state, requestId, windowId, controller);
   try {
     const response = await options.fetch(url, {
       method: init?.method,
       headers: init?.headers ? { ...init.headers } : void 0,
-      signal: controller.signal
+      signal
     });
     const buffer = await response.arrayBuffer();
+    const headers = collectResponseHeaders(response);
+    const mime = responseMime(response);
+    return {
+      ok: true,
+      url,
+      blob: responseBlob(buffer, mime),
+      mime,
+      status: response.status,
+      headers,
+      bodyBase64: arrayBufferToBase64(buffer)
+    };
+  } catch (err) {
+    const isAbort = signal.aborted || err instanceof Error && (err.name === "AbortError" || err.name === "DOMException");
+    return {
+      ok: false,
+      url,
+      error: isAbort ? "timeout" : "network-error",
+      code: isAbort ? "canceled" : "network-error",
+      message: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function handleBytes(options, state, windowId, msg, send) {
+  const { requestId, url, init } = msg;
+  const identity = options.resolveIdentity(windowId);
+  if (!identity) {
+    sendResourceError(send, requestId, "denied", "napplet identity not resolvable", "blocked-by-policy");
+    return;
+  }
+  const controller = new AbortController();
+  trackRequest(state, requestId, windowId, controller);
+  try {
+    const item = await fetchResourceItem(options, identity, url, init, controller.signal);
+    if (!item.ok) {
+      sendResourceError(send, requestId, item.code, item.message, item.error);
+      return;
+    }
     send({
       type: "resource.bytes.result",
+      id: requestId,
       requestId,
-      status: response.status,
-      headers: collectResponseHeaders(response),
-      bodyBase64: arrayBufferToBase64(buffer)
+      blob: item.blob,
+      mime: item.mime,
+      status: item.status,
+      headers: item.headers,
+      bodyBase64: item.bodyBase64
     });
-  } catch (err) {
-    const isAbort = controller.signal.aborted || err instanceof Error && (err.name === "AbortError" || err.name === "DOMException");
-    sendResourceError(
-      send,
+  } finally {
+    untrackRequest(state, requestId);
+  }
+}
+async function handleBytesMany(options, state, windowId, msg, send) {
+  const { requestId, urls, init } = msg;
+  if (!Array.isArray(urls) || urls.length === 0 || urls.some((url) => typeof url !== "string")) {
+    sendBytesManyError(send, requestId, "invalid-url", "resource.bytesMany requires a non-empty urls array", "invalid-request");
+    return;
+  }
+  const identity = options.resolveIdentity(windowId);
+  if (!identity) {
+    sendBytesManyError(send, requestId, "denied", "napplet identity not resolvable", "blocked-by-policy");
+    return;
+  }
+  const controller = new AbortController();
+  trackRequest(state, requestId, windowId, controller);
+  try {
+    const items = [];
+    for (const url of urls) {
+      const item = await fetchResourceItem(options, identity, url, init, controller.signal);
+      if (item.ok) {
+        items.push({
+          url: item.url,
+          ok: true,
+          blob: item.blob,
+          mime: item.mime
+        });
+      } else {
+        items.push({
+          url: item.url,
+          ok: false,
+          error: item.error,
+          code: item.code,
+          message: item.message
+        });
+      }
+    }
+    send({
+      type: "resource.bytesMany.result",
+      id: requestId,
       requestId,
-      isAbort ? "canceled" : "network-error",
-      err instanceof Error ? err.message : String(err)
-    );
+      items
+    });
   } finally {
     untrackRequest(state, requestId);
   }
@@ -4758,13 +5381,24 @@ function createResourceService(options) {
       switch (message.type) {
         case "resource.bytes": {
           const m = message;
-          handleBytes(options, state, windowId, m, send).catch(() => {
+          const requestId = requestIdFromMessage(m);
+          if (!requestId || typeof m.url !== "string") return;
+          handleBytes(options, state, windowId, { requestId, url: m.url, init: m.init }, send).catch(() => {
+          });
+          return;
+        }
+        case "resource.bytesMany": {
+          const m = message;
+          const requestId = requestIdFromMessage(m);
+          if (!requestId) return;
+          handleBytesMany(options, state, windowId, { requestId, urls: m.urls ?? [], init: m.init }, send).catch(() => {
           });
           return;
         }
         case "resource.cancel": {
           const m = message;
-          handleCancel(state, m.requestId);
+          const requestId = requestIdFromMessage(m);
+          if (requestId) handleCancel(state, requestId);
           return;
         }
         default:
@@ -5042,7 +5676,7 @@ function createIntentService(options) {
       send({ type: "intent.changed", availability });
     }
   });
-  function settle(call, send, resultType, id, onValue) {
+  function settle6(call, send, resultType, id, onValue) {
     let pending;
     try {
       pending = Promise.resolve(call());
@@ -5060,7 +5694,7 @@ function createIntentService(options) {
       send({ type: "intent.invoke.result", id, error: "invalid request" });
       return;
     }
-    settle(
+    settle6(
       () => resolver.invoke(request, { windowId }),
       send,
       "intent.invoke.result",
@@ -5076,7 +5710,7 @@ function createIntentService(options) {
       return;
     }
     const archetype = m.archetype;
-    settle(
+    settle6(
       () => resolver.available(archetype),
       send,
       "intent.available.result",
@@ -5087,7 +5721,7 @@ function createIntentService(options) {
   function handleHandlers(msg, send) {
     const m = msg;
     const id = m.id ?? "";
-    settle(
+    settle6(
       () => resolver.handlers(),
       send,
       "intent.handlers.result",
@@ -5222,6 +5856,708 @@ function toErrorMessage5(err) {
   if (typeof err === "string") return err;
   return "cvm request failed";
 }
+var LINK_SERVICE_VERSION = "1.0.0";
+var DEFAULT_ALLOWED_PROTOCOLS = ["http:", "https:"];
+function denied(id, error) {
+  return { type: "link.open.result", id, status: "denied", error };
+}
+function parseLinkUrl(id, rawUrl) {
+  try {
+    return new URL(rawUrl);
+  } catch {
+    return denied(id, "invalid-url");
+  }
+}
+function isProtocolAllowed(url, allowedProtocols) {
+  return allowedProtocols.includes(url.protocol);
+}
+async function handleOpen(options, windowId, message, send) {
+  const parsed = parseLinkUrl(message.id, message.url);
+  if ("type" in parsed) {
+    send(parsed);
+    return;
+  }
+  const allowedProtocols = options.allowedProtocols ?? DEFAULT_ALLOWED_PROTOCOLS;
+  if (!isProtocolAllowed(parsed, allowedProtocols)) {
+    send(denied(message.id, "unsupported-scheme"));
+    return;
+  }
+  if (!options.open) {
+    send(denied(message.id, "blocked-by-policy"));
+    return;
+  }
+  try {
+    const result = await options.open({ windowId, url: parsed, options: message.options });
+    send({
+      type: "link.open.result",
+      id: message.id,
+      status: result.status,
+      ...result.status === "denied" ? { error: "blocked-by-policy" } : {}
+    });
+  } catch {
+    send(denied(message.id, "blocked-by-policy"));
+  }
+}
+function createLinkService(options = {}) {
+  const descriptor = {
+    name: "link",
+    version: LINK_SERVICE_VERSION,
+    description: "NAP-LINK reference handler for shell-mediated link opening"
+  };
+  return {
+    descriptor,
+    handleMessage(windowId, message, send) {
+      if (message.type === "link.open") {
+        void handleOpen(options, windowId, message, send);
+        return;
+      }
+      const id = message.id ?? "";
+      send({
+        type: `${message.type}.error`,
+        id,
+        error: `Unknown link method: ${message.type}`
+      });
+    },
+    onWindowDestroyed(_windowId) {
+    }
+  };
+}
+var LISTS_SERVICE_VERSION = "1.0.0";
+var LISTS_DESCRIPTOR = {
+  name: "lists",
+  version: LISTS_SERVICE_VERSION,
+  description: "NAP-LISTS reference handler for shell-mediated NIP-51 list mutations"
+};
+function errorMessage(err, fallback) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return fallback;
+}
+function settle(call, send, okFalse, onValue) {
+  let pending;
+  try {
+    pending = Promise.resolve(call());
+  } catch (err) {
+    send(okFalse(errorMessage(err, "lists request failed")));
+    return;
+  }
+  pending.then((value) => send(onValue(value))).catch((err) => send(okFalse(errorMessage(err, "lists request failed"))));
+}
+function unsupportedMutation(resultType, id) {
+  return {
+    type: resultType,
+    id,
+    ok: false,
+    error: "unsupported",
+    reason: `${resultType.replace(".result", "")} unavailable`,
+    supported: []
+  };
+}
+function settleMutation(hook, message, context, send, resultType) {
+  if (!hook) {
+    send(unsupportedMutation(resultType, message.id));
+    return;
+  }
+  settle(
+    () => hook(message.list, message.items, message.options, context),
+    send,
+    (error) => ({ type: resultType, id: message.id, ok: false, error: "list-unavailable", reason: error }),
+    (result) => ({ type: resultType, id: message.id, ...result })
+  );
+}
+function createListsService(options = {}) {
+  return {
+    descriptor: LISTS_DESCRIPTOR,
+    handleMessage(windowId, message, send) {
+      const id = message.id ?? "";
+      const context = { windowId };
+      if (message.type === "lists.supported") {
+        if (!options.supported) {
+          send({ type: "lists.supported.result", id, lists: [] });
+          return;
+        }
+        settle(
+          () => options.supported(context),
+          send,
+          (error) => ({ type: "lists.supported.result", id, error }),
+          (lists) => ({ type: "lists.supported.result", id, lists: [...lists] })
+        );
+        return;
+      }
+      if (message.type === "lists.add") {
+        settleMutation(options.add, message, context, send, "lists.add.result");
+        return;
+      }
+      if (message.type === "lists.remove") {
+        settleMutation(options.remove, message, context, send, "lists.remove.result");
+        return;
+      }
+      send({
+        type: `${message.type}.error`,
+        id,
+        error: `Unknown lists method: ${message.type}`
+      });
+    },
+    onWindowDestroyed(_windowId) {
+    }
+  };
+}
+var SERIAL_SERVICE_VERSION = "1.0.0";
+var SERIAL_DESCRIPTOR = {
+  name: "serial",
+  version: SERIAL_SERVICE_VERSION,
+  description: "NAP-SERIAL reference handler for shell-mediated serial sessions"
+};
+function errorMessage2(err, fallback) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return fallback;
+}
+function settle2(call, send, okFalse, onValue) {
+  let pending;
+  try {
+    pending = Promise.resolve(call());
+  } catch (err) {
+    send(okFalse(errorMessage2(err, "serial request failed")));
+    return;
+  }
+  pending.then((value) => send(onValue(value))).catch((err) => send(okFalse(errorMessage2(err, "serial request failed"))));
+}
+function unsupported(resultType, id) {
+  return {
+    type: resultType,
+    id,
+    error: `${resultType.replace(".result", "")} unavailable`
+  };
+}
+function createSerialService(options = {}) {
+  return {
+    descriptor: SERIAL_DESCRIPTOR,
+    handleMessage(windowId, message, send) {
+      const id = message.id ?? "";
+      const context = { windowId };
+      if (message.type === "serial.open") {
+        if (!options.open) {
+          send(unsupported("serial.open.result", id));
+          return;
+        }
+        const serialMessage = message;
+        settle2(
+          () => options.open(serialMessage.request, context),
+          send,
+          (error) => ({ type: "serial.open.result", id, error }),
+          (result) => ({ type: "serial.open.result", id, session: result.session })
+        );
+        return;
+      }
+      if (message.type === "serial.write") {
+        if (!options.write) {
+          send(unsupported("serial.write.result", id));
+          return;
+        }
+        const serialMessage = message;
+        settle2(
+          () => options.write(serialMessage.sessionId, serialMessage.data, context),
+          send,
+          (error) => ({ type: "serial.write.result", id, error }),
+          () => ({ type: "serial.write.result", id })
+        );
+        return;
+      }
+      if (message.type === "serial.close") {
+        if (!options.close) {
+          send(unsupported("serial.close.result", id));
+          return;
+        }
+        const serialMessage = message;
+        settle2(
+          () => options.close(serialMessage.sessionId, serialMessage.reason, context),
+          send,
+          (error) => ({ type: "serial.close.result", id, error }),
+          () => ({ type: "serial.close.result", id })
+        );
+        return;
+      }
+      send({
+        type: `${message.type}.error`,
+        id,
+        error: `Unknown serial method: ${message.type}`
+      });
+    },
+    onWindowDestroyed(windowId) {
+      options.destroyWindow?.(windowId);
+    }
+  };
+}
+var BLE_SERVICE_VERSION = "1.0.0";
+var BLE_DESCRIPTOR = {
+  name: "ble",
+  version: BLE_SERVICE_VERSION,
+  description: "NAP-BLE reference handler for shell-mediated BLE/GATT sessions"
+};
+function errorMessage3(err, fallback) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return fallback;
+}
+function settle3(call, send, okFalse, onValue) {
+  let pending;
+  try {
+    pending = Promise.resolve(call());
+  } catch (err) {
+    send(okFalse(errorMessage3(err, "ble request failed")));
+    return;
+  }
+  pending.then((value) => send(onValue(value))).catch((err) => send(okFalse(errorMessage3(err, "ble request failed"))));
+}
+function unsupported2(resultType, id) {
+  return {
+    type: resultType,
+    id,
+    error: `${resultType.replace(".result", "")} unavailable`
+  };
+}
+function createBleService(options = {}) {
+  return {
+    descriptor: BLE_DESCRIPTOR,
+    handleMessage(windowId, message, send) {
+      const id = message.id ?? "";
+      const context = { windowId };
+      if (message.type === "ble.open") {
+        if (!options.open) {
+          send(unsupported2("ble.open.result", id));
+          return;
+        }
+        const bleMessage = message;
+        settle3(
+          () => options.open(bleMessage.request, context),
+          send,
+          (error) => ({ type: "ble.open.result", id, error }),
+          (result) => ({ type: "ble.open.result", id, session: result.session })
+        );
+        return;
+      }
+      if (message.type === "ble.services") {
+        if (!options.services) {
+          send(unsupported2("ble.services.result", id));
+          return;
+        }
+        const bleMessage = message;
+        settle3(
+          () => options.services(bleMessage.sessionId, context),
+          send,
+          (error) => ({ type: "ble.services.result", id, error }),
+          (services) => ({ type: "ble.services.result", id, services })
+        );
+        return;
+      }
+      if (message.type === "ble.read") {
+        if (!options.read) {
+          send(unsupported2("ble.read.result", id));
+          return;
+        }
+        const bleMessage = message;
+        settle3(
+          () => options.read(bleMessage.sessionId, bleMessage.target, context),
+          send,
+          (error) => ({ type: "ble.read.result", id, error }),
+          (data) => ({ type: "ble.read.result", id, data })
+        );
+        return;
+      }
+      if (message.type === "ble.write") {
+        if (!options.write) {
+          send(unsupported2("ble.write.result", id));
+          return;
+        }
+        const bleMessage = message;
+        settle3(
+          () => options.write(bleMessage.sessionId, bleMessage.target, bleMessage.data, bleMessage.options, context),
+          send,
+          (error) => ({ type: "ble.write.result", id, error }),
+          () => ({ type: "ble.write.result", id })
+        );
+        return;
+      }
+      if (message.type === "ble.subscribe") {
+        if (!options.subscribe) {
+          send(unsupported2("ble.subscribe.result", id));
+          return;
+        }
+        const bleMessage = message;
+        settle3(
+          () => options.subscribe(bleMessage.sessionId, bleMessage.target, context),
+          send,
+          (error) => ({ type: "ble.subscribe.result", id, error }),
+          () => ({ type: "ble.subscribe.result", id })
+        );
+        return;
+      }
+      if (message.type === "ble.unsubscribe") {
+        if (!options.unsubscribe) {
+          send(unsupported2("ble.unsubscribe.result", id));
+          return;
+        }
+        const bleMessage = message;
+        settle3(
+          () => options.unsubscribe(bleMessage.sessionId, bleMessage.target, context),
+          send,
+          (error) => ({ type: "ble.unsubscribe.result", id, error }),
+          () => ({ type: "ble.unsubscribe.result", id })
+        );
+        return;
+      }
+      if (message.type === "ble.close") {
+        if (!options.close) {
+          send(unsupported2("ble.close.result", id));
+          return;
+        }
+        const bleMessage = message;
+        settle3(
+          () => options.close(bleMessage.sessionId, bleMessage.reason, context),
+          send,
+          (error) => ({ type: "ble.close.result", id, error }),
+          () => ({ type: "ble.close.result", id })
+        );
+        return;
+      }
+      send({
+        type: `${message.type}.error`,
+        id,
+        error: `Unknown ble method: ${message.type}`
+      });
+    },
+    onWindowDestroyed(windowId) {
+      options.destroyWindow?.(windowId);
+    }
+  };
+}
+var WEBRTC_SERVICE_VERSION = "1.0.0";
+var WEBRTC_DESCRIPTOR = {
+  name: "webrtc",
+  version: WEBRTC_SERVICE_VERSION,
+  description: "NAP-WEBRTC reference handler for shell-mediated WebRTC sessions"
+};
+function errorMessage4(err, fallback) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return fallback;
+}
+function settle4(call, send, okFalse, onValue) {
+  let pending;
+  try {
+    pending = Promise.resolve(call());
+  } catch (err) {
+    send(okFalse(errorMessage4(err, "webrtc request failed")));
+    return;
+  }
+  pending.then((value) => send(onValue(value))).catch((err) => send(okFalse(errorMessage4(err, "webrtc request failed"))));
+}
+function unsupported3(resultType, id) {
+  return {
+    type: resultType,
+    id,
+    error: `${resultType.replace(".result", "")} unavailable`
+  };
+}
+function createContext(windowId, send) {
+  return {
+    windowId,
+    emit(event) {
+      send({ type: "webrtc.event", event });
+    }
+  };
+}
+function createWebrtcService(options = {}) {
+  return {
+    descriptor: WEBRTC_DESCRIPTOR,
+    handleMessage(windowId, message, send) {
+      const id = message.id ?? "";
+      const context = createContext(windowId, send);
+      if (message.type === "webrtc.open") {
+        if (!options.open) {
+          send(unsupported3("webrtc.open.result", id));
+          return;
+        }
+        const webrtcMessage = message;
+        settle4(
+          () => options.open(webrtcMessage.request, context),
+          send,
+          (error) => ({ type: "webrtc.open.result", id, error }),
+          (result) => ({ type: "webrtc.open.result", id, session: result.session })
+        );
+        return;
+      }
+      if (message.type === "webrtc.send") {
+        if (!options.send) {
+          send(unsupported3("webrtc.send.result", id));
+          return;
+        }
+        const webrtcMessage = message;
+        settle4(
+          () => options.send(webrtcMessage.sessionId, webrtcMessage.payload, context),
+          send,
+          (error) => ({ type: "webrtc.send.result", id, error }),
+          () => ({ type: "webrtc.send.result", id })
+        );
+        return;
+      }
+      if (message.type === "webrtc.close") {
+        if (!options.close) {
+          send(unsupported3("webrtc.close.result", id));
+          return;
+        }
+        const webrtcMessage = message;
+        settle4(
+          () => options.close(webrtcMessage.sessionId, webrtcMessage.reason, context),
+          send,
+          (error) => ({ type: "webrtc.close.result", id, error }),
+          () => ({ type: "webrtc.close.result", id })
+        );
+        return;
+      }
+      send({
+        type: `${message.type}.error`,
+        id,
+        error: `Unknown webrtc method: ${message.type}`
+      });
+    },
+    onWindowDestroyed(windowId) {
+      options.destroyWindow?.(windowId);
+    }
+  };
+}
+var COMMON_SERVICE_VERSION = "1.0.0";
+var BECH32_CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+var COMMON_DESCRIPTOR = {
+  name: "common",
+  version: COMMON_SERVICE_VERSION,
+  description: "NAP-COMMON reference handler for shell-mediated social helpers"
+};
+function errorMessage5(err, fallback) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return fallback;
+}
+function encodeNip19(input) {
+  try {
+    switch (input.type) {
+      case "npub":
+        return { ok: true, value: npubEncode(input.hex), nip19Type: input.type };
+      case "note":
+        return { ok: true, value: noteEncode(input.hex), nip19Type: input.type };
+      case "nprofile":
+        return { ok: true, value: nprofileEncode({ pubkey: input.pubkey, relays: input.relays }), nip19Type: input.type };
+      case "nevent":
+        return {
+          ok: true,
+          value: neventEncode({ id: input.eventId, relays: input.relays, author: input.author, kind: input.kind }),
+          nip19Type: input.type
+        };
+      case "naddr":
+        return {
+          ok: true,
+          value: naddrEncode({ identifier: input.identifier, pubkey: input.pubkey, kind: input.kind, relays: input.relays }),
+          nip19Type: input.type
+        };
+      case "nrelay":
+        return { ok: true, value: encodeBytes("nrelay", new TextEncoder().encode(input.relay)), nip19Type: input.type };
+      default:
+        return { ok: false, error: "unsupported NIP-19 type" };
+    }
+  } catch (err) {
+    return { ok: false, error: errorMessage5(err, "NIP-19 encode failed") };
+  }
+}
+function decodeNip19Value(value) {
+  try {
+    const decoded = decode(value);
+    switch (decoded.type) {
+      case "npub":
+      case "note":
+        return { ok: true, nip19Type: decoded.type, hex: decoded.data };
+      case "nprofile":
+        return { ok: true, nip19Type: decoded.type, pubkey: decoded.data.pubkey, relays: decoded.data.relays };
+      case "nevent":
+        return {
+          ok: true,
+          nip19Type: decoded.type,
+          eventId: decoded.data.id,
+          relays: decoded.data.relays,
+          author: decoded.data.author,
+          kind: decoded.data.kind
+        };
+      case "naddr":
+        return {
+          ok: true,
+          nip19Type: decoded.type,
+          identifier: decoded.data.identifier,
+          pubkey: decoded.data.pubkey,
+          kind: decoded.data.kind,
+          relays: decoded.data.relays
+        };
+      default:
+        return { ok: false, error: "unsupported NIP-19 type" };
+    }
+  } catch (err) {
+    if (value.startsWith("nrelay1")) return decodeNrelay(value);
+    return { ok: false, error: errorMessage5(err, "NIP-19 decode failed") };
+  }
+}
+function decodeNrelay(value) {
+  try {
+    const separator = value.lastIndexOf("1");
+    if (separator <= 0 || separator + 7 > value.length) return { ok: false, error: "invalid nrelay value" };
+    const dataPart = value.slice(separator + 1);
+    const words = [...dataPart].map((char) => {
+      const index = BECH32_CHARSET.indexOf(char);
+      if (index === -1) throw new Error("invalid nrelay character");
+      return index;
+    });
+    const payloadWords = words.slice(0, -6);
+    const bytes = convertBits(payloadWords, 5, 8, false);
+    return { ok: true, nip19Type: "nrelay", relay: new TextDecoder().decode(Uint8Array.from(bytes)) };
+  } catch (err) {
+    return { ok: false, error: errorMessage5(err, "invalid nrelay value") };
+  }
+}
+function convertBits(data, fromBits, toBits, pad) {
+  let acc = 0;
+  let bits = 0;
+  const result = [];
+  const maxv = (1 << toBits) - 1;
+  const maxAcc = (1 << fromBits + toBits - 1) - 1;
+  for (const value of data) {
+    if (value < 0 || value >> fromBits !== 0) throw new Error("invalid bech32 data");
+    acc = (acc << fromBits | value) & maxAcc;
+    bits += fromBits;
+    while (bits >= toBits) {
+      bits -= toBits;
+      result.push(acc >> bits & maxv);
+    }
+  }
+  if (pad) {
+    if (bits > 0) result.push(acc << toBits - bits & maxv);
+  } else if (bits >= fromBits || (acc << toBits - bits & maxv) !== 0) {
+    throw new Error("invalid bech32 padding");
+  }
+  return result;
+}
+function settle5(call, send, okFalse, onValue) {
+  let pending;
+  try {
+    pending = Promise.resolve(call());
+  } catch (err) {
+    send(okFalse(errorMessage5(err, "common request failed")));
+    return;
+  }
+  pending.then((value) => send(onValue(value))).catch((err) => send(okFalse(errorMessage5(err, "common request failed"))));
+}
+function createCommonService(options = {}) {
+  return {
+    descriptor: COMMON_DESCRIPTOR,
+    handleMessage(windowId, message, send) {
+      const id = message.id ?? "";
+      const context = { windowId };
+      if (message.type === "common.encodeNip19") {
+        const input = message.input;
+        const result = input ? encodeNip19(input) : { ok: false, error: "invalid input" };
+        send({ type: "common.encodeNip19.result", id, ...result });
+        return;
+      }
+      if (message.type === "common.decodeNip19") {
+        const value = message.value;
+        const result = typeof value === "string" ? decodeNip19Value(value) : { ok: false, error: "invalid value" };
+        send({ type: "common.decodeNip19.result", id, ...result });
+        return;
+      }
+      if (message.type === "common.getProfile") {
+        const target = message.target;
+        if (!options.getProfile) {
+          send({ type: "common.getProfile.result", id, ok: false, pubkey: target ?? "", error: "profile lookup unavailable" });
+          return;
+        }
+        settle5(
+          () => options.getProfile(target, context),
+          send,
+          (error) => ({ type: "common.getProfile.result", id, ok: false, pubkey: target ?? "", error }),
+          (result) => ({ type: "common.getProfile.result", id, ...result })
+        );
+        return;
+      }
+      if (message.type === "common.follows") {
+        if (!options.follows) {
+          send({ type: "common.follows.result", id, ok: false, pubkeys: [], error: "follows lookup unavailable" });
+          return;
+        }
+        settle5(
+          () => options.follows(context),
+          send,
+          (error) => ({ type: "common.follows.result", id, ok: false, pubkeys: [], error }),
+          (result) => ({ type: "common.follows.result", id, ...result })
+        );
+        return;
+      }
+      if (message.type === "common.follow") {
+        const pubkeys = message.pubkeys ?? [];
+        settleAction(options.follow, pubkeys, context, send, "common.follow.result", id, "follow unavailable");
+        return;
+      }
+      if (message.type === "common.unfollow") {
+        const pubkeys = message.pubkeys ?? [];
+        settleAction(options.unfollow, pubkeys, context, send, "common.unfollow.result", id, "unfollow unavailable");
+        return;
+      }
+      if (message.type === "common.react") {
+        const m = message;
+        if (!options.react) {
+          send({ type: "common.react.result", id, ok: false, error: "react unavailable" });
+          return;
+        }
+        settle5(
+          () => options.react(m.targetEventId, m.reaction, m.customEmojiHref, context),
+          send,
+          (error) => ({ type: "common.react.result", id, ok: false, error }),
+          (result) => ({ type: "common.react.result", id, ...result })
+        );
+        return;
+      }
+      if (message.type === "common.report") {
+        const m = message;
+        if (!options.report) {
+          send({ type: "common.report.result", id, ok: false, error: "report unavailable" });
+          return;
+        }
+        settle5(
+          () => options.report(m.target, m.reason, m.text, context),
+          send,
+          (error) => ({ type: "common.report.result", id, ok: false, error }),
+          (result) => ({ type: "common.report.result", id, ...result })
+        );
+        return;
+      }
+      send({
+        type: `${message.type}.error`,
+        id,
+        error: `Unknown common method: ${message.type}`
+      });
+    },
+    onWindowDestroyed(_windowId) {
+    }
+  };
+}
+function settleAction(action, pubkeys, context, send, resultType, id, unavailable) {
+  if (!action) {
+    send({ type: resultType, id, ok: false, error: unavailable });
+    return;
+  }
+  settle5(
+    () => action(pubkeys, context),
+    send,
+    (error) => ({ type: resultType, id, ok: false, error }),
+    (result) => ({ type: resultType, id, ...result })
+  );
+}
 
 // src/simulation.ts
 function summarizePajaSimulation(simulation) {
@@ -5233,8 +6569,185 @@ function summarizePajaSimulation(simulation) {
   return `${identity} ${relay} ${storage} ${theme} ${disabled}`;
 }
 
+// src/development-services.ts
+var DEV_LISTS_EVENT_ID = "3".repeat(64);
+var DEV_SERIAL_LABEL = "Paja serial";
+var DEV_BLE_DEVICE_NAME = "Paja BLE";
+var DEV_BLE_SERVICE_UUID = "battery_service";
+var DEV_BLE_CHARACTERISTIC_UUID = "battery_level";
+var DEV_WEBRTC_PEER = "6".repeat(64);
+var DEV_LISTS_SUPPORT = {
+  kind: 10003,
+  type: "bookmarks",
+  addressable: false,
+  supportedItemTypes: ["event", "url"]
+};
+function destroyWindowSessions2(sessions, windowId) {
+  for (const [sessionId, session] of sessions) {
+    if (session.windowId === windowId) sessions.delete(sessionId);
+  }
+}
+function createDevListStore() {
+  const values = /* @__PURE__ */ new Set();
+  const itemKey = (item) => `${item.itemType}:${item.value}`;
+  const isSupported = (list) => "type" in list && list.type === DEV_LISTS_SUPPORT.type || "kind" in list && list.kind === DEV_LISTS_SUPPORT.kind;
+  return {
+    supported: () => [DEV_LISTS_SUPPORT],
+    add(list, items) {
+      if (!isSupported(list)) return { ok: false, error: "unsupported-list", reason: "unsupported list", supported: [DEV_LISTS_SUPPORT] };
+      let added = 0;
+      let skipped = 0;
+      for (const item of items) {
+        const key = itemKey(item);
+        if (values.has(key)) skipped += 1;
+        else {
+          values.add(key);
+          added += 1;
+        }
+      }
+      return { ok: true, eventId: DEV_LISTS_EVENT_ID, added, skipped };
+    },
+    remove(list, items) {
+      if (!isSupported(list)) return { ok: false, error: "unsupported-list", reason: "unsupported list", supported: [DEV_LISTS_SUPPORT] };
+      let removed = 0;
+      let skipped = 0;
+      for (const item of items) {
+        if (values.delete(itemKey(item))) removed += 1;
+        else skipped += 1;
+      }
+      return { ok: true, eventId: DEV_LISTS_EVENT_ID, removed, skipped };
+    }
+  };
+}
+function createDevSerialController() {
+  const sessions = /* @__PURE__ */ new Map();
+  let nextSession = 1;
+  return {
+    open(_request, context) {
+      const id = `paja-serial-${nextSession++}`;
+      sessions.set(id, { windowId: context.windowId, writes: [] });
+      return {
+        session: {
+          id,
+          state: "open",
+          info: { displayName: DEV_SERIAL_LABEL }
+        }
+      };
+    },
+    write(sessionId, data) {
+      const session = sessions.get(sessionId);
+      if (!session) throw new Error("serial session not found");
+      session.writes.push([...data]);
+    },
+    close(sessionId) {
+      if (!sessions.delete(sessionId)) throw new Error("serial session not found");
+    },
+    destroyWindow(windowId) {
+      destroyWindowSessions2(sessions, windowId);
+    }
+  };
+}
+function createDevBleController() {
+  const sessions = /* @__PURE__ */ new Map();
+  let nextSession = 1;
+  const service = {
+    uuid: DEV_BLE_SERVICE_UUID,
+    characteristics: [{
+      uuid: DEV_BLE_CHARACTERISTIC_UUID,
+      properties: { read: true, write: true, notify: true }
+    }]
+  };
+  const targetKey = (target) => `${String(target.service)}:${String(target.characteristic)}:${String(target.descriptor ?? "")}`;
+  const getSession = (sessionId) => {
+    const session = sessions.get(sessionId);
+    if (!session) throw new Error("ble session not found");
+    return session;
+  };
+  return {
+    open(_request, context) {
+      const id = `paja-ble-${nextSession++}`;
+      sessions.set(id, { windowId: context.windowId, writes: [], subscriptions: /* @__PURE__ */ new Set() });
+      return {
+        session: {
+          id,
+          state: "open",
+          device: {
+            id: "paja-ble-device",
+            name: DEV_BLE_DEVICE_NAME,
+            services: [DEV_BLE_SERVICE_UUID]
+          }
+        }
+      };
+    },
+    services(sessionId) {
+      getSession(sessionId);
+      return [service];
+    },
+    read(sessionId, _target) {
+      getSession(sessionId);
+      return [87];
+    },
+    write(sessionId, _target, data, _options) {
+      getSession(sessionId).writes.push([...data]);
+    },
+    subscribe(sessionId, target) {
+      getSession(sessionId).subscriptions.add(targetKey(target));
+    },
+    unsubscribe(sessionId, target) {
+      getSession(sessionId).subscriptions.delete(targetKey(target));
+    },
+    close(sessionId) {
+      if (!sessions.delete(sessionId)) throw new Error("ble session not found");
+    },
+    destroyWindow(windowId) {
+      destroyWindowSessions2(sessions, windowId);
+    }
+  };
+}
+function createDevWebrtcController() {
+  const sessions = /* @__PURE__ */ new Map();
+  let nextSession = 1;
+  const getSession = (sessionId) => {
+    const session = sessions.get(sessionId);
+    if (!session) throw new Error("webrtc session not found");
+    return session;
+  };
+  return {
+    open(request, context) {
+      const id = `paja-webrtc-${nextSession++}`;
+      const channel = request.channel ?? "default";
+      sessions.set(id, { windowId: context.windowId, payloads: [] });
+      context.emit({ type: "state", sessionId: id, state: "open" });
+      context.emit({ type: "peer", sessionId: id, pubkey: DEV_WEBRTC_PEER, state: "joined" });
+      return {
+        session: {
+          id,
+          scope: request.scope,
+          channel,
+          ...request.protocol ? { protocol: request.protocol } : {},
+          state: "open"
+        }
+      };
+    },
+    send(sessionId, payload, context) {
+      getSession(sessionId).payloads.push(payload);
+      context.emit({ type: "message", sessionId, from: DEV_WEBRTC_PEER, payload });
+    },
+    close(sessionId, reason, context) {
+      getSession(sessionId);
+      sessions.delete(sessionId);
+      context.emit({ type: "closed", sessionId, ...reason ? { reason } : {} });
+    },
+    destroyWindow(windowId) {
+      destroyWindowSessions2(sessions, windowId);
+    }
+  };
+}
+
 // src/browser-host.ts
 var DEV_INTENT_ARCHETYPE = "paja-target";
+var DEV_COMMON_PUBKEY = "1".repeat(64);
+var DEV_COMMON_EVENT_ID = "2".repeat(64);
 var DEV_CVM_SERVER = {
   pubkey: "0".repeat(64),
   name: "Kehto Paja ContextVM",
@@ -5587,6 +7100,43 @@ function createDevServices(pool, getSimulation, onThemeService) {
       }
     });
   }
+  if (getSimulation().capabilities.domains.link) {
+    services.link = createLinkService({
+      open: ({ url }) => ({ status: url.protocol === "https:" || url.protocol === "http:" ? "opened" : "denied" })
+    });
+  }
+  if (getSimulation().capabilities.domains.common) {
+    services.common = createCommonService({
+      getProfile: (target) => ({
+        ok: true,
+        pubkey: target || getSimulation().identity.pubkey || DEV_COMMON_PUBKEY,
+        profile: { name: "paja", displayName: "Kehto Paja" },
+        relays: getRelayUrls(getSimulation())
+      }),
+      follows: () => ({ ok: true, pubkeys: [getSimulation().identity.pubkey || DEV_COMMON_PUBKEY] }),
+      follow: () => ({ ok: true, eventId: DEV_COMMON_EVENT_ID }),
+      unfollow: () => ({ ok: true, eventId: DEV_COMMON_EVENT_ID }),
+      react: () => ({ ok: true, eventId: DEV_COMMON_EVENT_ID }),
+      report: () => ({ ok: true, eventId: DEV_COMMON_EVENT_ID })
+    });
+  }
+  if (getSimulation().capabilities.domains.lists) {
+    const listStore = createDevListStore();
+    services.lists = createListsService({
+      supported: listStore.supported,
+      add: listStore.add,
+      remove: listStore.remove
+    });
+  }
+  if (getSimulation().capabilities.domains.serial) {
+    services.serial = createSerialService(createDevSerialController());
+  }
+  if (getSimulation().capabilities.domains.ble) {
+    services.ble = createBleService(createDevBleController());
+  }
+  if (getSimulation().capabilities.domains.webrtc) {
+    services.webrtc = createWebrtcService(createDevWebrtcController());
+  }
   return services;
 }
 function createPajaAdapter(config, getSimulation, onThemeService) {
@@ -5618,6 +7168,12 @@ function createPajaAdapter(config, getSimulation, onThemeService) {
     workerRelay: { getWorkerRelay: () => createWorkerRelay(workerRelayEvents) },
     upload: getSimulation().upload.mode === "memory" ? { getUploader: () => ({ rails: [getSimulation().upload.rail] }) } : void 0,
     intent: { isAvailable: () => getSimulation().intent.enabled },
+    link: { isAvailable: () => getSimulation().capabilities.domains.link },
+    common: { isAvailable: () => getSimulation().capabilities.domains.common },
+    lists: { isAvailable: () => getSimulation().capabilities.domains.lists },
+    serial: { isAvailable: () => getSimulation().capabilities.domains.serial },
+    ble: { isAvailable: () => getSimulation().capabilities.domains.ble },
+    webrtc: { isAvailable: () => getSimulation().capabilities.domains.webrtc },
     crypto: {
       verifyEvent: async () => true
     },
@@ -5639,11 +7195,7 @@ function registerFrameForGeneration(bridge, frame, config, generation) {
 }
 function navigateFrame(bridge, frame, config, generation) {
   const windowId = registerFrameForGeneration(bridge, frame, config, generation);
-  frame.src = "about:blank";
-  window.setTimeout(() => {
-    registerFrameForGeneration(bridge, frame, config, generation);
-    frame.src = config.target.url;
-  }, 0);
+  frame.src = config.target.url;
   return windowId;
 }
 function installPajaHost() {
@@ -5740,4 +7292,12 @@ try {
   if (statusEl) statusEl.textContent = "error";
   console.error(error);
 }
+/*! Bundled license information:
+
+@noble/hashes/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@scure/base/index.js:
+  (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
 //# sourceMappingURL=browser-host.js.map