@kehto/services 0.11.0 → 0.12.0

package/dist/index.js

@@ -231,6 +231,184 @@ function createNotificationService(options) {
 
 // src/identity-service.ts
 var IDENTITY_SERVICE_VERSION = "1.0.0";
+function sendProviderError(send, result, fallback, err) {
+  send({
+    ...result,
+    error: err?.message ?? fallback
+  });
+}
+async function getCurrentPubkey(options) {
+  const currentSigner = options.getSigner();
+  if (!currentSigner?.getPublicKey) return "";
+  try {
+    return await currentSigner.getPublicKey() ?? "";
+  } catch {
+    return "";
+  }
+}
+function sendOptionalProviderResult(options, send, fallbackResult, errorFallback, buildResult) {
+  if (!buildResult) {
+    send(fallbackResult);
+    return;
+  }
+  Promise.resolve(getCurrentPubkey(options)).then((pubkey) => buildResult(pubkey)).then((result) => send(result)).catch((err) => sendProviderError(send, fallbackResult, errorFallback, err));
+}
+function sendIdentityError(send, id, typeBase, error) {
+  send({ type: `${typeBase}.error`, id, error });
+}
+function sendSignerError(send, id, typeBase, fallback, err) {
+  sendIdentityError(send, id, typeBase, err?.message ?? fallback);
+}
+function handleGetPublicKey(options, id, send) {
+  const signer = options.getSigner();
+  if (!signer) {
+    const result = {
+      type: "identity.getPublicKey.result",
+      id,
+      pubkey: ""
+    };
+    send(result);
+    return;
+  }
+  Promise.resolve(signer.getPublicKey?.()).then((pubkey) => {
+    const result = {
+      type: "identity.getPublicKey.result",
+      id,
+      pubkey: pubkey ?? ""
+    };
+    send(result);
+  }).catch((err) => sendSignerError(send, id, "identity.getPublicKey", "getPublicKey failed", err));
+}
+function handleGetRelays(options, id, send) {
+  const signer = options.getSigner();
+  if (!signer) {
+    sendIdentityError(send, id, "identity.getRelays", "no signer configured");
+    return;
+  }
+  Promise.resolve(signer.getRelays?.() ?? {}).then((relays) => {
+    const result = {
+      type: "identity.getRelays.result",
+      id,
+      relays
+    };
+    send(result);
+  }).catch((err) => sendSignerError(send, id, "identity.getRelays", "getRelays failed", err));
+}
+function handleReadProvider(options, id, message, send) {
+  switch (message.type) {
+    case "identity.getProfile":
+      sendOptionalProviderResult(
+        options,
+        send,
+        { type: "identity.getProfile.result", id, profile: null },
+        "getProfile failed",
+        options.getProfile ? async (pubkey) => ({
+          type: "identity.getProfile.result",
+          id,
+          profile: await options.getProfile(pubkey, message)
+        }) : void 0
+      );
+      return true;
+    case "identity.getFollows":
+      sendOptionalProviderResult(
+        options,
+        send,
+        { type: "identity.getFollows.result", id, pubkeys: [] },
+        "getFollows failed",
+        options.getFollows ? async (pubkey) => ({
+          type: "identity.getFollows.result",
+          id,
+          pubkeys: await options.getFollows(pubkey, message)
+        }) : void 0
+      );
+      return true;
+    case "identity.getList":
+      handleGetList(options, id, message, send);
+      return true;
+    case "identity.getZaps":
+      sendOptionalProviderResult(
+        options,
+        send,
+        { type: "identity.getZaps.result", id, zaps: [] },
+        "getZaps failed",
+        options.getZaps ? async (pubkey) => ({
+          type: "identity.getZaps.result",
+          id,
+          zaps: await options.getZaps(pubkey, message)
+        }) : void 0
+      );
+      return true;
+    case "identity.getMutes":
+      sendOptionalProviderResult(
+        options,
+        send,
+        { type: "identity.getMutes.result", id, pubkeys: [] },
+        "getMutes failed",
+        options.getMutes ? async (pubkey) => ({
+          type: "identity.getMutes.result",
+          id,
+          pubkeys: await options.getMutes(pubkey, message)
+        }) : void 0
+      );
+      return true;
+    case "identity.getBlocked":
+      sendOptionalProviderResult(
+        options,
+        send,
+        { type: "identity.getBlocked.result", id, pubkeys: [] },
+        "getBlocked failed",
+        options.getBlocked ? async (pubkey) => ({
+          type: "identity.getBlocked.result",
+          id,
+          pubkeys: await options.getBlocked(pubkey, message)
+        }) : void 0
+      );
+      return true;
+    case "identity.getBadges":
+      sendOptionalProviderResult(
+        options,
+        send,
+        { type: "identity.getBadges.result", id, badges: [] },
+        "getBadges failed",
+        options.getBadges ? async (pubkey) => ({
+          type: "identity.getBadges.result",
+          id,
+          badges: await options.getBadges(pubkey, message)
+        }) : void 0
+      );
+      return true;
+    default:
+      return false;
+  }
+}
+function handleGetList(options, id, message, send) {
+  sendOptionalProviderResult(
+    options,
+    send,
+    { type: "identity.getList.result", id, entries: [] },
+    "getList failed",
+    options.getList ? async (pubkey) => ({
+      type: "identity.getList.result",
+      id,
+      entries: await options.getList(message.listType, pubkey, message)
+    }) : void 0
+  );
+}
+function handleIdentityServiceMessage(options, message, send) {
+  const id = message.id ?? "";
+  switch (message.type) {
+    case "identity.getPublicKey":
+      handleGetPublicKey(options, id, send);
+      return;
+    case "identity.getRelays":
+      handleGetRelays(options, id, send);
+      return;
+    default:
+      if (!handleReadProvider(options, id, message, send)) {
+        sendIdentityError(send, id, message.type, `Unknown identity method: ${message.type}`);
+      }
+  }
+}
 function createIdentityService(options) {
   return {
     descriptor: {
@@ -239,116 +417,7 @@ function createIdentityService(options) {
       description: "NIP-5D identity NAP reference handler (9 read-only identity queries)"
     },
     handleMessage(_windowId, message, send) {
-      const id = message.id ?? "";
-      function sendError(typeBase, error) {
-        send({ type: `${typeBase}.error`, id, error });
-      }
-      function sendSignerError(typeBase, fallback, err) {
-        sendError(typeBase, err?.message ?? fallback);
-      }
-      const signer = options.getSigner();
-      switch (message.type) {
-        case "identity.getPublicKey": {
-          if (!signer) {
-            const result = {
-              type: "identity.getPublicKey.result",
-              id,
-              pubkey: ""
-            };
-            send(result);
-            return;
-          }
-          Promise.resolve(signer.getPublicKey?.()).then((pubkey) => {
-            const result = {
-              type: "identity.getPublicKey.result",
-              id,
-              pubkey: pubkey ?? ""
-            };
-            send(result);
-          }).catch((err) => sendSignerError("identity.getPublicKey", "getPublicKey failed", err));
-          return;
-        }
-        case "identity.getRelays": {
-          if (!signer) {
-            sendError("identity.getRelays", "no signer configured");
-            return;
-          }
-          Promise.resolve(signer.getRelays?.() ?? {}).then((relays) => {
-            const result = {
-              type: "identity.getRelays.result",
-              id,
-              relays
-            };
-            send(result);
-          }).catch((err) => sendSignerError("identity.getRelays", "getRelays failed", err));
-          return;
-        }
-        case "identity.getProfile": {
-          const result = {
-            type: "identity.getProfile.result",
-            id,
-            profile: null
-          };
-          send(result);
-          return;
-        }
-        case "identity.getFollows": {
-          const result = {
-            type: "identity.getFollows.result",
-            id,
-            pubkeys: []
-          };
-          send(result);
-          return;
-        }
-        case "identity.getList": {
-          const result = {
-            type: "identity.getList.result",
-            id,
-            entries: []
-          };
-          send(result);
-          return;
-        }
-        case "identity.getZaps": {
-          const result = {
-            type: "identity.getZaps.result",
-            id,
-            zaps: []
-          };
-          send(result);
-          return;
-        }
-        case "identity.getMutes": {
-          const result = {
-            type: "identity.getMutes.result",
-            id,
-            pubkeys: []
-          };
-          send(result);
-          return;
-        }
-        case "identity.getBlocked": {
-          const result = {
-            type: "identity.getBlocked.result",
-            id,
-            pubkeys: []
-          };
-          send(result);
-          return;
-        }
-        case "identity.getBadges": {
-          const result = {
-            type: "identity.getBadges.result",
-            id,
-            badges: []
-          };
-          send(result);
-          return;
-        }
-        default:
-          sendError(message.type, `Unknown identity method: ${message.type}`);
-      }
+      handleIdentityServiceMessage(options, message, send);
     },
     // Identity service has no per-window state to clean up.
     onWindowDestroyed(_windowId) {
@@ -383,7 +452,8 @@ function createRelayPoolService(options) {
           send({ type: "relay.eose", subId });
           return;
         }
-        const relayUrls = options.selectRelayTier(filters);
+        const relayHint = typeof relayMessage.relay === "string" && relayMessage.relay.length > 0 ? relayMessage.relay : void 0;
+        const relayUrls = relayHint ? [relayHint] : options.selectRelayTier(filters);
         let eoseSent = false;
         const eoseTimer = setTimeout(() => {
           if (!eoseSent) {
@@ -563,7 +633,8 @@ function createCoordinatedRelay(options) {
               maybeSendEose(subKey, subId, send);
             }
           }, timeoutMs);
-          const relayUrls = options.relayPool.selectRelayTier(filters);
+          const relayHint = typeof relayMessage.relay === "string" && relayMessage.relay.length > 0 ? relayMessage.relay : void 0;
+          const relayUrls = relayHint ? [relayHint] : options.relayPool.selectRelayTier(filters);
           tracked.relayHandle = options.relayPool.subscribe(filters, (item) => {
             if (item === "EOSE") {
               clearTimeout(tracked.eoseTimer);
@@ -1579,19 +1650,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;
   }
 }
@@ -1602,45 +1689,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);
   }
@@ -1680,13 +1860,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:
@@ -2419,7 +2610,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());
@@ -2437,7 +2628,7 @@ function createIntentService(options) {
       send({ type: "intent.invoke.result", id, error: "invalid request" });
       return;
     }
-    settle(
+    settle6(
       () => resolver.invoke(request, { windowId }),
       send,
       "intent.invoke.result",
@@ -2453,7 +2644,7 @@ function createIntentService(options) {
       return;
     }
     const archetype = m.archetype;
-    settle(
+    settle6(
       () => resolver.available(archetype),
       send,
       "intent.available.result",
@@ -2464,7 +2655,7 @@ function createIntentService(options) {
   function handleHandlers(msg, send) {
     const m = msg;
     const id = m.id ?? "";
-    settle(
+    settle6(
       () => resolver.handlers(),
       send,
       "intent.handlers.result",
@@ -2739,11 +2930,736 @@ function toErrorMessage5(err) {
   if (typeof err === "string") return err;
   return "cvm request failed";
 }
+
+// src/link-service.ts
+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) {
+    }
+  };
+}
+
+// src/lists-service.ts
+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) {
+    }
+  };
+}
+
+// src/serial-service.ts
+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);
+    }
+  };
+}
+
+// src/ble-service.ts
+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);
+    }
+  };
+}
+
+// src/webrtc-service.ts
+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);
+    }
+  };
+}
+
+// src/common-service.ts
+import {
+  decode,
+  encodeBytes,
+  naddrEncode,
+  neventEncode,
+  noteEncode,
+  nprofileEncode,
+  npubEncode
+} from "nostr-tools/nip19";
+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 })
+  );
+}
 export {
   createAudioService,
+  createBleService,
   createBrowserMediaBridge,
   createCacheService,
   createCatalogIntentResolver,
+  createCommonService,
   createConfigService,
   createCoordinatedRelay,
   createCvmService,
@@ -2751,6 +3667,8 @@ export {
   createIdentityService,
   createIntentService,
   createKeysService,
+  createLinkService,
+  createListsService,
   createMediaService,
   createNotificationService,
   createNotifyService,
@@ -2758,8 +3676,10 @@ export {
   createRelayPoolOutboxRouter,
   createRelayPoolService,
   createResourceService,
+  createSerialService,
   createThemeService,
   createUploadService,
+  createWebrtcService,
   manifestToIntentCatalogEntry
 };
 //# sourceMappingURL=index.js.map