@kehto/services 0.2.0 → 0.5.0

package/dist/index.js

@@ -3,7 +3,7 @@ var AUDIO_SERVICE_VERSION = "1.0.0";
 function createAudioService(options) {
   const sources = /* @__PURE__ */ new Map();
   const onChange = options?.onChange;
-  function notify() {
+  function notify2() {
     onChange?.(new Map(sources));
   }
   const descriptor = {
@@ -15,21 +15,22 @@ function createAudioService(options) {
     descriptor,
     handleMessage(windowId, message, send) {
       if (message.type !== "ifc.emit") return;
-      const topic = message.topic;
+      const ifcMessage = message;
+      const topic = typeof ifcMessage.topic === "string" ? ifcMessage.topic : void 0;
       if (!topic?.startsWith("audio:")) return;
       const action = topic.slice(6);
-      const payload = message.payload ?? {};
+      const payload = ifcMessage.payload && typeof ifcMessage.payload === "object" ? ifcMessage.payload : {};
       switch (action) {
         case "register": {
           const nappletClass = typeof payload.nappletClass === "string" ? payload.nappletClass : "";
           const title = typeof payload.title === "string" ? payload.title : "";
           sources.set(windowId, { windowId, nappletClass, title, muted: false });
-          notify();
+          notify2();
           break;
         }
         case "unregister": {
           if (sources.delete(windowId)) {
-            notify();
+            notify2();
           }
           break;
         }
@@ -39,7 +40,7 @@ function createAudioService(options) {
           if (typeof payload.title === "string") {
             source.title = payload.title;
           }
-          notify();
+          notify2();
           break;
         }
         case "mute": {
@@ -48,7 +49,7 @@ function createAudioService(options) {
           const source = sources.get(targetWindowId);
           if (source) {
             source.muted = muted;
-            notify();
+            notify2();
           }
           send({ type: "ifc.event", topic: "napplet:audio-muted", payload: { muted } });
           break;
@@ -59,7 +60,7 @@ function createAudioService(options) {
     },
     onWindowDestroyed(windowId) {
       if (sources.delete(windowId)) {
-        notify();
+        notify2();
       }
     }
   };
@@ -73,42 +74,134 @@ function generateId() {
   idCounter++;
   return `notif-${Date.now()}-${idCounter}`;
 }
-function createNotificationService(options) {
-  const notifications = /* @__PURE__ */ new Map();
-  const onChange = options?.onChange;
-  const maxPerWindow = options?.maxPerWindow ?? DEFAULT_MAX_PER_WINDOW;
-  function getAllNotifications() {
-    const all = [];
-    for (const windowNotifs of notifications.values()) {
-      all.push(...windowNotifs);
-    }
-    return all;
+function getAllNotifications(store) {
+  const all = [];
+  for (const windowNotifs of store.notifications.values()) {
+    all.push(...windowNotifs);
   }
-  function notify() {
-    onChange?.(getAllNotifications());
+  return all;
+}
+function notify(store) {
+  store.onChange?.(getAllNotifications(store));
+}
+function getWindowNotifications(store, windowId) {
+  let list = store.notifications.get(windowId);
+  if (!list) {
+    list = [];
+    store.notifications.set(windowId, list);
+  }
+  return list;
+}
+function enforceLimit(store, list) {
+  while (list.length > store.maxPerWindow) {
+    list.shift();
   }
-  function getWindowNotifications(windowId) {
-    let list = notifications.get(windowId);
-    if (!list) {
-      list = [];
-      notifications.set(windowId, list);
+}
+function findById(store, id) {
+  for (const [windowId, list] of store.notifications) {
+    const index = list.findIndex((n) => n.id === id);
+    if (index !== -1) {
+      return [windowId, list[index], index];
     }
-    return list;
   }
-  function enforceLimit(list) {
-    while (list.length > maxPerWindow) {
-      list.shift();
+  return void 0;
+}
+function createNotification(store, windowId, title, body) {
+  const notification = {
+    id: generateId(),
+    windowId,
+    title,
+    body,
+    read: false,
+    createdAt: Math.floor(Date.now() / 1e3)
+  };
+  const list = getWindowNotifications(store, windowId);
+  list.push(notification);
+  enforceLimit(store, list);
+  notify(store);
+  return notification;
+}
+function dismissNotification(store, id) {
+  const found = findById(store, id);
+  if (!found) return;
+  const [foundWindowId, , index] = found;
+  const list = store.notifications.get(foundWindowId);
+  if (!list) return;
+  list.splice(index, 1);
+  if (list.length === 0) store.notifications.delete(foundWindowId);
+  notify(store);
+}
+function markNotificationRead(store, id) {
+  const found = findById(store, id);
+  if (!found) return;
+  const [, notification] = found;
+  if (!notification.read) {
+    notification.read = true;
+    notify(store);
+  }
+}
+function handleNotifyEnvelope(store, windowId, action, msg, send) {
+  switch (action) {
+    case "create": {
+      const title = typeof msg.title === "string" ? msg.title : "";
+      const body = typeof msg.body === "string" ? msg.body : "";
+      const notification = createNotification(store, windowId, title, body);
+      send({ type: "notify.created", id: notification.id });
+      break;
+    }
+    case "dismiss": {
+      const notifId = typeof msg.notificationId === "string" ? msg.notificationId : "";
+      if (notifId) dismissNotification(store, notifId);
+      break;
+    }
+    case "read": {
+      const notifId = typeof msg.notificationId === "string" ? msg.notificationId : "";
+      if (notifId) markNotificationRead(store, notifId);
+      break;
     }
+    case "list": {
+      const windowNotifs = store.notifications.get(windowId) ?? [];
+      send({ type: "notify.listed", notifications: windowNotifs });
+      break;
+    }
+    default:
+      break;
   }
-  function findById(id) {
-    for (const [windowId, list] of notifications) {
-      const index = list.findIndex((n) => n.id === id);
-      if (index !== -1) {
-        return [windowId, list[index], index];
-      }
+}
+function handleIfcNotification(store, windowId, action, payload, send) {
+  switch (action) {
+    case "create": {
+      const title = typeof payload.title === "string" ? payload.title : "";
+      const body = typeof payload.body === "string" ? payload.body : "";
+      const notification = createNotification(store, windowId, title, body);
+      send({ type: "ifc.event", topic: "notifications:created", payload: { id: notification.id } });
+      break;
     }
-    return void 0;
+    case "dismiss": {
+      const id = typeof payload.id === "string" ? payload.id : "";
+      if (id) dismissNotification(store, id);
+      break;
+    }
+    case "read": {
+      const id = typeof payload.id === "string" ? payload.id : "";
+      if (id) markNotificationRead(store, id);
+      break;
+    }
+    case "list": {
+      const windowNotifs = store.notifications.get(windowId) ?? [];
+      send({ type: "ifc.event", topic: "notifications:listed", payload: { notifications: windowNotifs } });
+      break;
+    }
+    default:
+      break;
   }
+}
+function createNotificationService(options) {
+  const store = {
+    notifications: /* @__PURE__ */ new Map(),
+    onChange: options?.onChange,
+    maxPerWindow: options?.maxPerWindow ?? DEFAULT_MAX_PER_WINDOW
+  };
   const descriptor = {
     name: "notifications",
     version: NOTIFICATION_SERVICE_VERSION,
@@ -119,132 +212,18 @@ function createNotificationService(options) {
     handleMessage(windowId, message, send) {
       const msg = message;
       if (message.type.startsWith("notify.")) {
-        const action2 = message.type.slice(7);
-        switch (action2) {
-          case "create": {
-            const title = typeof msg.title === "string" ? msg.title : "";
-            const body = typeof msg.body === "string" ? msg.body : "";
-            const id = generateId();
-            const notification = {
-              id,
-              windowId,
-              title,
-              body,
-              read: false,
-              createdAt: Math.floor(Date.now() / 1e3)
-            };
-            const list = getWindowNotifications(windowId);
-            list.push(notification);
-            enforceLimit(list);
-            notify();
-            send({ type: "notify.created", id });
-            break;
-          }
-          case "dismiss": {
-            const notifId = typeof msg.notificationId === "string" ? msg.notificationId : "";
-            if (!notifId) return;
-            const found = findById(notifId);
-            if (found) {
-              const [foundWindowId, , index] = found;
-              const list = notifications.get(foundWindowId);
-              if (list) {
-                list.splice(index, 1);
-                if (list.length === 0) notifications.delete(foundWindowId);
-                notify();
-              }
-            }
-            break;
-          }
-          case "read": {
-            const notifId = typeof msg.notificationId === "string" ? msg.notificationId : "";
-            if (!notifId) return;
-            const found = findById(notifId);
-            if (found) {
-              const [, notification] = found;
-              if (!notification.read) {
-                notification.read = true;
-                notify();
-              }
-            }
-            break;
-          }
-          case "list": {
-            const windowNotifs = notifications.get(windowId) ?? [];
-            send({ type: "notify.listed", notifications: windowNotifs });
-            break;
-          }
-          default:
-            break;
-        }
+        handleNotifyEnvelope(store, windowId, message.type.slice(7), msg, send);
         return;
       }
       if (message.type !== "ifc.emit") return;
       const topic = msg.topic;
       if (!topic?.startsWith("notifications:")) return;
-      const action = topic.slice(14);
       const payload = msg.payload ?? {};
-      switch (action) {
-        case "create": {
-          const title = typeof payload.title === "string" ? payload.title : "";
-          const body = typeof payload.body === "string" ? payload.body : "";
-          const id = generateId();
-          const notification = {
-            id,
-            windowId,
-            title,
-            body,
-            read: false,
-            createdAt: Math.floor(Date.now() / 1e3)
-          };
-          const list = getWindowNotifications(windowId);
-          list.push(notification);
-          enforceLimit(list);
-          notify();
-          send({ type: "ifc.event", topic: "notifications:created", payload: { id } });
-          break;
-        }
-        case "dismiss": {
-          const id = typeof payload.id === "string" ? payload.id : "";
-          if (!id) return;
-          const found = findById(id);
-          if (found) {
-            const [foundWindowId, , index] = found;
-            const list = notifications.get(foundWindowId);
-            if (list) {
-              list.splice(index, 1);
-              if (list.length === 0) {
-                notifications.delete(foundWindowId);
-              }
-              notify();
-            }
-          }
-          break;
-        }
-        case "read": {
-          const id = typeof payload.id === "string" ? payload.id : "";
-          if (!id) return;
-          const found = findById(id);
-          if (found) {
-            const [, notification] = found;
-            if (!notification.read) {
-              notification.read = true;
-              notify();
-            }
-          }
-          break;
-        }
-        case "list": {
-          const windowNotifs = notifications.get(windowId) ?? [];
-          send({ type: "ifc.event", topic: "notifications:listed", payload: { notifications: windowNotifs } });
-          break;
-        }
-        default:
-          break;
-      }
+      handleIfcNotification(store, windowId, topic.slice(14), payload, send);
     },
     onWindowDestroyed(windowId) {
-      if (notifications.delete(windowId)) {
-        notify();
+      if (store.notifications.delete(windowId)) {
+        notify(store);
       }
     }
   };
@@ -252,6 +231,156 @@ function createNotificationService(options) {
 
 // src/identity-service.ts
 var IDENTITY_SERVICE_VERSION = "1.0.0";
+var DECRYPT_ERROR_CODES = [
+  "class-forbidden",
+  "signer-denied",
+  "signer-unavailable",
+  "decrypt-failed",
+  "malformed-wrap",
+  "impersonation",
+  "unsupported-encryption",
+  "policy-denied"
+];
+var DECRYPT_ERROR_CODE_SET = new Set(DECRYPT_ERROR_CODES);
+function isDecryptErrorCode(value) {
+  return typeof value === "string" && DECRYPT_ERROR_CODE_SET.has(value);
+}
+function normalizeDecryptError(error) {
+  if (isDecryptErrorCode(error)) return error;
+  if (typeof error === "object" && error !== null) {
+    const candidate = error;
+    if (isDecryptErrorCode(candidate.code)) return candidate.code;
+    if (isDecryptErrorCode(candidate.error)) return candidate.error;
+    if (isDecryptErrorCode(candidate.message)) return candidate.message;
+  }
+  return "decrypt-failed";
+}
+function sendDecryptError(id, error, send) {
+  const result = {
+    type: "identity.decrypt.error",
+    id,
+    error
+  };
+  send(result);
+}
+function isStringArrayArray(value) {
+  return Array.isArray(value) && value.every(
+    (tag) => Array.isArray(tag) && tag.every((part) => typeof part === "string")
+  );
+}
+function isNostrEvent(value) {
+  const event = value;
+  return typeof event === "object" && event !== null && typeof event.id === "string" && typeof event.pubkey === "string" && typeof event.created_at === "number" && typeof event.kind === "number" && isStringArrayArray(event.tags) && typeof event.content === "string" && typeof event.sig === "string";
+}
+function isRumor(value) {
+  const rumor = value;
+  return typeof rumor === "object" && rumor !== null && typeof rumor.id === "string" && typeof rumor.pubkey === "string" && typeof rumor.created_at === "number" && typeof rumor.kind === "number" && isStringArrayArray(rumor.tags) && typeof rumor.content === "string";
+}
+function isGiftWrapDecryptResult(value) {
+  const result = value;
+  return typeof result === "object" && result !== null && isNostrEvent(result.seal) && isRumor(result.rumor);
+}
+function firstDecodedByte(content) {
+  const trimmed = content.trim();
+  if (trimmed.length === 0) return null;
+  const normalized = trimmed.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
+  try {
+    const decoded = atob(padded);
+    return decoded.length > 0 ? decoded.charCodeAt(0) : null;
+  } catch {
+    return null;
+  }
+}
+function detectEncryptionMode(event) {
+  if (event.kind === 4) return "nip04";
+  if (event.kind === 1059) return "nip17";
+  if (event.kind === 14 || firstDecodedByte(event.content) === 2) {
+    return "nip44-direct";
+  }
+  return null;
+}
+function rumorFromSignedEvent(event, content) {
+  return {
+    id: event.id,
+    pubkey: event.pubkey,
+    kind: event.kind,
+    tags: event.tags,
+    created_at: event.created_at,
+    content
+  };
+}
+async function handleDecrypt(id, message, send, options) {
+  const event = message.event;
+  if (!isNostrEvent(event)) {
+    sendDecryptError(id, "malformed-wrap", send);
+    return;
+  }
+  const verifyEvent = options.verifyEvent ?? (() => true);
+  let verified;
+  try {
+    verified = await Promise.resolve(verifyEvent(event));
+  } catch {
+    sendDecryptError(id, "malformed-wrap", send);
+    return;
+  }
+  if (!verified) {
+    sendDecryptError(id, "malformed-wrap", send);
+    return;
+  }
+  const mode = detectEncryptionMode(event);
+  if (!mode) {
+    sendDecryptError(id, "unsupported-encryption", send);
+    return;
+  }
+  const decryptor = options.getDecryptor?.() ?? null;
+  if (!decryptor) {
+    sendDecryptError(id, "signer-unavailable", send);
+    return;
+  }
+  try {
+    if (mode === "nip04") {
+      const plaintext = await decryptor.nip04Decrypt(event.pubkey, event.content);
+      const result2 = {
+        type: "identity.decrypt.result",
+        id,
+        rumor: rumorFromSignedEvent(event, plaintext),
+        sender: event.pubkey
+      };
+      send(result2);
+      return;
+    }
+    if (mode === "nip44-direct") {
+      const plaintext = await decryptor.nip44Decrypt(event.pubkey, event.content);
+      const result2 = {
+        type: "identity.decrypt.result",
+        id,
+        rumor: rumorFromSignedEvent(event, plaintext),
+        sender: event.pubkey
+      };
+      send(result2);
+      return;
+    }
+    const unwrapped = await decryptor.unwrapGiftWrap(event);
+    if (!isGiftWrapDecryptResult(unwrapped)) {
+      sendDecryptError(id, "malformed-wrap", send);
+      return;
+    }
+    if (unwrapped.seal.pubkey !== unwrapped.rumor.pubkey) {
+      sendDecryptError(id, "impersonation", send);
+      return;
+    }
+    const result = {
+      type: "identity.decrypt.result",
+      id,
+      rumor: unwrapped.rumor,
+      sender: unwrapped.seal.pubkey
+    };
+    send(result);
+  } catch (error) {
+    sendDecryptError(id, normalizeDecryptError(error), send);
+  }
+}
 function createIdentityService(options) {
   return {
     descriptor: {
@@ -264,6 +393,9 @@ function createIdentityService(options) {
       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": {
@@ -283,12 +415,7 @@ function createIdentityService(options) {
               pubkey: pubkey ?? ""
             };
             send(result);
-          }).catch((err) => {
-            sendError(
-              "identity.getPublicKey",
-              err?.message ?? "getPublicKey failed"
-            );
-          });
+          }).catch((err) => sendSignerError("identity.getPublicKey", "getPublicKey failed", err));
           return;
         }
         case "identity.getRelays": {
@@ -303,12 +430,7 @@ function createIdentityService(options) {
               relays
             };
             send(result);
-          }).catch((err) => {
-            sendError(
-              "identity.getRelays",
-              err?.message ?? "getRelays failed"
-            );
-          });
+          }).catch((err) => sendSignerError("identity.getRelays", "getRelays failed", err));
           return;
         }
         case "identity.getProfile": {
@@ -374,6 +496,10 @@ function createIdentityService(options) {
           send(result);
           return;
         }
+        case "identity.decrypt": {
+          void handleDecrypt(id, message, send, options);
+          return;
+        }
         default:
           sendError(message.type, `Unknown identity method: ${message.type}`);
       }
@@ -395,10 +521,11 @@ function createRelayPoolService(options) {
       description: "Relay pool subscription and publishing"
     },
     handleMessage(windowId, message, send) {
+      const relayMessage = message;
       if (message.type === "relay.subscribe") {
-        const subId = message.subId;
+        const subId = relayMessage.subId;
         if (typeof subId !== "string") return;
-        const filters = message.filters;
+        const filters = Array.isArray(relayMessage.filters) ? relayMessage.filters : [];
         const subKey = `${windowId}:${subId}`;
         const existing = tracked.get(subKey);
         if (existing) {
@@ -433,7 +560,7 @@ function createRelayPoolService(options) {
         return;
       }
       if (message.type === "relay.close") {
-        const subId = message.subId;
+        const subId = relayMessage.subId;
         if (typeof subId !== "string") return;
         const subKey = `${windowId}:${subId}`;
         const entry = tracked.get(subKey);
@@ -445,14 +572,14 @@ function createRelayPoolService(options) {
         return;
       }
       if (message.type === "relay.publish") {
-        const event = message.event;
+        const event = relayMessage.event;
         if (event && typeof event === "object" && options.isAvailable()) {
           options.publish(event);
         }
         return;
       }
       if (message.type === "relay.publishEncrypted") {
-        const event = message.event;
+        const event = relayMessage.event;
         if (event && typeof event === "object" && options.isAvailable()) {
           options.publish(event);
         }
@@ -481,10 +608,11 @@ function createCacheService(options) {
       description: "Local event cache (IndexedDB, worker relay, etc.)"
     },
     handleMessage(_windowId, message, send) {
+      const relayMessage = message;
       if (message.type === "relay.subscribe") {
-        const subId = message.subId;
+        const subId = relayMessage.subId;
         if (typeof subId !== "string") return;
-        const filters = message.filters;
+        const filters = Array.isArray(relayMessage.filters) ? relayMessage.filters : [];
         if (!options.isAvailable()) {
           send({ type: "relay.eose", subId });
           return;
@@ -500,7 +628,7 @@ function createCacheService(options) {
         return;
       }
       if (message.type === "relay.publish") {
-        const event = message.event;
+        const event = relayMessage.event;
         if (event && typeof event === "object" && options.isAvailable()) {
           try {
             options.store(event);
@@ -537,6 +665,7 @@ function createCoordinatedRelay(options) {
       description: "Coordinated relay pool + cache with dedup and unified EOSE"
     },
     handleMessage(windowId, message, send) {
+      const relayMessage = message;
       if (message.type === "relay.subscribe") {
         let deliver2 = function(event) {
           if (tracked.seenIds.has(event.id)) return;
@@ -544,9 +673,9 @@ function createCoordinatedRelay(options) {
           if (subs.has(subKey)) send({ type: "relay.event", subId, event });
         };
         var deliver = deliver2;
-        const subId = message.subId;
+        const subId = relayMessage.subId;
         if (typeof subId !== "string") return;
-        const filters = message.filters;
+        const filters = Array.isArray(relayMessage.filters) ? relayMessage.filters : [];
         const subKey = `${windowId}:${subId}`;
         const existing = subs.get(subKey);
         if (existing) {
@@ -608,7 +737,7 @@ function createCoordinatedRelay(options) {
         return;
       }
       if (message.type === "relay.close") {
-        const subId = message.subId;
+        const subId = relayMessage.subId;
         if (typeof subId !== "string") return;
         const subKey = `${windowId}:${subId}`;
         const entry = subs.get(subKey);
@@ -620,7 +749,7 @@ function createCoordinatedRelay(options) {
         return;
       }
       if (message.type === "relay.publish") {
-        const event = message.event;
+        const event = relayMessage.event;
         if (!event || typeof event !== "object") return;
         if (options.relayPool.isAvailable()) {
           options.relayPool.publish(event);
@@ -648,31 +777,266 @@ function createCoordinatedRelay(options) {
 }
 
 // src/keys-service.ts
-var KEYS_SERVICE_VERSION = "1.0.0";
+var KEYS_SERVICE_VERSION = "1.2.0";
+var MODIFIER_ALIASES = {
+  ctrl: "ctrl",
+  control: "ctrl",
+  alt: "alt",
+  option: "alt",
+  shift: "shift",
+  meta: "meta",
+  cmd: "meta",
+  command: "meta",
+  win: "meta",
+  super: "meta"
+};
+function parseChord(chord) {
+  if (chord.length === 0) throw new Error("empty chord");
+  const parts = chord.split("+");
+  const out = { ctrl: false, alt: false, shift: false, meta: false, key: "" };
+  for (let i = 0; i < parts.length - 1; i++) {
+    const tok = parts[i].trim().toLowerCase();
+    if (tok.length === 0) continue;
+    const slot = MODIFIER_ALIASES[tok];
+    if (!slot) throw new Error(`unknown modifier: ${parts[i]}`);
+    out[slot] = true;
+  }
+  const keyTok = parts[parts.length - 1].trim();
+  if (keyTok.length === 0) throw new Error(`empty key in chord: ${chord}`);
+  out.key = keyTok.length === 1 ? keyTok.toUpperCase() : keyTok;
+  return out;
+}
 function createKeysService(options = {}) {
   const descriptor = {
     name: "keys",
     version: KEYS_SERVICE_VERSION,
-    description: "NIP-5D keys NUB reference handler (stub)"
+    description: options.hostBridge ? "NIP-5D keys NUB reference handler (host-bridge delegated)" : "NIP-5D keys NUB reference handler (document-level chord listener)"
+  };
+  function chordSpecKey(spec) {
+    return `${spec.ctrl}|${spec.alt}|${spec.shift}|${spec.meta}|${spec.key}`;
+  }
+  const reservedChordKeys = /* @__PURE__ */ new Set();
+  if (options.reservedChords) {
+    for (const chordStr of options.reservedChords) {
+      reservedChordKeys.add(chordSpecKey(parseChord(chordStr)));
+    }
+  }
+  function forwardKey(m) {
+    const k = m.key.length === 1 ? m.key.toUpperCase() : m.key;
+    return `${m.ctrl}|${m.alt}|${m.shift}|${m.meta}|${k}`;
+  }
+  function forwardPayload(m) {
+    return {
+      key: m.key,
+      code: m.code,
+      ctrlKey: m.ctrl,
+      altKey: m.alt,
+      shiftKey: m.shift,
+      metaKey: m.meta
+    };
+  }
+  function eventKey(ev) {
+    const k = ev.key.length === 1 ? ev.key.toUpperCase() : ev.key;
+    return `${ev.ctrlKey}|${ev.altKey}|${ev.shiftKey}|${ev.metaKey}|${k}`;
+  }
+  if (options.hostBridge) {
+    const bridge = options.hostBridge;
+    const bridgeWindowActions = /* @__PURE__ */ new Map();
+    const unsubscribeHandles = /* @__PURE__ */ new Map();
+    return {
+      descriptor,
+      handleMessage(windowId, message, send) {
+        switch (message.type) {
+          case "keys.forward": {
+            const m = message;
+            const reserved = reservedChordKeys.has(forwardKey(m));
+            options.onForward?.(forwardPayload(m));
+            if (reserved) {
+              return;
+            }
+            return;
+          }
+          case "keys.registerAction": {
+            const m = message;
+            if (m.action.defaultKey) {
+              try {
+                const unsubscribe = bridge.subscribe(m.action.defaultKey, (ev) => {
+                  const e = ev;
+                  if ("repeat" in e && e.repeat) return;
+                  options.onForward?.({
+                    key: e.key,
+                    code: e.code,
+                    ctrlKey: e.ctrlKey,
+                    altKey: e.altKey,
+                    shiftKey: e.shiftKey,
+                    metaKey: e.metaKey
+                  });
+                  const payload = {
+                    type: "keys.action",
+                    actionId: m.action.id
+                  };
+                  send(payload);
+                });
+                unsubscribeHandles.set(m.action.id, unsubscribe);
+                if (!bridgeWindowActions.has(windowId)) bridgeWindowActions.set(windowId, /* @__PURE__ */ new Set());
+                bridgeWindowActions.get(windowId).add(m.action.id);
+              } catch (err) {
+                const id = m.id ?? "";
+                send({
+                  type: "keys.registerAction.error",
+                  id,
+                  error: `bridge subscribe failed: ${err.message}`
+                });
+                return;
+              }
+            }
+            const result = {
+              type: "keys.registerAction.result",
+              id: m.id,
+              actionId: m.action.id,
+              ...m.action.defaultKey ? { binding: m.action.defaultKey } : {}
+            };
+            send(result);
+            return;
+          }
+          case "keys.unregisterAction": {
+            const m = message;
+            if (m.actionId) {
+              const unsubscribe = unsubscribeHandles.get(m.actionId);
+              if (unsubscribe) {
+                try {
+                  unsubscribe();
+                } catch {
+                }
+                unsubscribeHandles.delete(m.actionId);
+                for (const [wid, set] of bridgeWindowActions.entries()) {
+                  if (set.delete(m.actionId) && set.size === 0) bridgeWindowActions.delete(wid);
+                }
+              }
+            }
+            return;
+          }
+          default: {
+            const id = message.id ?? "";
+            send({
+              type: `${message.type}.error`,
+              id,
+              error: `Unknown keys method: ${message.type}`
+            });
+            return;
+          }
+        }
+      },
+      onWindowDestroyed(windowId) {
+        const actions = bridgeWindowActions.get(windowId);
+        if (!actions) return;
+        for (const actionId of actions) {
+          const unsubscribe = unsubscribeHandles.get(actionId);
+          if (unsubscribe) {
+            try {
+              unsubscribe();
+            } catch {
+            }
+          }
+          unsubscribeHandles.delete(actionId);
+        }
+        bridgeWindowActions.delete(windowId);
+      },
+      destroy() {
+        for (const unsubscribe of unsubscribeHandles.values()) {
+          try {
+            unsubscribe();
+          } catch {
+          }
+        }
+        unsubscribeHandles.clear();
+        bridgeWindowActions.clear();
+      }
+    };
+  }
+  const actionRegistry = /* @__PURE__ */ new Map();
+  const windowActions = /* @__PURE__ */ new Map();
+  const sendHandles = /* @__PURE__ */ new Map();
+  const target = options.listenerTarget ?? (typeof document !== "undefined" ? document : new EventTarget());
+  function chordMatches(spec, ev) {
+    if (spec.ctrl !== ev.ctrlKey) return false;
+    if (spec.alt !== ev.altKey) return false;
+    if (spec.shift !== ev.shiftKey) return false;
+    if (spec.meta !== ev.metaKey) return false;
+    const evKey = ev.key.length === 1 ? ev.key.toUpperCase() : ev.key;
+    return spec.key === evKey;
+  }
+  const listener = (rawEv) => {
+    const ev = rawEv;
+    if (ev.repeat) return;
+    const isReserved = reservedChordKeys.has(eventKey(ev));
+    let anyMatch = false;
+    for (const entry of actionRegistry.values()) {
+      if (chordMatches(entry.chord, ev)) {
+        anyMatch = true;
+        break;
+      }
+    }
+    if (isReserved || anyMatch) {
+      options.onForward?.({
+        key: ev.key,
+        code: ev.code,
+        ctrlKey: ev.ctrlKey,
+        altKey: ev.altKey,
+        shiftKey: ev.shiftKey,
+        metaKey: ev.metaKey
+      });
+    }
+    if (isReserved) return;
+    for (const [actionId, entry] of actionRegistry.entries()) {
+      if (chordMatches(entry.chord, ev)) {
+        const send = sendHandles.get(entry.windowId);
+        if (send) {
+          const payload = {
+            type: "keys.action",
+            actionId,
+            chord: entry.chord
+          };
+          send(payload);
+        }
+      }
+    }
   };
+  target.addEventListener("keydown", listener);
   return {
     descriptor,
-    handleMessage(_windowId, message, send) {
+    handleMessage(windowId, message, send) {
       switch (message.type) {
         case "keys.forward": {
           const m = message;
-          options.onForward?.({
-            key: m.key,
-            code: m.code,
-            ctrlKey: m.ctrl,
-            altKey: m.alt,
-            shiftKey: m.shift,
-            metaKey: m.meta
-          });
+          const reserved = reservedChordKeys.has(forwardKey(m));
+          options.onForward?.(forwardPayload(m));
+          if (reserved) return;
           return;
         }
         case "keys.registerAction": {
           const m = message;
+          sendHandles.set(windowId, send);
+          if (m.action.defaultKey) {
+            try {
+              const chord = parseChord(m.action.defaultKey);
+              actionRegistry.set(m.action.id, {
+                chord,
+                chordString: m.action.defaultKey,
+                windowId
+              });
+              if (!windowActions.has(windowId)) windowActions.set(windowId, /* @__PURE__ */ new Set());
+              windowActions.get(windowId).add(m.action.id);
+            } catch (err) {
+              const id = m.id ?? "";
+              send({
+                type: "keys.registerAction.error",
+                id,
+                error: `invalid chord: ${err.message}`
+              });
+              return;
+            }
+          }
           const result = {
             type: "keys.registerAction.result",
             id: m.id,
@@ -683,6 +1047,19 @@ function createKeysService(options = {}) {
           return;
         }
         case "keys.unregisterAction": {
+          const m = message;
+          if (m.actionId && actionRegistry.has(m.actionId)) {
+            const entry = actionRegistry.get(m.actionId);
+            actionRegistry.delete(m.actionId);
+            const set = windowActions.get(entry.windowId);
+            if (set) {
+              set.delete(m.actionId);
+              if (set.size === 0) {
+                windowActions.delete(entry.windowId);
+                sendHandles.delete(entry.windowId);
+              }
+            }
+          }
           return;
         }
         default: {
@@ -696,66 +1073,382 @@ function createKeysService(options = {}) {
         }
       }
     },
-    onWindowDestroyed(_windowId) {
+    onWindowDestroyed(windowId) {
+      const actions = windowActions.get(windowId);
+      if (actions) {
+        for (const actionId of actions) actionRegistry.delete(actionId);
+        windowActions.delete(windowId);
+      }
+      sendHandles.delete(windowId);
+    },
+    destroy() {
+      target.removeEventListener("keydown", listener);
+      actionRegistry.clear();
+      windowActions.clear();
+      sendHandles.clear();
+    }
+  };
+}
+
+// src/browser-media-bridge.ts
+var SILENT_AUDIO_DATA_URL = "data:audio/wav;base64,UklGRiQAAABXQVZFZm10IBAAAAABAAEARKwAAIhYAQACABAAZGF0YQAAAAA=";
+var DEFAULT_MEDIA_ACTIONS = ["play", "pause", "next", "prev", "seek"];
+var ACTION_MATRIX = [
+  ["play", "play"],
+  ["pause", "pause"],
+  ["nexttrack", "next"],
+  ["previoustrack", "prev"],
+  ["seekto", "seek"]
+];
+function createBrowserMediaBridge(opts = {}) {
+  const ms = opts.mediaSessionTarget ?? (typeof navigator !== "undefined" && "mediaSession" in navigator ? navigator.mediaSession : null);
+  const doc = opts.documentTarget !== void 0 ? opts.documentTarget : typeof document !== "undefined" ? document : null;
+  let silentAudioEl = null;
+  let activeSessionId = null;
+  let sessionsActive = 0;
+  const actionCallbacks = /* @__PURE__ */ new Set();
+  function primeSilentAudio() {
+    if (silentAudioEl || !doc) return;
+    const el = doc.createElement("audio");
+    el.src = SILENT_AUDIO_DATA_URL;
+    el.loop = true;
+    el.style.display = "none";
+    el.setAttribute("data-kehto-silent-audio-prime", "true");
+    doc.body.appendChild(el);
+    void el.play().catch(() => {
+    });
+    silentAudioEl = el;
+  }
+  function teardownSilentAudio() {
+    if (!silentAudioEl) return;
+    try {
+      silentAudioEl.pause();
+    } catch {
+    }
+    try {
+      silentAudioEl.remove();
+    } catch {
+    }
+    silentAudioEl = null;
+  }
+  function applyActionHandlers(actions = DEFAULT_MEDIA_ACTIONS) {
+    if (!ms) return;
+    for (const [domAction, nubAction] of ACTION_MATRIX) {
+      if (!actions.includes(nubAction)) {
+        try {
+          ms.setActionHandler(domAction, null);
+        } catch {
+        }
+        continue;
+      }
+      ms.setActionHandler(domAction, (details) => {
+        if (!activeSessionId) return;
+        const value = nubAction === "seek" && typeof details?.seekTime === "number" ? details.seekTime : void 0;
+        for (const cb of actionCallbacks) {
+          cb(activeSessionId, nubAction, value);
+        }
+      });
+    }
+  }
+  function writeMetadata(metadata) {
+    if (!ms) return;
+    if (!metadata) {
+      ms.metadata = null;
+      return;
+    }
+    const artwork = metadata.artwork?.url ? [{ src: metadata.artwork.url }] : void 0;
+    const init = {
+      title: metadata.title ?? "",
+      artist: metadata.artist ?? "",
+      album: metadata.album ?? "",
+      ...artwork ? { artwork } : {}
+    };
+    try {
+      const ctor = globalThis.MediaMetadata;
+      ms.metadata = ctor ? new ctor(init) : init;
+    } catch {
+      ms.metadata = init;
+    }
+  }
+  return {
+    setMetadata(sessionId, metadata) {
+      if (sessionId === activeSessionId) writeMetadata(metadata);
+    },
+    setPlaybackState(sessionId, state) {
+      if (!ms || sessionId !== activeSessionId) return;
+      ms.playbackState = state === "playing" ? "playing" : state === "paused" || state === "buffering" ? "paused" : "none";
+    },
+    onAction(callback) {
+      actionCallbacks.add(callback);
+      return () => {
+        actionCallbacks.delete(callback);
+      };
+    },
+    setActiveSession(sessionId, actions) {
+      activeSessionId = sessionId;
+      if (!sessionId) {
+        if (ms) {
+          ms.metadata = null;
+          ms.playbackState = "none";
+          for (const [domAction] of ACTION_MATRIX) {
+            try {
+              ms.setActionHandler(domAction, null);
+            } catch {
+            }
+          }
+        }
+        return;
+      }
+      if (sessionsActive === 0) {
+        primeSilentAudio();
+        sessionsActive = 1;
+      }
+      applyActionHandlers(actions ?? DEFAULT_MEDIA_ACTIONS);
+    },
+    destroySession(_sessionId) {
+      sessionsActive = Math.max(0, sessionsActive - 1);
+      if (sessionsActive === 0) teardownSilentAudio();
     }
   };
 }
 
 // src/media-service.ts
-var MEDIA_SERVICE_VERSION = "1.0.0";
+var MEDIA_SERVICE_VERSION = "1.1.0";
+function createMediaServiceState(options, bridge) {
+  return {
+    bridge,
+    options,
+    sessionRegistry: /* @__PURE__ */ new Map(),
+    windowSessions: /* @__PURE__ */ new Map(),
+    sendHandles: /* @__PURE__ */ new Map(),
+    activeSessionId: null,
+    touchCounter: 0,
+    sessionCounter: 0
+  };
+}
+function setActive(state, sessionId, actions) {
+  state.activeSessionId = sessionId;
+  state.bridge.setActiveSession?.(sessionId, actions);
+  if (!sessionId) return;
+  const entry = state.sessionRegistry.get(sessionId);
+  if (!entry) return;
+  if (entry.metadata) state.bridge.setMetadata(sessionId, entry.metadata);
+  if (entry.state) state.bridge.setPlaybackState(sessionId, entry.state.status);
+}
+function promoteNextActiveOrClear(state) {
+  if (state.sessionRegistry.size === 0) {
+    setActive(state, null);
+    return;
+  }
+  let latest = null;
+  for (const entry of state.sessionRegistry.values()) {
+    if (!latest || entry.lastTouched > latest.lastTouched) latest = entry;
+  }
+  setActive(state, latest ? latest.sessionId : null, latest?.actions);
+}
+function sendMediaCommand(state, sessionId, action, value) {
+  const entry = state.sessionRegistry.get(sessionId);
+  if (!entry) return;
+  const send = state.sendHandles.get(entry.windowId);
+  if (!send) return;
+  const payload = {
+    type: "media.command",
+    sessionId,
+    action,
+    ...typeof value === "number" ? { value } : {}
+  };
+  send(payload);
+}
+function registerWindowSession(state, windowId, sessionId) {
+  if (!state.windowSessions.has(windowId)) state.windowSessions.set(windowId, /* @__PURE__ */ new Set());
+  state.windowSessions.get(windowId).add(sessionId);
+}
+function sendSessionCreateResult(send, id, fields) {
+  send({
+    type: "media.session.create.result",
+    id: id ?? "",
+    ...fields
+  });
+}
+function isMediaPlaybackOwner(value) {
+  return value === "shell" || value === "napplet";
+}
+function hasSourceRef(source) {
+  if (!source) return false;
+  if (typeof source.url === "string" && source.url.length > 0) return true;
+  if (typeof source.blossomHash === "string" && source.blossomHash.length > 0) return true;
+  if (source.nostr) {
+    return Boolean(source.nostr.eventId || source.nostr.address);
+  }
+  return false;
+}
+function canonicalizeSessionId(state, windowId, preferredSessionId) {
+  const trimmed = typeof preferredSessionId === "string" ? preferredSessionId.trim() : "";
+  const hint = trimmed || `session-${++state.sessionCounter}`;
+  if (!state.sessionRegistry.has(hint)) return hint;
+  let next;
+  do {
+    next = `${windowId}:${hint}:${++state.sessionCounter}`;
+  } while (state.sessionRegistry.has(next));
+  return next;
+}
+function handleSessionCreate(state, windowId, message, send) {
+  if (!isMediaPlaybackOwner(message.owner)) {
+    sendSessionCreateResult(send, message.id, { error: "missing owner" });
+    return;
+  }
+  if (message.owner === "shell") {
+    if (!hasSourceRef(message.source)) {
+      sendSessionCreateResult(send, message.id, { owner: "shell", error: "missing source" });
+      return;
+    }
+    sendSessionCreateResult(send, message.id, { owner: "shell", error: "unsupported owner mode" });
+    return;
+  }
+  state.sendHandles.set(windowId, send);
+  const sessionId = canonicalizeSessionId(state, windowId, message.sessionId);
+  const entry = {
+    sessionId,
+    windowId,
+    owner: message.owner,
+    source: message.source,
+    metadata: message.metadata,
+    state: void 0,
+    actions: message.capabilities ?? DEFAULT_MEDIA_ACTIONS,
+    lastTouched: ++state.touchCounter
+  };
+  state.sessionRegistry.set(sessionId, entry);
+  registerWindowSession(state, windowId, sessionId);
+  setActive(state, sessionId, entry.actions);
+  state.options.onSessionCreate?.(windowId, sessionId, message.metadata);
+  sendSessionCreateResult(send, message.id, { sessionId, owner: message.owner });
+}
+function handleSessionUpdate(state, windowId, message) {
+  const entry = state.sessionRegistry.get(message.sessionId);
+  if (entry) {
+    entry.metadata = { ...entry.metadata, ...message.metadata };
+    entry.lastTouched = ++state.touchCounter;
+    if (entry.owner === "napplet" && message.sessionId === state.activeSessionId && entry.metadata) {
+      state.bridge.setMetadata(message.sessionId, entry.metadata);
+    }
+  }
+  state.options.onSessionUpdate?.(windowId, message.sessionId, message.metadata);
+}
+function handleSessionDestroy(state, windowId, message) {
+  const entry = state.sessionRegistry.get(message.sessionId);
+  if (entry) {
+    state.sessionRegistry.delete(message.sessionId);
+    const set = state.windowSessions.get(entry.windowId);
+    if (set) {
+      set.delete(message.sessionId);
+      if (set.size === 0) state.windowSessions.delete(entry.windowId);
+    }
+    state.bridge.destroySession?.(message.sessionId);
+    if (message.sessionId === state.activeSessionId) promoteNextActiveOrClear(state);
+  }
+  state.options.onSessionDestroy?.(windowId, message.sessionId);
+}
+function handleMediaState(state, windowId, message) {
+  const entry = state.sessionRegistry.get(message.sessionId);
+  if (entry?.owner === "napplet") {
+    entry.state = {
+      status: message.status,
+      position: message.position,
+      duration: message.duration,
+      volume: message.volume
+    };
+    entry.lastTouched = ++state.touchCounter;
+    if (state.activeSessionId !== message.sessionId) setActive(state, message.sessionId, entry.actions);
+    else state.bridge.setPlaybackState(message.sessionId, message.status);
+  }
+  state.options.onState?.(windowId, message.sessionId, message);
+}
+function handleMediaCapabilities(state, windowId, message) {
+  const entry = state.sessionRegistry.get(message.sessionId);
+  if (entry?.owner === "napplet") {
+    entry.actions = message.actions;
+    entry.lastTouched = ++state.touchCounter;
+    if (message.sessionId === state.activeSessionId) {
+      state.bridge.setActiveSession?.(message.sessionId, entry.actions);
+    }
+  }
+  state.options.onCapabilities?.(windowId, message.sessionId, message.actions);
+}
+function handleMediaMessage(state, windowId, message, send) {
+  switch (message.type) {
+    case "media.session.create":
+      handleSessionCreate(state, windowId, message, send);
+      return;
+    case "media.session.update":
+      handleSessionUpdate(state, windowId, message);
+      return;
+    case "media.session.destroy":
+      handleSessionDestroy(state, windowId, message);
+      return;
+    case "media.state":
+      handleMediaState(state, windowId, message);
+      return;
+    case "media.capabilities":
+      handleMediaCapabilities(state, windowId, message);
+      return;
+    default: {
+      const id = message.id ?? "";
+      send({
+        type: `${message.type}.error`,
+        id,
+        error: `Unknown media method: ${message.type}`
+      });
+    }
+  }
+}
+function destroyWindowSessions(state, windowId) {
+  const sessions = state.windowSessions.get(windowId);
+  if (sessions) {
+    const ownedActive = state.activeSessionId !== null && sessions.has(state.activeSessionId);
+    for (const sessionId of sessions) {
+      state.sessionRegistry.delete(sessionId);
+      state.bridge.destroySession?.(sessionId);
+    }
+    state.windowSessions.delete(windowId);
+    if (ownedActive) promoteNextActiveOrClear(state);
+  }
+  state.sendHandles.delete(windowId);
+}
+function destroyMediaState(state, unsubscribeAction) {
+  unsubscribeAction();
+  for (const sessionId of state.sessionRegistry.keys()) state.bridge.destroySession?.(sessionId);
+  state.bridge.setActiveSession?.(null);
+  state.sessionRegistry.clear();
+  state.windowSessions.clear();
+  state.sendHandles.clear();
+  state.activeSessionId = null;
+  state.touchCounter = 0;
+  state.sessionCounter = 0;
+}
 function createMediaService(options = {}) {
   const descriptor = {
     name: "media",
     version: MEDIA_SERVICE_VERSION,
-    description: "NIP-5D media NUB reference handler (stub)"
+    description: options.hostBridge ? "NIP-5D media NUB reference handler (host-bridge delegated)" : "NIP-5D media NUB reference handler (navigator.mediaSession mirror)"
   };
+  const bridge = options.hostBridge ?? createBrowserMediaBridge({
+    mediaSessionTarget: options.mediaSessionTarget,
+    documentTarget: options.documentTarget
+  });
+  const state = createMediaServiceState(options, bridge);
+  const unsubscribeAction = bridge.onAction((sessionId, action, value) => {
+    sendMediaCommand(state, sessionId, action, value);
+  });
   return {
     descriptor,
     handleMessage(windowId, message, send) {
-      switch (message.type) {
-        case "media.session.create": {
-          const m = message;
-          options.onSessionCreate?.(windowId, m.sessionId, m.metadata);
-          const result = {
-            type: "media.session.create.result",
-            id: m.id,
-            sessionId: m.sessionId
-          };
-          send(result);
-          return;
-        }
-        case "media.session.update": {
-          const m = message;
-          options.onSessionUpdate?.(windowId, m.sessionId ?? "", m.metadata);
-          return;
-        }
-        case "media.session.destroy": {
-          const m = message;
-          options.onSessionDestroy?.(windowId, m.sessionId ?? "");
-          return;
-        }
-        case "media.state": {
-          const m = message;
-          options.onState?.(windowId, m.sessionId ?? "", m);
-          return;
-        }
-        case "media.capabilities": {
-          const m = message;
-          options.onCapabilities?.(windowId, m.sessionId ?? "", m.actions);
-          return;
-        }
-        default: {
-          const id = message.id ?? "";
-          send({
-            type: `${message.type}.error`,
-            id,
-            error: `Unknown media method: ${message.type}`
-          });
-          return;
-        }
-      }
+      handleMediaMessage(state, windowId, message, send);
     },
-    onWindowDestroyed(_windowId) {
+    onWindowDestroyed(windowId) {
+      destroyWindowSessions(state, windowId);
+    },
+    destroy() {
+      destroyMediaState(state, unsubscribeAction);
     }
   };
 }
@@ -827,7 +1520,7 @@ var DEFAULT_THEME = {
     primary: "#7aa2f7"
   }
   // fonts, background, title intentionally undefined — all optional per
-  // @napplet/nub-theme Theme interface.
+  // @napplet/nub/theme Theme interface.
 };
 function createThemeService(options = {}) {
   let currentTheme = options.initialTheme ?? DEFAULT_THEME;
@@ -870,16 +1563,416 @@ function createThemeService(options = {}) {
   }
   return { handler, publishTheme, getCurrentTheme };
 }
+
+// src/config-service.ts
+var CONFIG_SERVICE_VERSION = "1.0.0";
+function validateCoreSubset(schema) {
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
+    return { ok: false, code: "invalid-schema", error: "schema root must be an object" };
+  }
+  const s = schema;
+  if ("$ref" in s) {
+    return { ok: false, code: "ref-not-allowed", error: "$ref is not permitted in the Core Subset" };
+  }
+  if ("pattern" in s) {
+    return {
+      ok: false,
+      code: "pattern-not-allowed",
+      error: "pattern is not permitted in the Core Subset"
+    };
+  }
+  if ("oneOf" in s || "anyOf" in s || "allOf" in s || "not" in s) {
+    return {
+      ok: false,
+      code: "invalid-schema",
+      error: "oneOf/anyOf/allOf/not are not permitted in the Core Subset"
+    };
+  }
+  if ("if" in s || "then" in s || "else" in s) {
+    return {
+      ok: false,
+      code: "invalid-schema",
+      error: "if/then/else are not permitted in the Core Subset"
+    };
+  }
+  if (s.type !== "object") {
+    return { ok: false, code: "invalid-schema", error: 'schema root must have type: "object"' };
+  }
+  const props = s.properties;
+  if (props !== void 0 && (typeof props !== "object" || props === null)) {
+    return { ok: false, code: "invalid-schema", error: "properties must be an object" };
+  }
+  if (props) {
+    for (const [key, val] of Object.entries(props)) {
+      if (typeof val !== "object" || val === null) {
+        return {
+          ok: false,
+          code: "invalid-schema",
+          error: `property "${key}" must be an object schema`
+        };
+      }
+      const pv = val;
+      const ALLOWED_TYPES = /* @__PURE__ */ new Set(["string", "number", "boolean", "array", "object"]);
+      if (pv.type !== void 0 && !ALLOWED_TYPES.has(pv.type)) {
+        return {
+          ok: false,
+          code: "invalid-schema",
+          error: `property "${key}" must have type: string|number|boolean|array|object`
+        };
+      }
+    }
+  }
+  return { ok: true };
+}
+function createConfigService(options) {
+  const subscribers = /* @__PURE__ */ new Map();
+  const descriptor = {
+    name: "config",
+    version: CONFIG_SERVICE_VERSION,
+    description: "NUB-CONFIG reference service \u2014 shell-writes, napplet-reads configuration"
+  };
+  const handler = {
+    descriptor,
+    handleMessage(windowId, message, send) {
+      switch (message.type) {
+        case "config.get": {
+          const m = message;
+          const reply = {
+            type: "config.values",
+            id: m.id,
+            values: options.getValues()
+          };
+          send(reply);
+          return;
+        }
+        case "config.subscribe": {
+          subscribers.set(windowId, send);
+          const push = {
+            type: "config.values",
+            values: options.getValues()
+          };
+          send(push);
+          options.onSubscribe?.(windowId);
+          return;
+        }
+        case "config.unsubscribe": {
+          subscribers.delete(windowId);
+          options.onUnsubscribe?.(windowId);
+          return;
+        }
+        case "config.registerSchema": {
+          const m = message;
+          const validation = options.registerSchema ? options.registerSchema(windowId, m.schema, m.version) : validateCoreSubset(m.schema);
+          const result = validation.ok ? { type: "config.registerSchema.result", id: m.id, ok: true } : {
+            type: "config.registerSchema.result",
+            id: m.id,
+            ok: false,
+            code: validation.code,
+            error: validation.error
+          };
+          send(result);
+          return;
+        }
+        case "config.openSettings": {
+          const m = message;
+          options.openSettings?.(windowId, m.section);
+          return;
+        }
+        default:
+          return;
+      }
+    },
+    onWindowDestroyed(windowId) {
+      subscribers.delete(windowId);
+    }
+  };
+  function publishValues(values) {
+    const envelope = {
+      type: "config.values",
+      values
+    };
+    for (const send of subscribers.values()) {
+      try {
+        send(envelope);
+      } catch {
+      }
+    }
+  }
+  return { handler, publishValues };
+}
+
+// src/resource-service.ts
+var RESOURCE_SERVICE_VERSION = "1.0.0";
+function arrayBufferToBase64(buf) {
+  const bytes = new Uint8Array(buf);
+  const CHUNK = 32768;
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+  }
+  return btoa(binary);
+}
+function assertResourceOptions(options) {
+  if (typeof options?.fetch !== "function" || typeof options?.isOriginGranted !== "function" || typeof options?.getConnectGrants !== "function" || typeof options?.resolveIdentity !== "function") {
+    throw new Error(
+      "[RESOURCE-01 / H-03] createResourceService requires {fetch, isOriginGranted, getConnectGrants, resolveIdentity} \u2014 all four options are required from day one. The grants source (getConnectGrants) MUST be wired at construction time to prevent unguarded fetch proxying."
+    );
+  }
+}
+function trackRequest(state, requestId, windowId, controller) {
+  state.inFlight.set(requestId, { controller, windowId });
+  if (!state.perWindow.has(windowId)) {
+    state.perWindow.set(windowId, /* @__PURE__ */ new Set());
+  }
+  state.perWindow.get(windowId).add(requestId);
+}
+function untrackRequest(state, requestId) {
+  const entry = state.inFlight.get(requestId);
+  if (entry) {
+    state.inFlight.delete(requestId);
+    state.perWindow.get(entry.windowId)?.delete(requestId);
+  }
+}
+function sendResourceError(send, requestId, code, message) {
+  send({
+    type: "resource.bytes.error",
+    requestId,
+    code,
+    message
+  });
+}
+function parseResourceUrl(send, requestId, url) {
+  try {
+    return new URL(url);
+  } catch {
+    sendResourceError(send, requestId, "invalid-url", `invalid URL: ${url}`);
+    return null;
+  }
+}
+function collectResponseHeaders(response) {
+  const headers = {};
+  response.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  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;
+  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;
+  }
+  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
+    });
+    const buffer = await response.arrayBuffer();
+    send({
+      type: "resource.bytes.result",
+      requestId,
+      status: response.status,
+      headers: collectResponseHeaders(response),
+      bodyBase64: arrayBufferToBase64(buffer)
+    });
+  } catch (err) {
+    const isAbort = controller.signal.aborted || err instanceof Error && (err.name === "AbortError" || err.name === "DOMException");
+    sendResourceError(
+      send,
+      requestId,
+      isAbort ? "canceled" : "network-error",
+      err instanceof Error ? err.message : String(err)
+    );
+  } finally {
+    untrackRequest(state, requestId);
+  }
+}
+function handleCancel(state, requestId) {
+  const entry = state.inFlight.get(requestId);
+  if (entry) {
+    entry.controller.abort();
+  }
+}
+function destroyWindowRequests(state, windowId) {
+  const requestIds = state.perWindow.get(windowId);
+  if (!requestIds) return;
+  for (const requestId of requestIds) {
+    const entry = state.inFlight.get(requestId);
+    if (entry) {
+      entry.controller.abort();
+      state.inFlight.delete(requestId);
+    }
+  }
+  state.perWindow.delete(windowId);
+}
+function createResourceService(options) {
+  assertResourceOptions(options);
+  const state = {
+    inFlight: /* @__PURE__ */ new Map(),
+    perWindow: /* @__PURE__ */ new Map()
+  };
+  const descriptor = {
+    name: "resource",
+    version: RESOURCE_SERVICE_VERSION,
+    description: "NUB-RESOURCE reference service \u2014 shell-proxied authenticated fetch (RESOURCE-01..06)"
+  };
+  const handler = {
+    descriptor,
+    handleMessage(windowId, message, send) {
+      switch (message.type) {
+        case "resource.bytes": {
+          const m = message;
+          handleBytes(options, state, windowId, m, send).catch(() => {
+          });
+          return;
+        }
+        case "resource.cancel": {
+          const m = message;
+          handleCancel(state, m.requestId);
+          return;
+        }
+        default:
+          return;
+      }
+    },
+    onWindowDestroyed(windowId) {
+      destroyWindowRequests(state, windowId);
+    }
+  };
+  return handler;
+}
+
+// src/cvm-service.ts
+var CVM_SERVICE_VERSION = "1.0.0";
+var CVM_DESCRIPTOR = {
+  name: "cvm",
+  version: CVM_SERVICE_VERSION,
+  description: "NAP-CVM ContextVM bridge \u2014 MCP over Nostr"
+};
+function createCvmService(options) {
+  if (!options || typeof options.transport !== "object" || options.transport === null) {
+    throw new Error("createCvmService: options.transport is required");
+  }
+  const { transport } = options;
+  const sendByWindow = /* @__PURE__ */ new Map();
+  const windowsByServer = /* @__PURE__ */ new Map();
+  function openSession(windowId, server, send) {
+    sendByWindow.set(windowId, send);
+    let windows = windowsByServer.get(server.pubkey);
+    if (!windows) {
+      windows = /* @__PURE__ */ new Set();
+      windowsByServer.set(server.pubkey, windows);
+    }
+    windows.add(windowId);
+  }
+  function closeSession(windowId, serverPubkey) {
+    const windows = windowsByServer.get(serverPubkey);
+    if (windows) {
+      windows.delete(windowId);
+      if (windows.size === 0) windowsByServer.delete(serverPubkey);
+    }
+  }
+  const eventSub = transport.onEvent((server, message) => {
+    const windows = windowsByServer.get(server.pubkey);
+    if (!windows) return;
+    for (const windowId of windows) {
+      const send = sendByWindow.get(windowId);
+      send?.({ type: "cvm.event", server, message });
+    }
+  });
+  function handleDiscover(msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    void transport.discover(m.query).then((servers) => send({ type: "cvm.discover.result", id, servers })).catch(
+      (err) => send({ type: "cvm.discover.result", id, servers: [], error: toErrorMessage(err) })
+    );
+  }
+  function handleRequest(windowId, msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    if (!m.server || typeof m.server.pubkey !== "string" || m.server.pubkey.length === 0) {
+      send({ type: "cvm.request.result", id, error: "server not found" });
+      return;
+    }
+    if (!m.message || typeof m.message !== "object") {
+      send({ type: "cvm.request.result", id, error: "unsupported method" });
+      return;
+    }
+    openSession(windowId, m.server, send);
+    void transport.request(m.server, m.message, m.options).then((message) => send({ type: "cvm.request.result", id, message })).catch(
+      (err) => send({ type: "cvm.request.result", id, error: toErrorMessage(err) })
+    );
+  }
+  function handleClose(windowId, msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    if (!m.server || typeof m.server.pubkey !== "string") {
+      send({ type: "cvm.close.result", id, error: "server not found" });
+      return;
+    }
+    closeSession(windowId, m.server.pubkey);
+    void transport.close(m.server).then(() => send({ type: "cvm.close.result", id })).catch((err) => send({ type: "cvm.close.result", id, error: toErrorMessage(err) }));
+  }
+  return {
+    descriptor: CVM_DESCRIPTOR,
+    handleMessage(windowId, message, send) {
+      switch (message.type) {
+        case "cvm.discover":
+          handleDiscover(message, send);
+          return;
+        case "cvm.request":
+          handleRequest(windowId, message, send);
+          return;
+        case "cvm.close":
+          handleClose(windowId, message, send);
+          return;
+        default:
+          return;
+      }
+    },
+    onWindowDestroyed(windowId) {
+      sendByWindow.delete(windowId);
+      for (const [pubkey, windows] of windowsByServer) {
+        windows.delete(windowId);
+        if (windows.size === 0) windowsByServer.delete(pubkey);
+      }
+    },
+    dispose() {
+      eventSub.close();
+    }
+  };
+}
+function toErrorMessage(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return "cvm request failed";
+}
 export {
   createAudioService,
+  createBrowserMediaBridge,
   createCacheService,
+  createConfigService,
   createCoordinatedRelay,
+  createCvmService,
   createIdentityService,
   createKeysService,
   createMediaService,
   createNotificationService,
   createNotifyService,
   createRelayPoolService,
+  createResourceService,
   createThemeService
 };
 //# sourceMappingURL=index.js.map