@kehto/runtime 0.18.3 → 0.19.0

package/dist/index.js

@@ -66,11 +66,20 @@ function createSessionRegistry(notifier) {
     getWindowId(pubkey) {
       return byPubkey.get(pubkey)?.windowId;
     },
+    getWindowIdByDTag(dTag) {
+      let resolvedWindowId;
+      for (const [windowId, entry] of byWindowIdEntry) {
+        if (entry.dTag !== dTag) continue;
+        if (resolvedWindowId !== void 0) return void 0;
+        resolvedWindowId = windowId;
+      }
+      return resolvedWindowId;
+    },
     isRegistered(windowId) {
       return byWindowId.has(windowId);
     },
     getAllEntries() {
-      return Array.from(byPubkey.values());
+      return Array.from(byWindowIdEntry.values());
     },
     getInstanceId(windowId) {
       const pubkey = byWindowId.get(windowId);
@@ -178,7 +187,7 @@ function bitsToCapabilities(bits) {
 function toIdentity(pubkey, dTag, hash) {
   return { pubkey, dTag, hash };
 }
-function createAclState(persistence, defaultPolicy = "permissive") {
+function createAclState(persistence, defaultPolicy = "permissive", onMutation) {
   let state = createState(defaultPolicy);
   function ensureRuntimeDefaultEntry(id) {
     if (state.defaultPolicy !== "permissive") return;
@@ -199,11 +208,13 @@ function createAclState(persistence, defaultPolicy = "permissive") {
       const id = toIdentity(pubkey, dTag, aggregateHash);
       ensureRuntimeDefaultEntry(id);
       state = revoke(state, id, capToBit(capability));
+      onMutation?.({ type: "revoke", dTag, aggregateHash, capability });
     },
     block(pubkey, dTag, aggregateHash) {
       const id = toIdentity(pubkey, dTag, aggregateHash);
       ensureRuntimeDefaultEntry(id);
       state = block(state, id);
+      onMutation?.({ type: "block", dTag, aggregateHash });
     },
     unblock(pubkey, dTag, aggregateHash) {
       const id = toIdentity(pubkey, dTag, aggregateHash);
@@ -399,18 +410,39 @@ function createManifestCache(persistence) {
 var REPLAY_WINDOW_SECONDS = 30;
 function createReplayDetector(getReplayWindow) {
   const seenEventIds = /* @__PURE__ */ new Map();
+  function checkAndTrack(event, state) {
+    const replayWindow = getReplayWindow?.() ?? REPLAY_WINDOW_SECONDS;
+    const now = Math.floor(Date.now() / 1e3);
+    for (const [id, entry] of seenEventIds) {
+      if (entry.state === "committed" && now - entry.timestamp > replayWindow) {
+        seenEventIds.delete(id);
+      }
+    }
+    if (now - event.created_at > replayWindow) return "invalid: event created_at too old";
+    if (event.created_at - now > 10) return "invalid: event created_at in the future";
+    if (seenEventIds.has(event.id)) return "duplicate: already processed";
+    seenEventIds.set(event.id, { state, timestamp: now });
+    return null;
+  }
   return {
     check(event) {
-      const replayWindow = getReplayWindow?.() ?? REPLAY_WINDOW_SECONDS;
-      const now = Math.floor(Date.now() / 1e3);
-      if (now - event.created_at > replayWindow) return "invalid: event created_at too old";
-      if (event.created_at - now > 10) return "invalid: event created_at in the future";
-      if (seenEventIds.has(event.id)) return "duplicate: already processed";
-      seenEventIds.set(event.id, now);
-      for (const [id, timestamp] of seenEventIds) {
-        if (now - timestamp > replayWindow) seenEventIds.delete(id);
+      return checkAndTrack(event, "committed");
+    },
+    reserve(event) {
+      return checkAndTrack(event, "pending");
+    },
+    commit(eventId) {
+      const entry = seenEventIds.get(eventId);
+      if (entry?.state !== "pending") return;
+      seenEventIds.set(eventId, {
+        state: "committed",
+        timestamp: Math.floor(Date.now() / 1e3)
+      });
+    },
+    release(eventId) {
+      if (seenEventIds.get(eventId)?.state === "pending") {
+        seenEventIds.delete(eventId);
       }
-      return null;
     },
     clear() {
       seenEventIds.clear();
@@ -524,21 +556,13 @@ import { createDispatch } from "@napplet/core";
 
 // src/service-dispatch.ts
 function routeServiceMessage(windowId, message, services, sendToNapplet) {
+  if (message.type === "inc.emit") return false;
   const domain = message.type.split(".")[0];
   const handler = services[domain];
   if (handler) {
     handler.handleMessage(windowId, message, (msg) => sendToNapplet(windowId, msg));
     return true;
   }
-  const incMessage = message;
-  if (message.type === "inc.emit" && typeof incMessage.topic === "string") {
-    const prefix = incMessage.topic.split(":")[0];
-    const incHandler = services[prefix];
-    if (incHandler) {
-      incHandler.handleMessage(windowId, message, (msg) => sendToNapplet(windowId, msg));
-      return true;
-    }
-  }
   return false;
 }
 function notifyServiceWindowDestroyed(windowId, services) {
@@ -564,7 +588,7 @@ function createRelayHandler(context) {
         handleRelayClose(context, windowId, msg, m);
         return;
       case "publish":
-        handleRelayPublish(context, windowId, msg, m);
+        handleRelayPublish(context, windowId, m);
         return;
       case "publishEncrypted":
         handleRelayPublishEncrypted(context, windowId, msg);
@@ -688,29 +712,106 @@ function handleRelayClose(context, windowId, msg, m) {
   hooks.relayPool?.untrackSubscription(subKey);
   hooks.sendToNapplet(windowId, { type: "relay.closed", subId, message: "" });
 }
-function handleRelayPublish(context, windowId, msg, m) {
-  const { eventBuffer, hooks, replayDetector } = context;
-  const event = m.event;
+function handleRelayPublish(context, windowId, m) {
+  const { hooks, replayDetector } = context;
+  const eventTemplate = m.event;
   const id = m.id ?? "";
-  if (!event || typeof event !== "object") {
-    hooks.sendToNapplet(windowId, { type: "relay.publish.error", id, error: "invalid event" });
+  if (!eventTemplate || typeof eventTemplate !== "object") {
+    sendRelayPublishResult(hooks, windowId, id, false, void 0, "invalid event template");
     return;
   }
-  const replayResult = replayDetector.check(event);
-  if (replayResult !== null) {
-    hooks.sendToNapplet(windowId, { type: "relay.publish.result", id, accepted: false, message: replayResult });
+  const signer = hooks.auth.getSigner();
+  const signEvent = signer?.signEvent?.bind(signer);
+  if (!signEvent) {
+    sendRelayPublishResult(hooks, windowId, id, false, void 0, "no signer configured");
     return;
   }
+  void (async () => {
+    try {
+      const signed = await signEvent(eventTemplate);
+      if (!signed) {
+        sendRelayPublishResult(hooks, windowId, id, false, void 0, "signEvent returned no event");
+        return;
+      }
+      const replayResult = replayDetector.reserve(signed);
+      if (replayResult !== null) {
+        sendRelayPublishResult(hooks, windowId, id, false, void 0, replayResult);
+        return;
+      }
+      publishSignedRelayEvent(context, windowId, id, signed, (ok, error) => {
+        if (ok) replayDetector.commit(signed.id);
+        else replayDetector.release(signed.id);
+        sendRelayPublishResult(hooks, windowId, id, ok, ok ? signed : void 0, error);
+      });
+    } catch (error) {
+      sendRelayPublishResult(
+        hooks,
+        windowId,
+        id,
+        false,
+        void 0,
+        error instanceof Error && error.message ? error.message : "event signing failed"
+      );
+    }
+  })();
+}
+function sendRelayPublishResult(hooks, windowId, id, ok, event, error) {
+  const result = ok && event ? { type: "relay.publish.result", id, ok: true, event, eventId: event.id } : { type: "relay.publish.result", id, ok: false, error: error ?? "publish failed" };
+  hooks.sendToNapplet(windowId, result);
+}
+function publishSignedRelayEvent(context, windowId, id, signed, reply) {
+  const { eventBuffer, hooks } = context;
+  let settled = false;
+  const settle = (ok, error) => {
+    if (settled) return;
+    settled = true;
+    if (ok) {
+      try {
+        eventBuffer.bufferAndDeliver(signed, windowId);
+      } catch {
+      }
+    }
+    reply(ok, error);
+  };
   const relayService = relayServiceFrom(context);
   if (relayService) {
-    relayService.handleMessage(windowId, msg, (resp) => hooks.sendToNapplet(windowId, resp));
-  } else if (hooks.relayPool?.isAvailable()) {
-    hooks.relayPool.publish(event);
-    hooks.sendToNapplet(windowId, { type: "relay.publish.result", id, accepted: true });
-  } else {
-    hooks.sendToNapplet(windowId, { type: "relay.publish.result", id, accepted: false, message: "no relay pool available" });
+    const publishMessage = { type: "relay.publish", id, event: signed };
+    try {
+      relayService.handleMessage(windowId, publishMessage, (response) => {
+        if (response.type !== "relay.publish.result" && response.type !== "relay.publish.error") {
+          return;
+        }
+        const result = response;
+        const ok = response.type === "relay.publish.result" && (result.ok ?? result.accepted ?? false);
+        settle(ok, ok ? void 0 : result.error ?? result.message ?? "publish failed");
+      });
+    } catch (error) {
+      settle(
+        false,
+        error instanceof Error && error.message ? error.message : "relay service failed"
+      );
+    }
+    return;
+  }
+  if (!hooks.relayPool?.isAvailable()) {
+    settle(false, "no relay pool available");
+    return;
+  }
+  try {
+    const publishResult = hooks.relayPool.publish(signed);
+    void Promise.resolve(publishResult).then(
+      () => settle(true),
+      (error) => settle(
+        false,
+        error instanceof Error && error.message ? error.message : "publish failed"
+      )
+    );
+  } catch (error) {
+    settle(
+      false,
+      error instanceof Error && error.message ? error.message : "publish failed"
+    );
   }
-  eventBuffer.bufferAndDeliver(event, windowId);
 }
 function handleRelayPublishEncrypted(context, windowId, msg) {
   const { hooks } = context;
@@ -742,7 +843,7 @@ function handleRelayPublishEncrypted(context, windowId, msg) {
   publishEncrypted(context, windowId, id, recipient, encryption, eventTemplate, replyPe);
 }
 function publishEncrypted(context, windowId, id, recipient, encryption, eventTemplate, replyPe) {
-  const { eventBuffer, hooks } = context;
+  const { hooks } = context;
   const peSigner = hooks.auth.getSigner();
   if (!peSigner) return;
   (async () => {
@@ -755,46 +856,14 @@ function publishEncrypted(context, windowId, id, recipient, encryption, eventTem
         replyPe(false, { error: "signEvent returned null" });
         return;
       }
-      publishSignedEncrypted(context, windowId, id, signed, replyPe);
-      try {
-        eventBuffer.bufferAndDeliver(signed, windowId);
-      } catch {
-        return;
-      }
+      publishSignedRelayEvent(context, windowId, id, signed, (ok, error) => {
+        replyPe(ok, ok ? { event: signed, eventId: signed.id } : { error: error ?? "publish failed" });
+      });
     } catch (err) {
       replyPe(false, { error: err?.message ?? "encryption failed" });
     }
   })();
 }
-function publishSignedEncrypted(context, windowId, id, signed, replyPe) {
-  const { hooks } = context;
-  const relayService = relayServiceFrom(context);
-  if (!relayService) {
-    if (hooks.relayPool?.isAvailable()) {
-      hooks.relayPool.publish(signed);
-      replyPe(true, { event: signed, eventId: signed.id });
-    } else {
-      replyPe(false, { error: "no relay pool available" });
-    }
-    return;
-  }
-  const publishMsg = { type: "relay.publish", id, event: signed };
-  let replied = false;
-  relayService.handleMessage(windowId, publishMsg, (resp) => {
-    if (replied) return;
-    const r = resp;
-    if (typeof r.type !== "string" || !r.type.startsWith("relay.publish")) return;
-    const okVal = r.ok ?? r.accepted ?? false;
-    replied = true;
-    const publishResult = { event: signed, eventId: signed.id };
-    if (!okVal) publishResult.error = r.error ?? r.message ?? "publish failed";
-    replyPe(okVal, publishResult);
-  });
-  if (!replied) {
-    replied = true;
-    replyPe(true, { event: signed, eventId: signed.id });
-  }
-}
 function handleRelayQuery(context, windowId, m) {
   const { hooks, serviceRegistry, eventBuffer } = context;
   const id = m.id ?? "";
@@ -921,6 +990,63 @@ function handleRelayQuery(context, windowId, m) {
   }, relayUrls);
 }
 
+// src/domain-results.ts
+var RUNTIME_THEME_FALLBACK = {
+  colors: { background: "#0a0a0a", text: "#e0e0e0", primary: "#7aa2f7" }
+};
+var IDENTITY_SAFE_DEFAULTS = {
+  "identity.getPublicKey": { pubkey: "" },
+  "identity.getRelays": { relays: {} },
+  "identity.getProfile": { profile: null },
+  "identity.getFollows": { pubkeys: [] },
+  "identity.getList": { entries: [] },
+  "identity.getZaps": { zaps: [] },
+  "identity.getMutes": { pubkeys: [] },
+  "identity.getBlocked": { pubkeys: [] },
+  "identity.getBadges": { badges: [] }
+};
+function isRuntimeOwnedIdentityOrThemeRequest(type) {
+  return type === "theme.get" || type in IDENTITY_SAFE_DEFAULTS;
+}
+function createRuntimeOwnedResultEnvelope(type, id) {
+  return Object.assign({ type }, { id });
+}
+function isIdentityOrThemeMessage(message) {
+  return message.type.startsWith("identity.") || message.type.startsWith("theme.");
+}
+function createIntentPolicyDenial(message) {
+  const id = message.id ?? "";
+  if (message.type === "intent.invoke") {
+    return {
+      type: "intent.invoke.result",
+      id,
+      result: { ok: false, error: "invoke rejected" }
+    };
+  }
+  if (message.type === "intent.available" || message.type === "intent.handlers") {
+    return {
+      type: `${message.type}.result`,
+      id,
+      error: "intent request denied"
+    };
+  }
+  return void 0;
+}
+function createCanonicalDomainResult(message) {
+  if (!isRuntimeOwnedIdentityOrThemeRequest(message.type)) return void 0;
+  const id = message.id ?? "";
+  if (message.type === "theme.get") {
+    return Object.assign(
+      createRuntimeOwnedResultEnvelope("theme.get.result", id),
+      { theme: RUNTIME_THEME_FALLBACK }
+    );
+  }
+  return Object.assign(
+    createRuntimeOwnedResultEnvelope(`${message.type}.result`, id),
+    IDENTITY_SAFE_DEFAULTS[message.type]
+  );
+}
+
 // src/identity-handler.ts
 function createIdentityHandler(context) {
   return function handleIdentityMessage(windowId, msg) {
@@ -930,14 +1056,12 @@ function createIdentityHandler(context) {
       identityService.handleMessage(windowId, msg, (resp) => hooks.sendToNapplet(windowId, resp));
       return;
     }
-    const id = msg.id ?? "";
     const action = msg.type.slice("identity.".length);
     const signer = hooks.auth.getSigner();
-    const sendError = (error) => {
-      hooks.sendToNapplet(windowId, { type: `${msg.type}.error`, id, error });
-    };
-    const sendResult = (payload) => {
-      hooks.sendToNapplet(windowId, { type: `${msg.type}.result`, id, ...payload });
+    const fallback = createCanonicalDomainResult(msg);
+    if (!fallback) return;
+    const sendResult = (payload = {}) => {
+      hooks.sendToNapplet(windowId, { ...fallback, ...payload });
     };
     switch (action) {
       case "getPublicKey":
@@ -945,14 +1069,14 @@ function createIdentityHandler(context) {
           sendResult({ pubkey: "" });
           return;
         }
-        Promise.resolve(signer.getPublicKey?.()).then((pubkey) => sendResult({ pubkey: pubkey ?? "" })).catch((err) => sendError(err?.message ?? "getPublicKey failed"));
+        Promise.resolve(signer.getPublicKey?.()).then((pubkey) => sendResult({ pubkey: pubkey ?? "" })).catch(() => sendResult({ pubkey: "" }));
         return;
       case "getRelays":
         if (!signer) {
-          sendError("no signer configured");
+          sendResult();
           return;
         }
-        Promise.resolve(signer.getRelays?.() ?? {}).then((relays) => sendResult({ relays })).catch((err) => sendError(err?.message ?? "getRelays failed"));
+        Promise.resolve(signer.getRelays?.() ?? {}).then((relays) => sendResult({ relays })).catch(() => sendResult());
         return;
       case "getProfile":
         sendResult({ profile: null });
@@ -976,7 +1100,7 @@ function createIdentityHandler(context) {
         sendResult({ badges: [] });
         return;
       default:
-        sendError(`Unknown identity action: ${action}`);
+        return;
     }
   };
 }
@@ -1043,7 +1167,8 @@ function isPlainObject(value) {
 }
 
 // src/inc-handler.ts
-function createIncRuntime(hooks, sessionRegistry) {
+var MAX_CHANNELS_PER_WINDOW = 32;
+function createIncRuntime(hooks, sessionRegistry, authorizeChannelOpen) {
   const state = {
     subscriptions: /* @__PURE__ */ new Map(),
     channels: /* @__PURE__ */ new Map(),
@@ -1051,12 +1176,15 @@ function createIncRuntime(hooks, sessionRegistry) {
   };
   return {
     handleMessage(windowId, msg) {
-      handleIncMessage(state, hooks, sessionRegistry, windowId, msg);
+      handleIncMessage(state, hooks, sessionRegistry, authorizeChannelOpen, windowId, msg);
     },
     destroyWindow(windowId) {
       removeWindowChannels(state, hooks, windowId);
       removeWindowSubscriptions(state, windowId);
     },
+    revokeWindow(windowId) {
+      revokeWindowChannels(state, hooks, windowId);
+    },
     clear() {
       state.subscriptions.clear();
       state.channels.clear();
@@ -1094,18 +1222,18 @@ function peerOf(state, channelId, self) {
   return null;
 }
 function resolveTarget(sessionRegistry, target) {
-  if (sessionRegistry.getEntryByWindowId(target)) return target;
-  const entries = sessionRegistry.getAllEntries();
-  const byPubkey = entries.find((entry) => entry.pubkey === target);
-  return byPubkey?.windowId ?? null;
+  return sessionRegistry.getWindowIdByDTag(target) ?? null;
 }
-function handleIncMessage(state, hooks, sessionRegistry, windowId, msg) {
+function hasReachedChannelLimit(state, windowId) {
+  return (state.channelsByWindow.get(windowId)?.size ?? 0) >= MAX_CHANNELS_PER_WINDOW;
+}
+function handleIncMessage(state, hooks, sessionRegistry, authorizeChannelOpen, windowId, msg) {
   const m = msg;
   const dotIdx = msg.type.indexOf(".");
   const action = msg.type.slice(dotIdx + 1);
   switch (action) {
     case "emit":
-      handleEmit(state, hooks, windowId, m);
+      handleEmit(state, hooks, sessionRegistry, windowId, m);
       return;
     case "subscribe":
       handleSubscribe(state, hooks, windowId, m);
@@ -1114,16 +1242,16 @@ function handleIncMessage(state, hooks, sessionRegistry, windowId, msg) {
       handleUnsubscribe(state, windowId, m);
       return;
     case "channel.open":
-      handleChannelOpen(state, hooks, sessionRegistry, windowId, m);
+      handleChannelOpen(state, hooks, sessionRegistry, authorizeChannelOpen, windowId, m);
       return;
     case "channel.emit":
-      handleChannelEmit(state, hooks, windowId, m);
+      handleChannelEmit(state, hooks, sessionRegistry, windowId, m);
       return;
     case "channel.broadcast":
-      handleChannelBroadcast(state, hooks, windowId, m);
+      handleChannelBroadcast(state, hooks, sessionRegistry, windowId, m);
       return;
     case "channel.list":
-      handleChannelList(state, hooks, windowId, m);
+      handleChannelList(state, hooks, sessionRegistry, windowId, m);
       return;
     case "channel.close":
       handleChannelClose(state, hooks, windowId, m);
@@ -1132,14 +1260,16 @@ function handleIncMessage(state, hooks, sessionRegistry, windowId, msg) {
       return;
   }
 }
-function handleEmit(state, hooks, windowId, m) {
+function handleEmit(state, hooks, sessionRegistry, windowId, m) {
   const topic = m.topic ?? "";
+  const sender = sessionRegistry.getEntryByWindowId(windowId)?.dTag;
+  if (!sender) return;
   if (!topic) return;
   const subscribers = state.subscriptions.get(topic);
   if (!subscribers) return;
   for (const subscriberWindowId of subscribers) {
     if (subscriberWindowId !== windowId) {
-      hooks.sendToNapplet(subscriberWindowId, { type: "inc.event", topic, payload: m.payload, sender: windowId });
+      hooks.sendToNapplet(subscriberWindowId, { type: "inc.event", topic, payload: m.payload, sender });
     }
   }
 }
@@ -1166,51 +1296,96 @@ function handleUnsubscribe(state, windowId, m) {
   subscriptions.delete(windowId);
   if (subscriptions.size === 0) state.subscriptions.delete(topic);
 }
-function handleChannelOpen(state, hooks, sessionRegistry, windowId, m) {
+function handleChannelOpen(state, hooks, sessionRegistry, authorizeChannelOpen, windowId, m) {
   const id = m.id ?? "";
   const peerWindow = resolveTarget(sessionRegistry, m.target ?? "");
-  if (!peerWindow) {
+  const openerDTag = sessionRegistry.getEntryByWindowId(windowId)?.dTag;
+  const peerDTag = peerWindow ? sessionRegistry.getEntryByWindowId(peerWindow)?.dTag : void 0;
+  if (!peerWindow || !openerDTag || !peerDTag) {
     hooks.sendToNapplet(windowId, { type: "inc.channel.open.result", id, error: "target not found" });
     return;
   }
+  if (!authorizeChannelOpen(peerWindow, m)) {
+    hooks.sendToNapplet(windowId, { type: "inc.channel.open.result", id, error: "target denied" });
+    return;
+  }
+  if (hasReachedChannelLimit(state, windowId) || hasReachedChannelLimit(state, peerWindow)) {
+    hooks.sendToNapplet(windowId, { type: "inc.channel.open.result", id, error: "channel limit reached" });
+    return;
+  }
   const channelId = hooks.crypto.randomUUID().replace(/-/g, "").slice(0, 32);
   addChannel(state, channelId, windowId, peerWindow);
-  hooks.sendToNapplet(windowId, { type: "inc.channel.open.result", id, channelId, peer: peerWindow });
+  try {
+    hooks.sendToNapplet(peerWindow, { type: "inc.channel.opened", channelId, peer: openerDTag });
+  } catch {
+    removeChannel(state, channelId);
+    hooks.sendToNapplet(windowId, { type: "inc.channel.open.result", id, error: "target unavailable" });
+    return;
+  }
+  try {
+    hooks.sendToNapplet(windowId, { type: "inc.channel.open.result", id, channelId, peer: peerDTag });
+  } catch {
+    teardownChannel(state, hooks, channelId);
+  }
 }
-function handleChannelEmit(state, hooks, windowId, m) {
+function handleChannelEmit(state, hooks, sessionRegistry, windowId, m) {
   const peer = peerOf(state, m.channelId ?? "", windowId);
-  if (peer) {
-    hooks.sendToNapplet(peer, { type: "inc.channel.event", channelId: m.channelId ?? "", sender: windowId, payload: m.payload });
+  const sender = sessionRegistry.getEntryByWindowId(windowId)?.dTag;
+  if (peer && sender) {
+    hooks.sendToNapplet(peer, { type: "inc.channel.event", channelId: m.channelId ?? "", sender, payload: m.payload });
   }
 }
-function handleChannelBroadcast(state, hooks, windowId, m) {
+function handleChannelBroadcast(state, hooks, sessionRegistry, windowId, m) {
   const channels = state.channelsByWindow.get(windowId);
-  if (!channels) return;
+  const sender = sessionRegistry.getEntryByWindowId(windowId)?.dTag;
+  if (!channels || !sender) return;
   for (const channelId of channels) {
     const peer = peerOf(state, channelId, windowId);
     if (peer) {
-      hooks.sendToNapplet(peer, { type: "inc.channel.event", channelId, sender: windowId, payload: m.payload });
+      hooks.sendToNapplet(peer, { type: "inc.channel.event", channelId, sender, payload: m.payload });
     }
   }
 }
-function handleChannelList(state, hooks, windowId, m) {
+function handleChannelList(state, hooks, sessionRegistry, windowId, m) {
   const channels = [];
   const set = state.channelsByWindow.get(windowId);
   if (set) {
     for (const channelId of set) {
       const peer = peerOf(state, channelId, windowId);
-      if (peer) channels.push({ id: channelId, peer });
+      const peerDTag = peer ? sessionRegistry.getEntryByWindowId(peer)?.dTag : void 0;
+      if (peerDTag) channels.push({ id: channelId, peer: peerDTag });
     }
   }
   hooks.sendToNapplet(windowId, { type: "inc.channel.list.result", id: m.id ?? "", channels });
 }
 function handleChannelClose(state, hooks, windowId, m) {
   const channelId = m.channelId ?? "";
-  const peer = peerOf(state, channelId, windowId);
-  if (!peer) return;
-  hooks.sendToNapplet(windowId, { type: "inc.channel.closed", channelId });
-  hooks.sendToNapplet(peer, { type: "inc.channel.closed", channelId });
-  removeChannel(state, channelId);
+  if (!peerOf(state, channelId, windowId)) return;
+  teardownChannel(state, hooks, channelId);
+}
+function teardownChannel(state, hooks, channelId, destroyedWindowId) {
+  const channel = state.channels.get(channelId);
+  if (!channel) return;
+  try {
+    if (destroyedWindowId) {
+      const survivor = peerOf(state, channelId, destroyedWindowId);
+      if (survivor) {
+        try {
+          hooks.sendToNapplet(survivor, { type: "inc.channel.closed", channelId, reason: "peer destroyed" });
+        } catch {
+        }
+      }
+      return;
+    }
+    for (const peer of [channel.peerA, channel.peerB]) {
+      try {
+        hooks.sendToNapplet(peer, { type: "inc.channel.closed", channelId });
+      } catch {
+      }
+    }
+  } finally {
+    removeChannel(state, channelId);
+  }
 }
 function removeWindowSubscriptions(state, windowId) {
   for (const [topic, subscriptions] of state.subscriptions) {
@@ -1222,11 +1397,14 @@ function removeWindowChannels(state, hooks, windowId) {
   const channelIds = state.channelsByWindow.get(windowId);
   if (!channelIds) return;
   for (const channelId of Array.from(channelIds)) {
-    const peer = peerOf(state, channelId, windowId);
-    if (peer) {
-      hooks.sendToNapplet(peer, { type: "inc.channel.closed", channelId });
-    }
-    removeChannel(state, channelId);
+    teardownChannel(state, hooks, channelId, windowId);
+  }
+}
+function revokeWindowChannels(state, hooks, windowId) {
+  const channelIds = state.channelsByWindow.get(windowId);
+  if (!channelIds) return;
+  for (const channelId of Array.from(channelIds)) {
+    teardownChannel(state, hooks, channelId);
   }
 }
 
@@ -1377,9 +1555,6 @@ function cleanupNappState(pubkey, dTag, aggregateHash, statePersistence) {
 }
 
 // src/domain-handlers.ts
-var THEME_FALLBACK_DEFAULT = {
-  colors: { background: "#0a0a0a", text: "#e0e0e0", primary: "#7aa2f7" }
-};
 function createRuntimeDomainHandlers(context) {
   return {
     storage: (windowId, msg) => handleStorageMessage(context, windowId, msg),
@@ -1441,8 +1616,9 @@ function handleMediaMessage(context, windowId, msg) {
   }
 }
 function handleKeysMessage(context, windowId, msg) {
-  const { hooks, serviceRegistry } = context;
+  const { hooks, serviceRegistry, sessionRegistry } = context;
   if (msg.type === "keys.forward") {
+    if (!sessionRegistry.getEntryByWindowId(windowId)) return;
     forwardHotkey(hooks, msg);
     return;
   }
@@ -1469,8 +1645,7 @@ function sendRegisterActionResult(hooks, windowId, msg) {
   hooks.sendToNapplet(windowId, {
     type: "keys.registerAction.result",
     id: m.id ?? "",
-    actionId: m.action?.id ?? "",
-    ...m.action?.defaultKey ? { binding: m.action.defaultKey } : {}
+    actionId: m.action?.id ?? ""
   });
 }
 function handleNotifyMessage(context, windowId, msg) {
@@ -1495,16 +1670,13 @@ function handleThemeMessage(context, windowId, msg) {
     themeService.handleMessage(windowId, msg, (resp) => hooks.sendToNapplet(windowId, resp));
     return;
   }
-  if (msg.type === "theme.get") {
-    const m = msg;
-    hooks.sendToNapplet(windowId, {
-      type: "theme.get.result",
-      id: m.id ?? "",
-      theme: THEME_FALLBACK_DEFAULT
-    });
-  }
+  const fallback = createCanonicalDomainResult(msg);
+  if (fallback) hooks.sendToNapplet(windowId, fallback);
 }
 function handleServiceOnlyMessage(context, name, windowId, msg) {
+  if (name === "intent" && msg.type !== "intent.invoke" && msg.type !== "intent.available" && msg.type !== "intent.handlers") {
+    return;
+  }
   const service = context.serviceRegistry[name];
   if (!service) return;
   service.handleMessage(windowId, msg, (resp) => context.hooks.sendToNapplet(windowId, resp));
@@ -1592,7 +1764,20 @@ function buildObservation(envelope, windowId, senderCap, sessionRegistry, getFoc
   const focus = getFocusContext?.(windowId) ?? { focused: true };
   const opClass = senderCap ?? envelope.type;
   const { kind, size } = extractKindSize(envelope);
-  return { napplet, opClass, kind, size, initElapsedMs, focused: focus.focused, msSinceFocusGain: focus.msSinceFocusGain, now };
+  return {
+    napplet,
+    opClass,
+    kind,
+    size,
+    initElapsedMs,
+    // `windowId` comes from the host's source-bound session lookup, never the
+    // napplet message envelope. It scopes startup burst accounting to this
+    // registered realm while rate limits remain dTag-wide.
+    initKey: windowId,
+    focused: focus.focused,
+    msSinceFocusGain: focus.msSinceFocusGain,
+    now
+  };
 }
 function createFirewallGate(config) {
   const { firewallState, sessionRegistry, hooks, fireConsent } = config;
@@ -1603,10 +1788,25 @@ function createFirewallGate(config) {
     const napplet = obs.napplet;
     const opClass = obs.opClass;
     if (decision === "reject" || decision === "prompt") {
+      const intentDenial = createIntentPolicyDenial(envelope);
+      if (intentDenial) {
+        hooks.sendToNapplet(windowId, intentDenial);
+        hooks.onFirewallEvent?.({ windowId, napplet, opClass, decision, action, ruleId, reason, message: envelope });
+        if (decision === "prompt") fireConsent(windowId, napplet);
+        return "drop";
+      }
+      const canonicalResult = createCanonicalDomainResult(envelope);
+      if (canonicalResult) {
+        hooks.sendToNapplet(windowId, canonicalResult);
+        hooks.onFirewallEvent?.({ windowId, napplet, opClass, decision, action, ruleId, reason, message: envelope });
+        if (decision === "prompt") fireConsent(windowId, napplet);
+        return "drop";
+      }
       const id = envelope.id ?? "";
-      const isStorageEnvelope = envelope.type.startsWith("storage.");
-      const type = isStorageEnvelope ? `${envelope.type}.result` : `${envelope.type}.error`;
-      hooks.sendToNapplet(windowId, { type, id, error: `firewall: ${reason}` });
+      const type = denialResponseType(envelope);
+      if (type) {
+        hooks.sendToNapplet(windowId, { type, id, error: `firewall: ${reason}` });
+      }
       hooks.onFirewallEvent?.({ windowId, napplet, opClass, decision, action, ruleId, reason, message: envelope });
       if (decision === "prompt") {
         fireConsent(windowId, napplet);
@@ -1619,21 +1819,45 @@ function createFirewallGate(config) {
     return "dispatch";
   };
 }
-function createMessageHandler(hooks, enforceNap, dispatchNapEnvelope, firewallGate) {
+function denialResponseType(envelope) {
+  if (envelope.type.startsWith("intent.")) return null;
+  if (envelope.type.startsWith("storage.")) return `${envelope.type}.result`;
+  if (envelope.type === "inc.subscribe" || envelope.type === "inc.channel.open") {
+    return `${envelope.type}.result`;
+  }
+  if (envelope.type.startsWith("inc.")) return null;
+  return `${envelope.type}.error`;
+}
+function createMessageHandler(hooks, sessionRegistry, enforceNap, dispatchNapEnvelope, firewallGate) {
   return (windowId, msg) => {
     if (typeof msg !== "object" || msg === null || !("type" in msg)) return;
     const envelope = msg;
     const dotIdx = envelope.type.indexOf(".");
     if (dotIdx === -1) return;
+    if (!sessionRegistry.getEntryByWindowId(windowId)) return;
+    const domain = envelope.type.slice(0, dotIdx);
+    if (hooks.isDomainAllowed && !hooks.isDomainAllowed(windowId, domain)) return;
+    if (isIdentityOrThemeMessage(envelope) && !createCanonicalDomainResult(envelope)) return;
     const caps = resolveCapabilitiesNap(envelope);
     if (caps.senderCap) {
       const result = enforceNap(windowId, caps.senderCap, envelope);
       if (!result.allowed) {
+        const intentDenial = createIntentPolicyDenial(envelope);
+        if (intentDenial) {
+          hooks.sendToNapplet(windowId, intentDenial);
+          return;
+        }
+        const canonicalResult = createCanonicalDomainResult(envelope);
+        if (canonicalResult) {
+          hooks.sendToNapplet(windowId, canonicalResult);
+          return;
+        }
         const id = envelope.id ?? "";
-        const isStorageEnvelope = envelope.type.startsWith("storage.");
         const error = formatDenialReason(result.capability);
-        const type = isStorageEnvelope ? `${envelope.type}.result` : `${envelope.type}.error`;
-        hooks.sendToNapplet(windowId, { type, id, error });
+        const type = denialResponseType(envelope);
+        if (type) {
+          hooks.sendToNapplet(windowId, { type, id, error });
+        }
         return;
       }
     }
@@ -1670,12 +1894,64 @@ function createRuntimeInstance(context) {
     consentHandlerRef
   } = context;
   const undeclaredServiceConsents = /* @__PURE__ */ new Set();
+  const attachedServices = /* @__PURE__ */ new Map();
+  const isDomainAllowed = hooks.isDomainAllowed;
+  const sendToNapplet = hooks.sendToNapplet;
+  const serviceContext = Object.freeze({
+    resolveDTag(windowId) {
+      return sessionRegistry.getEntryByWindowId(windowId)?.dTag;
+    },
+    listWindowIds() {
+      return Object.freeze(
+        sessionRegistry.getAllEntries().map((entry) => entry.windowId)
+      );
+    },
+    sendToEligibleNapplet(windowId, message) {
+      const entry = sessionRegistry.getEntryByWindowId(windowId);
+      if (!entry || typeof message.type !== "string") return false;
+      const dotIndex = message.type.indexOf(".");
+      if (dotIndex <= 0) return false;
+      const domain = message.type.slice(0, dotIndex);
+      try {
+        if (isDomainAllowed && !isDomainAllowed(windowId, domain)) return false;
+        const { recipientCap } = resolveCapabilitiesNap(message);
+        if (!recipientCap) return false;
+        if (!aclState.check("", entry.dTag, entry.aggregateHash, recipientCap)) {
+          return false;
+        }
+        sendToNapplet(windowId, message);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  });
+  function attachService(name, handler) {
+    attachedServices.set(name, handler);
+    try {
+      handler.onRegistered?.(serviceContext);
+    } catch {
+    }
+  }
+  function detachService(name) {
+    const handler = attachedServices.get(name);
+    if (!handler) return;
+    attachedServices.delete(name);
+    try {
+      handler.onUnregistered?.();
+    } catch {
+    }
+  }
+  for (const [name, handler] of Object.entries(serviceRegistry)) {
+    attachService(name, handler);
+  }
   return {
     handleMessage: context.handleMessage,
     injectEvent(topic, payload) {
       eventBuffer.bufferAndDeliver(createInjectedEvent(hooks, topic, payload), null);
     },
     destroy() {
+      for (const name of attachedServices.keys()) detachService(name);
       manifestCache.persist();
       aclState.persist();
       firewallState.persist();
@@ -1690,14 +1966,17 @@ function createRuntimeInstance(context) {
       consentHandlerRef.current = handler;
     },
     registerService(name, handler) {
+      detachService(name);
       serviceRegistry[name] = handler;
       registeredServices.set(name, {
         name: handler.descriptor.name,
         version: handler.descriptor.version,
         description: handler.descriptor.description
       });
+      attachService(name, handler);
     },
     unregisterService(name) {
+      detachService(name);
       delete serviceRegistry[name];
       registeredServices.delete(name);
     },
@@ -1730,7 +2009,15 @@ function createRuntime(hooks) {
   const serviceRegistry = { ...hooks.services };
   const registeredServices = createRegisteredServices(serviceRegistry);
   const sessionRegistry = createSessionRegistry(hooks.onPendingUpdate);
-  const aclState = createAclState(hooks.aclPersistence);
+  let incRuntime = null;
+  const aclState = createAclState(hooks.aclPersistence, "permissive", (mutation) => {
+    if (mutation.type === "revoke" && mutation.capability !== "relay:read") return;
+    for (const entry of sessionRegistry.getAllEntries()) {
+      if (entry.dTag === mutation.dTag && entry.aggregateHash === mutation.aggregateHash) {
+        incRuntime?.revokeWindow(entry.windowId);
+      }
+    }
+  });
   const firewallState = createFirewallState(hooks.firewallPersistence);
   const manifestCache = createManifestCache(hooks.manifestPersistence);
   const replayDetector = createReplayDetector(
@@ -1767,6 +2054,11 @@ function createRuntime(hooks) {
     },
     onAclCheck: hooks.onAclCheck
   });
+  incRuntime = createIncRuntime(
+    hooks,
+    sessionRegistry,
+    (targetWindowId, message) => enforceNap(targetWindowId, "relay:read", message).allowed
+  );
   const firewallGate = createFirewallGate({ firewallState, sessionRegistry, hooks, fireConsent });
   const eventBuffer = createEventBuffer(
     hooks.sendToNapplet,
@@ -1778,7 +2070,6 @@ function createRuntime(hooks) {
   aclState.load();
   firewallState.load();
   manifestCache.load();
-  const incRuntime = createIncRuntime(hooks, sessionRegistry);
   const domainHandlers = createRuntimeDomainHandlers({ hooks, serviceRegistry, sessionRegistry, aclState });
   const dispatchNapEnvelope = createNapEnvelopeDispatcher({
     relay: createRelayHandler({ hooks, serviceRegistry, subscriptions, eventBuffer, replayDetector }),
@@ -1787,7 +2078,7 @@ function createRuntime(hooks) {
     inc: incRuntime.handleMessage,
     ...domainHandlers
   });
-  const handleMessage = createMessageHandler(hooks, enforceNap, dispatchNapEnvelope, firewallGate);
+  const handleMessage = createMessageHandler(hooks, sessionRegistry, enforceNap, dispatchNapEnvelope, firewallGate);
   return createRuntimeInstance({
     hooks,
     serviceRegistry,