@kehto/services 0.16.5 → 0.18.0

package/dist/index.js

@@ -1,71 +1,3 @@
-// src/audio-service.ts
-var AUDIO_SERVICE_VERSION = "1.0.0";
-function createAudioService(options) {
-  const sources = /* @__PURE__ */ new Map();
-  const onChange = options?.onChange;
-  function notify2() {
-    onChange?.(new Map(sources));
-  }
-  const descriptor = {
-    name: "audio",
-    version: AUDIO_SERVICE_VERSION,
-    description: "Audio source registry \u2014 tracks active audio sources per napplet window"
-  };
-  return {
-    descriptor,
-    handleMessage(windowId, message, send) {
-      if (message.type !== "inc.emit") return;
-      const incMessage = message;
-      const topic = typeof incMessage.topic === "string" ? incMessage.topic : void 0;
-      if (!topic?.startsWith("audio:")) return;
-      const action = topic.slice(6);
-      const payload = incMessage.payload && typeof incMessage.payload === "object" ? incMessage.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 });
-          notify2();
-          break;
-        }
-        case "unregister": {
-          if (sources.delete(windowId)) {
-            notify2();
-          }
-          break;
-        }
-        case "state-changed": {
-          const source = sources.get(windowId);
-          if (!source) return;
-          if (typeof payload.title === "string") {
-            source.title = payload.title;
-          }
-          notify2();
-          break;
-        }
-        case "mute": {
-          const targetWindowId = typeof payload.windowId === "string" ? payload.windowId : windowId;
-          const muted = payload.muted === true;
-          const source = sources.get(targetWindowId);
-          if (source) {
-            source.muted = muted;
-            notify2();
-          }
-          send({ type: "inc.event", topic: "napplet:audio-muted", payload: { muted } });
-          break;
-        }
-        default:
-          break;
-      }
-    },
-    onWindowDestroyed(windowId) {
-      if (sources.delete(windowId)) {
-        notify2();
-      }
-    }
-  };
-}
-
 // src/notification-service.ts
 var NOTIFICATION_SERVICE_VERSION = "1.0.0";
 var DEFAULT_MAX_PER_WINDOW = 100;
@@ -97,14 +29,11 @@ function enforceLimit(store, list) {
     list.shift();
   }
 }
-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 void 0;
+function findById(store, windowId, id) {
+  const list = store.notifications.get(windowId);
+  const index = list?.findIndex((notification) => notification.id === id) ?? -1;
+  if (!list || index === -1) return void 0;
+  return [list[index], index];
 }
 function createNotification(store, windowId, title, body) {
   const notification = {
@@ -121,20 +50,20 @@ function createNotification(store, windowId, title, body) {
   notify(store);
   return notification;
 }
-function dismissNotification(store, id) {
-  const found = findById(store, id);
+function dismissNotification(store, windowId, id) {
+  const found = findById(store, windowId, id);
   if (!found) return;
-  const [foundWindowId, , index] = found;
-  const list = store.notifications.get(foundWindowId);
+  const [, index] = found;
+  const list = store.notifications.get(windowId);
   if (!list) return;
   list.splice(index, 1);
-  if (list.length === 0) store.notifications.delete(foundWindowId);
+  if (list.length === 0) store.notifications.delete(windowId);
   notify(store);
 }
-function markNotificationRead(store, id) {
-  const found = findById(store, id);
+function markNotificationRead(store, windowId, id) {
+  const found = findById(store, windowId, id);
   if (!found) return;
-  const [, notification] = found;
+  const [notification] = found;
   if (!notification.read) {
     notification.read = true;
     notify(store);
@@ -151,12 +80,12 @@ function handleNotifyEnvelope(store, windowId, action, msg, send) {
     }
     case "dismiss": {
       const notifId = typeof msg.notificationId === "string" ? msg.notificationId : "";
-      if (notifId) dismissNotification(store, notifId);
+      if (notifId) dismissNotification(store, windowId, notifId);
       break;
     }
     case "read": {
       const notifId = typeof msg.notificationId === "string" ? msg.notificationId : "";
-      if (notifId) markNotificationRead(store, notifId);
+      if (notifId) markNotificationRead(store, windowId, notifId);
       break;
     }
     case "list": {
@@ -168,34 +97,6 @@ function handleNotifyEnvelope(store, windowId, action, msg, send) {
       break;
   }
 }
-function handleIncNotification(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: "inc.event", topic: "notifications:created", payload: { id: notification.id } });
-      break;
-    }
-    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: "inc.event", topic: "notifications:listed", payload: { notifications: windowNotifs } });
-      break;
-    }
-    default:
-      break;
-  }
-}
 function createNotificationService(options) {
   const store = {
     notifications: /* @__PURE__ */ new Map(),
@@ -203,23 +104,21 @@ function createNotificationService(options) {
     maxPerWindow: options?.maxPerWindow ?? DEFAULT_MAX_PER_WINDOW
   };
   const descriptor = {
-    name: "notifications",
+    name: "notify",
     version: NOTIFICATION_SERVICE_VERSION,
     description: "Notification state registry \u2014 tracks notifications per napplet window"
   };
   return {
     descriptor,
     handleMessage(windowId, message, send) {
-      const msg = message;
-      if (message.type.startsWith("notify.")) {
-        handleNotifyEnvelope(store, windowId, message.type.slice(7), msg, send);
-        return;
-      }
-      if (message.type !== "inc.emit") return;
-      const topic = msg.topic;
-      if (!topic?.startsWith("notifications:")) return;
-      const payload = msg.payload ?? {};
-      handleIncNotification(store, windowId, topic.slice(14), payload, send);
+      if (!message.type.startsWith("notify.")) return;
+      handleNotifyEnvelope(
+        store,
+        windowId,
+        message.type.slice(7),
+        message,
+        send
+      );
     },
     onWindowDestroyed(windowId) {
       if (store.notifications.delete(windowId)) {
@@ -231,16 +130,16 @@ function createNotificationService(options) {
 
 // src/identity-service.ts
 var IDENTITY_SERVICE_VERSION = "1.0.0";
-function sendProviderError(send, result2, fallback, err2) {
+function sendProviderError(send, result2, fallback, _err) {
   send({
     ...result2,
-    error: err2?.message ?? fallback
+    error: fallback
   });
 }
 async function getCurrentPubkey(options) {
-  const currentSigner = options.getSigner();
-  if (!currentSigner?.getPublicKey) return "";
   try {
+    const currentSigner = options.getSigner();
+    if (!currentSigner?.getPublicKey) return "";
     return await currentSigner.getPublicKey() ?? "";
   } catch {
     return "";
@@ -253,46 +152,29 @@ function sendOptionalProviderResult(options, send, fallbackResult, errorFallback
   }
   Promise.resolve(getCurrentPubkey(options)).then((pubkey) => buildResult(pubkey)).then((result2) => send(result2)).catch((err2) => sendProviderError(send, fallbackResult, errorFallback, err2));
 }
-function sendIdentityError(send, id, typeBase, error) {
-  send({ type: `${typeBase}.error`, id, error });
-}
-function sendSignerError(send, id, typeBase, fallback, err2) {
-  sendIdentityError(send, id, typeBase, err2?.message ?? fallback);
-}
 function handleGetPublicKey(options, id, send) {
-  const signer = options.getSigner();
-  if (!signer) {
-    const result2 = {
-      type: "identity.getPublicKey.result",
-      id,
-      pubkey: ""
-    };
-    send(result2);
-    return;
-  }
-  Promise.resolve(signer.getPublicKey?.()).then((pubkey) => {
+  Promise.resolve().then(() => options.getSigner()).then(async (signer) => signer?.getPublicKey ? signer.getPublicKey() : "").catch(() => "").then((pubkey) => {
     const result2 = {
       type: "identity.getPublicKey.result",
       id,
       pubkey: pubkey ?? ""
     };
     send(result2);
-  }).catch((err2) => sendSignerError(send, id, "identity.getPublicKey", "getPublicKey failed", err2));
+  });
 }
 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 result2 = {
-      type: "identity.getRelays.result",
-      id,
-      relays
+  const fallbackResult = {
+    type: "identity.getRelays.result",
+    id,
+    relays: {}
+  };
+  Promise.resolve().then(() => options.getSigner()).then(async (signer) => {
+    if (!signer?.getRelays) return fallbackResult;
+    return {
+      ...fallbackResult,
+      relays: await signer.getRelays() ?? {}
     };
-    send(result2);
-  }).catch((err2) => sendSignerError(send, id, "identity.getRelays", "getRelays failed", err2));
+  }).catch(() => ({ ...fallbackResult, error: "identity.getRelays failed" })).then(send);
 }
 function handleReadProvider(options, id, message, send) {
   switch (message.type) {
@@ -301,11 +183,11 @@ function handleReadProvider(options, id, message, send) {
         options,
         send,
         { type: "identity.getProfile.result", id, profile: null },
-        "getProfile failed",
+        "identity.getProfile failed",
         options.getProfile ? async (pubkey) => ({
           type: "identity.getProfile.result",
           id,
-          profile: await options.getProfile(pubkey, message)
+          profile: await options.getProfile(pubkey, message) ?? null
         }) : void 0
       );
       return true;
@@ -314,11 +196,11 @@ function handleReadProvider(options, id, message, send) {
         options,
         send,
         { type: "identity.getFollows.result", id, pubkeys: [] },
-        "getFollows failed",
+        "identity.getFollows failed",
         options.getFollows ? async (pubkey) => ({
           type: "identity.getFollows.result",
           id,
-          pubkeys: await options.getFollows(pubkey, message)
+          pubkeys: await options.getFollows(pubkey, message) ?? []
         }) : void 0
       );
       return true;
@@ -330,11 +212,11 @@ function handleReadProvider(options, id, message, send) {
         options,
         send,
         { type: "identity.getZaps.result", id, zaps: [] },
-        "getZaps failed",
+        "identity.getZaps failed",
         options.getZaps ? async (pubkey) => ({
           type: "identity.getZaps.result",
           id,
-          zaps: await options.getZaps(pubkey, message)
+          zaps: await options.getZaps(pubkey, message) ?? []
         }) : void 0
       );
       return true;
@@ -343,11 +225,11 @@ function handleReadProvider(options, id, message, send) {
         options,
         send,
         { type: "identity.getMutes.result", id, pubkeys: [] },
-        "getMutes failed",
+        "identity.getMutes failed",
         options.getMutes ? async (pubkey) => ({
           type: "identity.getMutes.result",
           id,
-          pubkeys: await options.getMutes(pubkey, message)
+          pubkeys: await options.getMutes(pubkey, message) ?? []
         }) : void 0
       );
       return true;
@@ -356,11 +238,11 @@ function handleReadProvider(options, id, message, send) {
         options,
         send,
         { type: "identity.getBlocked.result", id, pubkeys: [] },
-        "getBlocked failed",
+        "identity.getBlocked failed",
         options.getBlocked ? async (pubkey) => ({
           type: "identity.getBlocked.result",
           id,
-          pubkeys: await options.getBlocked(pubkey, message)
+          pubkeys: await options.getBlocked(pubkey, message) ?? []
         }) : void 0
       );
       return true;
@@ -369,11 +251,11 @@ function handleReadProvider(options, id, message, send) {
         options,
         send,
         { type: "identity.getBadges.result", id, badges: [] },
-        "getBadges failed",
+        "identity.getBadges failed",
         options.getBadges ? async (pubkey) => ({
           type: "identity.getBadges.result",
           id,
-          badges: await options.getBadges(pubkey, message)
+          badges: await options.getBadges(pubkey, message) ?? []
         }) : void 0
       );
       return true;
@@ -386,11 +268,11 @@ function handleGetList(options, id, message, send) {
     options,
     send,
     { type: "identity.getList.result", id, entries: [] },
-    "getList failed",
+    "identity.getList failed",
     options.getList ? async (pubkey) => ({
       type: "identity.getList.result",
       id,
-      entries: await options.getList(message.listType, pubkey, message)
+      entries: await options.getList(message.listType, pubkey, message) ?? []
     }) : void 0
   );
 }
@@ -404,9 +286,7 @@ function handleIdentityServiceMessage(options, message, send) {
       handleGetRelays(options, id, send);
       return;
     default:
-      if (!handleReadProvider(options, id, message, send)) {
-        sendIdentityError(send, id, message.type, `Unknown identity method: ${message.type}`);
-      }
+      handleReadProvider(options, id, message, send);
   }
 }
 function createIdentityService(options) {
@@ -430,6 +310,37 @@ import { createRelayEventResultWithHints } from "@kehto/runtime";
 var EOSE_FALLBACK_MS = 15e3;
 function createRelayPoolService(options) {
   const tracked = /* @__PURE__ */ new Map();
+  function publishEvent(relayMessage, resultType, send) {
+    const id = typeof relayMessage.id === "string" ? relayMessage.id : "";
+    const event = relayMessage.event;
+    if (!event || typeof event !== "object") {
+      send({ type: resultType, id, ok: false, error: "invalid event" });
+      return;
+    }
+    if (!options.isAvailable()) {
+      send({ type: resultType, id, ok: false, error: "no relay pool available" });
+      return;
+    }
+    void (async () => {
+      try {
+        await options.publish(event);
+        send({
+          type: resultType,
+          id,
+          ok: true,
+          event,
+          eventId: event.id
+        });
+      } catch (error) {
+        send({
+          type: resultType,
+          id,
+          ok: false,
+          error: error instanceof Error && error.message ? error.message : "publish failed"
+        });
+      }
+    })();
+  }
   return {
     descriptor: {
       name: "relay-pool",
@@ -489,17 +400,11 @@ function createRelayPoolService(options) {
         return;
       }
       if (message.type === "relay.publish") {
-        const event = relayMessage.event;
-        if (event && typeof event === "object" && options.isAvailable()) {
-          options.publish(event);
-        }
+        publishEvent(relayMessage, "relay.publish.result", send);
         return;
       }
       if (message.type === "relay.publishEncrypted") {
-        const event = relayMessage.event;
-        if (event && typeof event === "object" && options.isAvailable()) {
-          options.publish(event);
-        }
+        publishEvent(relayMessage, "relay.publishEncrypted.result", send);
         return;
       }
     },
@@ -651,6 +556,48 @@ function isPlainObject(value) {
 // src/coordinated-relay.ts
 import { createRelayEventResult as createRelayEventResult2, createRelayEventResultWithHints as createRelayEventResultWithHints2 } from "@kehto/runtime";
 var DEFAULT_EOSE_TIMEOUT_MS = 15e3;
+function publishCoordinatedEvent(options, relayMessage, send) {
+  const id = typeof relayMessage.id === "string" ? relayMessage.id : "";
+  const event = relayMessage.event;
+  if (!event || typeof event !== "object") {
+    send({ type: "relay.publish.result", id, ok: false, error: "invalid event" });
+    return;
+  }
+  if (!options.relayPool.isAvailable()) {
+    send({
+      type: "relay.publish.result",
+      id,
+      ok: false,
+      error: "no relay pool available"
+    });
+    return;
+  }
+  void (async () => {
+    try {
+      await options.relayPool.publish(event);
+      if (options.cache.isAvailable()) {
+        try {
+          options.cache.store(event);
+        } catch {
+        }
+      }
+      send({
+        type: "relay.publish.result",
+        id,
+        ok: true,
+        event,
+        eventId: event.id
+      });
+    } catch (error) {
+      send({
+        type: "relay.publish.result",
+        id,
+        ok: false,
+        error: error instanceof Error && error.message ? error.message : "publish failed"
+      });
+    }
+  })();
+}
 function createCoordinatedRelay(options) {
   const timeoutMs = options.eoseTimeoutMs ?? DEFAULT_EOSE_TIMEOUT_MS;
   const subs = /* @__PURE__ */ new Map();
@@ -758,17 +705,7 @@ function createCoordinatedRelay(options) {
         return;
       }
       if (message.type === "relay.publish") {
-        const event = relayMessage.event;
-        if (!event || typeof event !== "object") return;
-        if (options.relayPool.isAvailable()) {
-          options.relayPool.publish(event);
-        }
-        if (options.cache.isAvailable()) {
-          try {
-            options.cache.store(event);
-          } catch {
-          }
-        }
+        publishCoordinatedEvent(options, relayMessage, send);
         return;
       }
     },
@@ -1628,8 +1565,15 @@ var DEFAULT_THEME = {
   // fonts, background, title intentionally undefined — all optional per
   // @napplet/nap/theme Theme interface.
 };
+function isCompleteTheme(theme) {
+  const colors = theme?.colors;
+  return typeof colors?.background === "string" && typeof colors.text === "string" && typeof colors.primary === "string";
+}
+function normalizeTheme(theme) {
+  return isCompleteTheme(theme) ? theme : DEFAULT_THEME;
+}
 function createThemeService(options = {}) {
-  let currentTheme = options.initialTheme ?? DEFAULT_THEME;
+  let currentTheme = normalizeTheme(options.initialTheme);
   const descriptor = {
     name: "theme",
     version: THEME_SERVICE_VERSION,
@@ -1648,19 +1592,15 @@ function createThemeService(options = {}) {
         send(result2);
         return;
       }
-      send({
-        type: `${message.type}.error`,
-        id,
-        error: `Unknown theme method: ${message.type}`
-      });
+      return;
     },
     // Theme service has no per-window state to clean up.
     onWindowDestroyed(_windowId) {
     }
   };
   function publishTheme(theme) {
-    currentTheme = theme;
-    const envelope = { type: "theme.changed", theme };
+    currentTheme = normalizeTheme(theme);
+    const envelope = { type: "theme.changed", theme: currentTheme };
     options.onBroadcast?.(envelope);
     return envelope;
   }
@@ -3226,42 +3166,132 @@ function toErrorMessage4(err2) {
   if (typeof err2 === "string") return err2;
   return "intent request failed";
 }
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function validateIntentRequest(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { error: "invalid request" };
+  }
+  const request = value;
+  if (typeof request.archetype !== "string" || request.archetype.length === 0) {
+    return { error: "invalid request" };
+  }
+  const action = request.action === void 0 ? "open" : request.action;
+  if (typeof action !== "string" || action.length === 0) {
+    return { error: "invalid request" };
+  }
+  if (request.convention !== void 0 && (typeof request.convention !== "string" || !/^napplet:[^/?#\s]+\/[^/?#\s]+$/.test(request.convention))) {
+    return { error: "invalid convention" };
+  }
+  const allowedKeys = ["archetype", "action", "convention", "payload", "handler", "behavior"];
+  if (Object.keys(request).some((key) => !allowedKeys.includes(key))) {
+    return { error: "invoke rejected" };
+  }
+  if (hasOwn(request, "handler") && request.handler !== void 0 && (typeof request.handler !== "string" || request.handler.length === 0)) {
+    return { error: "invoke rejected" };
+  }
+  let behavior;
+  if (hasOwn(request, "behavior") && request.behavior !== void 0) {
+    if (typeof request.behavior !== "object" || request.behavior === null || Array.isArray(request.behavior)) {
+      return { error: "invoke rejected" };
+    }
+    const record = request.behavior;
+    if (Object.keys(record).some((key) => key !== "focus" && key !== "newWindow" && key !== "reuse") || hasOwn(record, "focus") && typeof record.focus !== "boolean" || hasOwn(record, "newWindow") && typeof record.newWindow !== "boolean" || hasOwn(record, "reuse") && typeof record.reuse !== "boolean") {
+      return { error: "invoke rejected" };
+    }
+    behavior = {
+      ...record.focus === void 0 ? {} : { focus: record.focus },
+      ...record.newWindow === void 0 ? {} : { newWindow: record.newWindow },
+      ...record.reuse === void 0 ? {} : { reuse: record.reuse }
+    };
+  }
+  return {
+    request: {
+      archetype: request.archetype,
+      action,
+      ...typeof request.convention === "string" ? { convention: request.convention } : {},
+      ...hasOwn(request, "payload") ? { payload: request.payload } : {},
+      ...typeof request.handler === "string" ? { handler: request.handler } : {},
+      ...behavior === void 0 ? {} : { behavior }
+    }
+  };
+}
+function settleResolverCall(call, send, resultType, id, onValue) {
+  let pending;
+  try {
+    pending = Promise.resolve(call());
+  } catch (error) {
+    send({ type: resultType, id, error: toErrorMessage4(error) });
+    return;
+  }
+  pending.then((value) => send(onValue(value))).catch((error) => send({ type: resultType, id, error: toErrorMessage4(error) }));
+}
+function rejectedResult(request, error) {
+  return {
+    ok: false,
+    archetype: request.archetype,
+    action: request.action ?? "open",
+    handled: false,
+    error
+  };
+}
+function rejectInvoke(send, id, request, error = "invoke rejected") {
+  send({
+    type: "intent.invoke.result",
+    id,
+    result: rejectedResult(request, error)
+  });
+}
 function createIntentService(options) {
   if (!options || typeof options.resolver !== "object" || options.resolver === null) {
     throw new Error("createIntentService: options.resolver is required");
   }
   const { resolver } = options;
-  const windows = /* @__PURE__ */ new Map();
-  resolver.onChanged?.((availability) => {
-    for (const send of windows.values()) {
-      send({ type: "intent.changed", availability });
-    }
-  });
-  function settle6(call, send, resultType, id, onValue) {
-    let pending;
-    try {
-      pending = Promise.resolve(call());
-    } catch (err2) {
-      send({ type: resultType, id, error: toErrorMessage4(err2) });
-      return;
-    }
-    pending.then((value) => send(onValue(value))).catch((err2) => send({ type: resultType, id, error: toErrorMessage4(err2) }));
-  }
+  let runtimeContext;
+  let unsubscribeChanged;
   function handleInvoke(windowId, msg, send) {
     const m = msg;
     const id = m.id ?? "";
-    const request = m.request;
-    if (!request || typeof request !== "object" || typeof request.archetype !== "string" || request.archetype.length === 0) {
-      send({ type: "intent.invoke.result", id, error: "invalid request" });
+    const validation = validateIntentRequest(m.request);
+    if ("error" in validation) {
+      const raw = typeof m.request === "object" && m.request !== null ? m.request : {};
+      rejectInvoke(
+        send,
+        id,
+        {
+          archetype: typeof raw.archetype === "string" ? raw.archetype : "",
+          action: typeof raw.action === "string" ? raw.action : "open"
+        },
+        validation.error
+      );
       return;
     }
-    settle6(
-      () => resolver.invoke(request, { windowId }),
-      send,
-      "intent.invoke.result",
-      id,
-      (result2) => ({ type: "intent.invoke.result", id, result: result2 })
-    );
+    const sender = runtimeContext?.resolveDTag(windowId);
+    if (!sender) {
+      rejectInvoke(send, id, validation.request);
+      return;
+    }
+    let pending;
+    try {
+      pending = Promise.resolve(resolver.invoke(validation.request, { sender }));
+    } catch {
+      rejectInvoke(send, id, validation.request);
+      return;
+    }
+    void pending.then(
+      (result2) => {
+        send({
+          type: "intent.invoke.result",
+          id,
+          result: result2
+        });
+      },
+      () => {
+        rejectInvoke(send, id, validation.request);
+      }
+    ).catch(() => {
+    });
   }
   function handleAvailable(msg, send) {
     const m = msg;
@@ -3271,7 +3301,7 @@ function createIntentService(options) {
       return;
     }
     const archetype = m.archetype;
-    settle6(
+    settleResolverCall(
       () => resolver.available(archetype),
       send,
       "intent.available.result",
@@ -3282,7 +3312,7 @@ function createIntentService(options) {
   function handleHandlers(msg, send) {
     const m = msg;
     const id = m.id ?? "";
-    settle6(
+    settleResolverCall(
       () => resolver.handlers(),
       send,
       "intent.handlers.result",
@@ -3292,8 +3322,31 @@ function createIntentService(options) {
   }
   return {
     descriptor: INTENT_DESCRIPTOR,
+    onRegistered(context) {
+      try {
+        unsubscribeChanged?.();
+      } catch {
+      }
+      runtimeContext = context;
+      unsubscribeChanged = resolver.onChanged?.((availability) => {
+        const current = runtimeContext;
+        if (!current) return;
+        const message = { type: "intent.changed", availability };
+        for (const windowId of current.listWindowIds()) {
+          current.sendToEligibleNapplet(windowId, message);
+        }
+      });
+    },
+    onUnregistered() {
+      const unsubscribe = unsubscribeChanged;
+      unsubscribeChanged = void 0;
+      runtimeContext = void 0;
+      try {
+        unsubscribe?.();
+      } catch {
+      }
+    },
     handleMessage(windowId, message, send) {
-      windows.set(windowId, send);
       switch (message.type) {
         case "intent.invoke":
           handleInvoke(windowId, message, send);
@@ -3307,9 +3360,6 @@ function createIntentService(options) {
         default:
           return;
       }
-    },
-    onWindowDestroyed(windowId) {
-      windows.delete(windowId);
     }
   };
 }
@@ -3323,103 +3373,144 @@ function candidatesFor(catalog, archetype, defaultHandler) {
     candidates.push({
       dTag: entry.dTag,
       ...entry.title === void 0 ? {} : { title: entry.title },
-      actions: support.actions,
-      protocols: support.protocols,
+      actions: [...support.actions],
+      conventions: [...support.conventions],
       ...entry.dTag === defaultHandler ? { isDefault: true } : {}
     });
   }
   return candidates;
 }
-function fail(archetype, action, error) {
-  return { ok: false, archetype, action, handled: false, error };
+function reject(request, error) {
+  return {
+    ok: false,
+    archetype: request.archetype,
+    action: request.action ?? "open",
+    handled: false,
+    error
+  };
+}
+async function availabilityForCatalog(options, archetype) {
+  const catalog = await options.loadCatalog();
+  const defaultHandler = options.getDefaultHandler?.(archetype);
+  const candidates = candidatesFor(catalog, archetype, defaultHandler);
+  return {
+    archetype,
+    available: candidates.length > 0,
+    candidates,
+    hasDefault: defaultHandler !== void 0 && candidates.some((candidate) => candidate.dTag === defaultHandler)
+  };
+}
+async function chooseCompatible(options, request, candidates, sender) {
+  if (!options.chooseHandler) {
+    return request.handler === "choose" ? { error: "user cancelled" } : { error: "invoke rejected" };
+  }
+  const picked = await options.chooseHandler(request.archetype, candidates, sender);
+  if (picked === void 0) return { error: "user cancelled" };
+  const candidate = candidates.find((item) => item.dTag === picked);
+  return candidate ? { candidate } : { error: "invoke rejected" };
+}
+async function pickHandler(options, request, compatible, sender) {
+  const preference = request.handler;
+  if (typeof preference === "string" && preference !== "default" && preference !== "choose") {
+    const candidate = compatible.find((item) => item.dTag === preference);
+    if (!candidate || !options.authorizeExplicitHandler) return { error: "invoke rejected" };
+    let authorized = false;
+    try {
+      authorized = await options.authorizeExplicitHandler(
+        sender,
+        preference,
+        request,
+        candidate
+      );
+    } catch {
+      return { error: "invoke rejected" };
+    }
+    return authorized ? { candidate } : { error: "invoke rejected" };
+  }
+  if (preference === "choose") {
+    return chooseCompatible(options, request, compatible, sender);
+  }
+  const defaultCandidate = compatible.find((candidate) => candidate.isDefault === true);
+  if (preference === "default") {
+    return defaultCandidate ? { candidate: defaultCandidate } : { error: "invoke rejected" };
+  }
+  if (defaultCandidate) return { candidate: defaultCandidate };
+  if (compatible.length === 1) return { candidate: compatible[0] };
+  return chooseCompatible(options, request, compatible, sender);
+}
+async function invokeFromCatalog(options, request, context) {
+  const catalog = await options.loadCatalog();
+  const defaultHandler = options.getDefaultHandler?.(request.archetype);
+  const candidates = candidatesFor(catalog, request.archetype, defaultHandler);
+  if (candidates.length === 0) return reject(request, "no handler");
+  const action = request.action ?? "open";
+  const actionCompatible = candidates.filter((candidate) => candidate.actions.includes(action));
+  if (actionCompatible.length === 0) return reject(request, "unsupported action");
+  const compatible = request.convention === void 0 ? actionCompatible : actionCompatible.filter((candidate) => candidate.conventions.includes(request.convention));
+  if (compatible.length === 0) return reject(request, "unsupported convention");
+  const sender = context.sender;
+  if (typeof sender !== "string" || sender.length === 0) {
+    return reject(request, "invoke rejected");
+  }
+  const selected = await pickHandler(options, request, compatible, sender);
+  if ("error" in selected) return reject(request, selected.error);
+  const convention = request.convention ?? selected.candidate.conventions.find((value) => {
+    const match = /^napplet:[^/?#\s]+\/([^/?#\s]+)$/.exec(value);
+    return match?.[1] === action;
+  });
+  if (!convention) return reject(request, "unsupported convention");
+  const behavior = request.behavior === void 0 ? void 0 : Object.freeze({
+    ...request.behavior.focus === void 0 ? {} : { focus: request.behavior.focus },
+    ...request.behavior.newWindow === void 0 ? {} : { newWindow: request.behavior.newWindow },
+    ...request.behavior.reuse === void 0 ? {} : { reuse: request.behavior.reuse }
+  });
+  const params = Object.freeze({
+    handler: selected.candidate.dTag,
+    sender,
+    archetype: request.archetype,
+    action,
+    convention,
+    ...request.payload === void 0 ? {} : { payload: request.payload },
+    ...behavior === void 0 ? {} : { behavior }
+  });
+  let target;
+  try {
+    target = await options.targets.dispatch(params);
+  } catch {
+    return reject(request, "invoke failed");
+  }
+  if (!target || typeof target.windowId !== "string" || target.windowId.length === 0) {
+    return reject(request, "invoke failed");
+  }
+  return {
+    ok: true,
+    archetype: request.archetype,
+    action,
+    handled: true,
+    handler: selected.candidate.dTag,
+    windowId: target.windowId,
+    convention
+  };
 }
 function createCatalogIntentResolver(options) {
   if (!options || typeof options.loadCatalog !== "function") {
     throw new Error("createCatalogIntentResolver: options.loadCatalog is required");
   }
-  if (!options.windows || typeof options.windows.open !== "function") {
-    throw new Error("createCatalogIntentResolver: options.windows is required");
+  if (!options.targets || typeof options.targets.dispatch !== "function") {
+    throw new Error("createCatalogIntentResolver: options.targets is required");
   }
-  const { loadCatalog, windows, getDefaultHandler, chooseHandler, defaultProtocol } = options;
   const listeners = /* @__PURE__ */ new Set();
-  async function availabilityFor(archetype) {
-    const catalog = await loadCatalog();
-    const def = getDefaultHandler?.(archetype);
-    const candidates = candidatesFor(catalog, archetype, def);
-    return {
-      archetype,
-      available: candidates.length > 0,
-      candidates,
-      hasDefault: def !== void 0 && candidates.some((c) => c.dTag === def)
-    };
-  }
-  async function pickHandler(archetype, candidates, preference, callerWindowId) {
-    if (typeof preference === "string" && preference !== "default" && preference !== "choose") {
-      return preference;
-    }
-    if (preference === "choose") {
-      const picked = await chooseHandler?.(archetype, candidates, callerWindowId);
-      return picked ?? null;
-    }
-    const def = getDefaultHandler?.(archetype);
-    if (def !== void 0 && candidates.some((c) => c.dTag === def)) return def;
-    if (candidates.length === 1) return candidates[0].dTag;
-    if (chooseHandler) {
-      const picked = await chooseHandler(archetype, candidates, callerWindowId);
-      return picked ?? null;
-    }
-    return candidates[0].dTag;
-  }
-  async function invoke(request, context) {
-    const archetype = request.archetype;
-    const action = request.action ?? "open";
-    const catalog = await loadCatalog();
-    const candidates = candidatesFor(catalog, archetype, getDefaultHandler?.(archetype));
-    if (candidates.length === 0) return fail(archetype, action, "no handler");
-    const pickedDTag = await pickHandler(archetype, candidates, request.handler, context.windowId);
-    if (pickedDTag === null) return fail(archetype, action, "user cancelled");
-    const handler = candidates.find((c) => c.dTag === pickedDTag);
-    if (!handler) return fail(archetype, action, "no handler");
-    if (!handler.actions.includes(action)) return fail(archetype, action, "unsupported action");
-    const protocol = request.protocol ?? defaultProtocol?.(archetype) ?? handler.protocols[0];
-    if (protocol !== void 0 && handler.protocols.length > 0 && !handler.protocols.includes(protocol)) {
-      return fail(archetype, action, "unsupported protocol");
-    }
-    let windowId;
-    try {
-      const opened = await windows.open({
-        dTag: handler.dTag,
-        archetype,
-        action,
-        ...protocol === void 0 ? {} : { protocol },
-        ...request.payload === void 0 ? {} : { payload: request.payload },
-        ...request.behavior === void 0 ? {} : { behavior: request.behavior },
-        callerWindowId: context.windowId
-      });
-      windowId = opened.windowId;
-    } catch {
-      return fail(archetype, action, "invoke failed");
-    }
-    return {
-      ok: true,
-      archetype,
-      action,
-      handled: true,
-      handler: handler.dTag,
-      windowId,
-      ...protocol === void 0 ? {} : { protocol }
-    };
-  }
+  const availabilityFor = (archetype) => availabilityForCatalog(options, archetype);
   async function handlers() {
-    const catalog = await loadCatalog();
+    const catalog = await options.loadCatalog();
     const archetypes = /* @__PURE__ */ new Set();
     for (const entry of catalog) {
       for (const slug of Object.keys(entry.archetypes)) archetypes.add(slug);
     }
-    return Promise.all([...archetypes].map((a) => availabilityFor(a)));
+    return Promise.all([...archetypes].map((archetype) => availabilityFor(archetype)));
   }
   return {
-    invoke,
+    invoke: (request, context) => invokeFromCatalog(options, request, context),
     available: availabilityFor,
     handlers,
     onChanged(listener) {
@@ -3436,14 +3527,26 @@ function createCatalogIntentResolver(options) {
 }
 
 // src/manifest-intent-catalog.ts
-var DEFAULT_ACTIONS = ["open"];
+function actionFromConvention(slug, convention) {
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(slug)) {
+    throw new TypeError("manifest archetype slug is invalid");
+  }
+  const match = /^napplet:([^/?#\s]+)\/([^/?#\s]+)$/.exec(convention);
+  if (!match || match[1] !== slug) {
+    throw new TypeError("manifest archetype convention is invalid or mismatched");
+  }
+  return match[2];
+}
 function manifestToIntentCatalogEntry(manifest) {
   const archetypes = {};
-  for (const { slug, nap } of manifest.archetypes) {
-    archetypes[slug] = {
-      actions: [...DEFAULT_ACTIONS],
-      protocols: nap ? [nap] : []
+  for (const { slug, convention } of manifest.archetypes) {
+    const action = actionFromConvention(slug, convention);
+    const support = archetypes[slug] ??= {
+      actions: [],
+      conventions: []
     };
+    if (!support.actions.includes(action)) support.actions.push(action);
+    if (!support.conventions.includes(convention)) support.conventions.push(convention);
   }
   return {
     dTag: manifest.dTag,
@@ -4932,7 +5035,6 @@ function createCordnDmAdapter(options) {
 }
 export {
   DmMemoryStore,
-  createAudioService,
   createBleService,
   createBrowserMediaBridge,
   createCacheService,