@kehto/paja 0.8.0 → 0.10.0

package/dist/browser-host.js

@@ -196,6 +196,9 @@ function countMap(_action) {
   return { senderCap: "relay:read", recipientCap: null };
 }
 function identityMap(action) {
+  if (action === "changed") {
+    return { senderCap: null, recipientCap: "identity:read" };
+  }
   if (action === "getPublicKey" || action === "getRelays") {
     return { senderCap: null, recipientCap: null };
   }
@@ -219,9 +222,12 @@ function storageMap(action) {
   return { senderCap: null, recipientCap: null };
 }
 function incMap(action) {
-  if (action === "emit" || action === "channel.emit" || action === "channel.broadcast") {
+  if (action === "emit") {
     return { senderCap: "relay:write", recipientCap: "relay:read" };
   }
+  if (action === "channel.emit" || action === "channel.broadcast" || action === "channel.list" || action === "channel.close") {
+    return { senderCap: null, recipientCap: null };
+  }
   return { senderCap: "relay:read", recipientCap: null };
 }
 function configMap(action) {
@@ -256,11 +262,14 @@ function uploadMap(action) {
   return { senderCap: "upload:write", recipientCap: null };
 }
 function intentMap(action) {
-  if (action === "changed" || action.endsWith(".result") || action.endsWith(".error")) {
+  if (action === "changed" || action === "invoke.result" || action === "available.result" || action === "handlers.result") {
     return { senderCap: null, recipientCap: "intent:read" };
   }
   if (action === "invoke") return { senderCap: "intent:write", recipientCap: null };
-  return { senderCap: "intent:read", recipientCap: null };
+  if (action === "available" || action === "handlers") {
+    return { senderCap: "intent:read", recipientCap: null };
+  }
+  return { senderCap: null, recipientCap: null };
 }
 function dmMap(action) {
   if (action === "message" || action.endsWith(".result") || action.endsWith(".error")) {
@@ -363,12 +372,14 @@ function evaluate(config, state, observation) {
   }
   const { initElapsedMs } = observation;
   if (initElapsedMs !== void 0 && initElapsedMs < config.burstGuard.windowMs) {
-    const existingBurst = state.bursts[napplet];
+    const burstKey = observation.initKey ?? napplet;
+    const existingBurst = state.bursts[burstKey];
+    const activeBurst = existingBurst !== void 0 && now2 - existingBurst.windowStart < config.burstGuard.windowMs ? existingBurst : void 0;
     const newBurst = {
-      count: (existingBurst?.count ?? 0) + 1,
-      windowStart: existingBurst?.windowStart ?? now2
+      count: (activeBurst?.count ?? 0) + 1,
+      windowStart: activeBurst?.windowStart ?? now2
     };
-    const newBursts = { ...state.bursts, [napplet]: newBurst };
+    const newBursts = { ...state.bursts, [burstKey]: newBurst };
     if (newBurst.count > config.burstGuard.maxOps) {
       const burstAction = config.burstGuard.action;
       return {
@@ -612,7 +623,7 @@ function deserialize2(json) {
   return defaultConfig();
 }
 
-// ../../node_modules/.pnpm/@napplet+core@0.28.0/node_modules/@napplet/core/dist/index.js
+// ../../node_modules/.pnpm/@napplet+core@0.31.0/node_modules/@napplet/core/dist/index.js
 function createDispatch() {
   const handlers = /* @__PURE__ */ new Map();
   function registerNap2(domain, handler) {
@@ -705,11 +716,20 @@ function createSessionRegistry(notifier) {
     getWindowId(pubkey) {
       return byPubkey2.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 byWindowId2.has(windowId);
     },
     getAllEntries() {
-      return Array.from(byPubkey2.values());
+      return Array.from(byWindowIdEntry.values());
     },
     getInstanceId(windowId) {
       const pubkey = byWindowId2.get(windowId);
@@ -795,7 +815,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;
@@ -816,11 +836,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);
@@ -999,18 +1021,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 now2 = Math.floor(Date.now() / 1e3);
+    for (const [id, entry] of seenEventIds) {
+      if (entry.state === "committed" && now2 - entry.timestamp > replayWindow) {
+        seenEventIds.delete(id);
+      }
+    }
+    if (now2 - event.created_at > replayWindow) return "invalid: event created_at too old";
+    if (event.created_at - now2 > 10) return "invalid: event created_at in the future";
+    if (seenEventIds.has(event.id)) return "duplicate: already processed";
+    seenEventIds.set(event.id, { state, timestamp: now2 });
+    return null;
+  }
   return {
     check(event) {
-      const replayWindow = getReplayWindow?.() ?? REPLAY_WINDOW_SECONDS;
-      const now2 = Math.floor(Date.now() / 1e3);
-      if (now2 - event.created_at > replayWindow) return "invalid: event created_at too old";
-      if (event.created_at - now2 > 10) return "invalid: event created_at in the future";
-      if (seenEventIds.has(event.id)) return "duplicate: already processed";
-      seenEventIds.set(event.id, now2);
-      for (const [id, timestamp] of seenEventIds) {
-        if (now2 - 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();
@@ -1135,7 +1178,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);
@@ -1259,29 +1302,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 result2 = 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, result2);
+}
+function publishSignedRelayEvent(context, windowId, id, signed, reply) {
+  const { eventBuffer, hooks } = context;
+  let settled = false;
+  const settle6 = (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 result2 = response;
+        const ok = response.type === "relay.publish.result" && (result2.ok ?? result2.accepted ?? false);
+        settle6(ok, ok ? void 0 : result2.error ?? result2.message ?? "publish failed");
+      });
+    } catch (error) {
+      settle6(
+        false,
+        error instanceof Error && error.message ? error.message : "relay service failed"
+      );
+    }
+    return;
+  }
+  if (!hooks.relayPool?.isAvailable()) {
+    settle6(false, "no relay pool available");
+    return;
+  }
+  try {
+    const publishResult = hooks.relayPool.publish(signed);
+    void Promise.resolve(publishResult).then(
+      () => settle6(true),
+      (error) => settle6(
+        false,
+        error instanceof Error && error.message ? error.message : "publish failed"
+      )
+    );
+  } catch (error) {
+    settle6(
+      false,
+      error instanceof Error && error.message ? error.message : "publish failed"
+    );
   }
-  eventBuffer.bufferAndDeliver(event, windowId);
 }
 function handleRelayPublishEncrypted(context, windowId, msg) {
   const { hooks } = context;
@@ -1313,7 +1433,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 () => {
@@ -1326,46 +1446,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 ?? "";
@@ -1491,6 +1579,61 @@ function handleRelayQuery(context, windowId, m) {
     }
   }, relayUrls);
 }
+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]
+  );
+}
 function createIdentityHandler(context) {
   return function handleIdentityMessage(windowId, msg) {
     const { hooks, serviceRegistry } = context;
@@ -1499,14 +1642,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":
@@ -1514,14 +1655,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 });
@@ -1545,7 +1686,7 @@ function createIdentityHandler(context) {
         sendResult({ badges: [] });
         return;
       default:
-        sendError(`Unknown identity action: ${action}`);
+        return;
     }
   };
 }
@@ -1608,7 +1749,8 @@ function isValidFilterArray(value) {
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function createIncRuntime(hooks, sessionRegistry2) {
+var MAX_CHANNELS_PER_WINDOW = 32;
+function createIncRuntime(hooks, sessionRegistry2, authorizeChannelOpen) {
   const state = {
     subscriptions: /* @__PURE__ */ new Map(),
     channels: /* @__PURE__ */ new Map(),
@@ -1616,12 +1758,15 @@ function createIncRuntime(hooks, sessionRegistry2) {
   };
   return {
     handleMessage(windowId, msg) {
-      handleIncMessage(state, hooks, sessionRegistry2, windowId, msg);
+      handleIncMessage(state, hooks, sessionRegistry2, 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();
@@ -1659,18 +1804,18 @@ function peerOf(state, channelId, self) {
   return null;
 }
 function resolveTarget(sessionRegistry2, target) {
-  if (sessionRegistry2.getEntryByWindowId(target)) return target;
-  const entries = sessionRegistry2.getAllEntries();
-  const byPubkey2 = entries.find((entry) => entry.pubkey === target);
-  return byPubkey2?.windowId ?? null;
+  return sessionRegistry2.getWindowIdByDTag(target) ?? null;
+}
+function hasReachedChannelLimit(state, windowId) {
+  return (state.channelsByWindow.get(windowId)?.size ?? 0) >= MAX_CHANNELS_PER_WINDOW;
 }
-function handleIncMessage(state, hooks, sessionRegistry2, windowId, msg) {
+function handleIncMessage(state, hooks, sessionRegistry2, 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, sessionRegistry2, windowId, m);
       return;
     case "subscribe":
       handleSubscribe(state, hooks, windowId, m);
@@ -1679,16 +1824,16 @@ function handleIncMessage(state, hooks, sessionRegistry2, windowId, msg) {
       handleUnsubscribe(state, windowId, m);
       return;
     case "channel.open":
-      handleChannelOpen(state, hooks, sessionRegistry2, windowId, m);
+      handleChannelOpen(state, hooks, sessionRegistry2, authorizeChannelOpen, windowId, m);
       return;
     case "channel.emit":
-      handleChannelEmit(state, hooks, windowId, m);
+      handleChannelEmit(state, hooks, sessionRegistry2, windowId, m);
       return;
     case "channel.broadcast":
-      handleChannelBroadcast(state, hooks, windowId, m);
+      handleChannelBroadcast(state, hooks, sessionRegistry2, windowId, m);
       return;
     case "channel.list":
-      handleChannelList(state, hooks, windowId, m);
+      handleChannelList(state, hooks, sessionRegistry2, windowId, m);
       return;
     case "channel.close":
       handleChannelClose(state, hooks, windowId, m);
@@ -1697,14 +1842,16 @@ function handleIncMessage(state, hooks, sessionRegistry2, windowId, msg) {
       return;
   }
 }
-function handleEmit(state, hooks, windowId, m) {
+function handleEmit(state, hooks, sessionRegistry2, windowId, m) {
   const topic = m.topic ?? "";
+  const sender = sessionRegistry2.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 });
     }
   }
 }
@@ -1731,51 +1878,96 @@ function handleUnsubscribe(state, windowId, m) {
   subscriptions.delete(windowId);
   if (subscriptions.size === 0) state.subscriptions.delete(topic);
 }
-function handleChannelOpen(state, hooks, sessionRegistry2, windowId, m) {
+function handleChannelOpen(state, hooks, sessionRegistry2, authorizeChannelOpen, windowId, m) {
   const id = m.id ?? "";
   const peerWindow = resolveTarget(sessionRegistry2, m.target ?? "");
-  if (!peerWindow) {
+  const openerDTag = sessionRegistry2.getEntryByWindowId(windowId)?.dTag;
+  const peerDTag = peerWindow ? sessionRegistry2.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, sessionRegistry2, 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 = sessionRegistry2.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, sessionRegistry2, windowId, m) {
   const channels = state.channelsByWindow.get(windowId);
-  if (!channels) return;
+  const sender = sessionRegistry2.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, sessionRegistry2, 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 ? sessionRegistry2.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) {
@@ -1787,11 +1979,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);
   }
 }
 var INSTANCE_MARKER = "@i/";
@@ -1932,9 +2127,6 @@ function handleStorageNap(windowId, msg, sendToNapplet, sessionRegistry2, aclSta
       break;
   }
 }
-var THEME_FALLBACK_DEFAULT = {
-  colors: { background: "#0a0a0a", text: "#e0e0e0", primary: "#7aa2f7" }
-};
 function createRuntimeDomainHandlers(context) {
   return {
     storage: (windowId, msg) => handleStorageMessage(context, windowId, msg),
@@ -2050,16 +2242,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));
@@ -2145,7 +2334,20 @@ function buildObservation(envelope, windowId, senderCap, sessionRegistry2, getFo
   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: now2 };
+  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: now2
+  };
 }
 function createFirewallGate(config) {
   const { firewallState, sessionRegistry: sessionRegistry2, hooks, fireConsent } = config;
@@ -2156,10 +2358,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);
@@ -2172,21 +2389,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, sessionRegistry2, 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 (!sessionRegistry2.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 result2 = enforceNap(windowId, caps.senderCap, envelope);
       if (!result2.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(result2.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;
       }
     }
@@ -2223,12 +2464,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 sessionRegistry2.getEntryByWindowId(windowId)?.dTag;
+    },
+    listWindowIds() {
+      return Object.freeze(
+        sessionRegistry2.getAllEntries().map((entry) => entry.windowId)
+      );
+    },
+    sendToEligibleNapplet(windowId, message) {
+      const entry = sessionRegistry2.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);
       manifestCache2.persist();
       aclState.persist();
       firewallState.persist();
@@ -2243,14 +2536,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);
     },
@@ -2283,7 +2579,15 @@ function createRuntime(hooks) {
   const serviceRegistry = { ...hooks.services };
   const registeredServices = createRegisteredServices(serviceRegistry);
   const sessionRegistry2 = 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 sessionRegistry2.getAllEntries()) {
+      if (entry.dTag === mutation.dTag && entry.aggregateHash === mutation.aggregateHash) {
+        incRuntime?.revokeWindow(entry.windowId);
+      }
+    }
+  });
   const firewallState = createFirewallState(hooks.firewallPersistence);
   const manifestCache2 = createManifestCache(hooks.manifestPersistence);
   const replayDetector = createReplayDetector(
@@ -2320,6 +2624,11 @@ function createRuntime(hooks) {
     },
     onAclCheck: hooks.onAclCheck
   });
+  incRuntime = createIncRuntime(
+    hooks,
+    sessionRegistry2,
+    (targetWindowId, message) => enforceNap(targetWindowId, "relay:read", message).allowed
+  );
   const firewallGate = createFirewallGate({ firewallState, sessionRegistry: sessionRegistry2, hooks, fireConsent });
   const eventBuffer = createEventBuffer(
     hooks.sendToNapplet,
@@ -2331,7 +2640,6 @@ function createRuntime(hooks) {
   aclState.load();
   firewallState.load();
   manifestCache2.load();
-  const incRuntime = createIncRuntime(hooks, sessionRegistry2);
   const domainHandlers = createRuntimeDomainHandlers({ hooks, serviceRegistry, sessionRegistry: sessionRegistry2, aclState });
   const dispatchNapEnvelope = createNapEnvelopeDispatcher({
     relay: createRelayHandler({ hooks, serviceRegistry, subscriptions, eventBuffer, replayDetector }),
@@ -2340,7 +2648,7 @@ function createRuntime(hooks) {
     inc: incRuntime.handleMessage,
     ...domainHandlers
   });
-  const handleMessage = createMessageHandler(hooks, enforceNap, dispatchNapEnvelope, firewallGate);
+  const handleMessage = createMessageHandler(hooks, sessionRegistry2, enforceNap, dispatchNapEnvelope, firewallGate);
   return createRuntimeInstance({
     hooks,
     serviceRegistry,
@@ -2392,7 +2700,7 @@ function createRelayPoolAdapter(shellHooks, originRegistry2) {
       const pool = shellHooks.relayPool.getRelayPool();
       if (!pool) return;
       const relayUrls = shellHooks.relayPool.selectRelayTier([]);
-      pool.publish(relayUrls, event);
+      return pool.publish(relayUrls, event);
     },
     selectRelayTier(filters) {
       return shellHooks.relayPool.selectRelayTier(filters);
@@ -2747,6 +3055,19 @@ var originRegistry = {
     if (!entry?.dTag || !entry?.aggregateHash) return void 0;
     return { dTag: entry.dTag, aggregateHash: entry.aggregateHash };
   },
+  /** Store the immutable environment captured for this exact frame registration. */
+  setEnvironment(win, environment) {
+    const entry = registry.get(win);
+    if (!entry) return;
+    entry.environment = Object.freeze({
+      capabilities: Object.freeze({ domains: Object.freeze([...environment.capabilities.domains]) }),
+      services: Object.freeze([...environment.services])
+    });
+  },
+  /** Return the immutable environment captured before this frame executes. */
+  getEnvironment(win) {
+    return registry.get(win)?.environment;
+  },
   /**
    * Look up the monotonically increasing registration id for a Window.
    *
@@ -3305,111 +3626,151 @@ var audioManager = {
     version = 0;
   }
 };
-var NAP_DOMAINS = [
+var RUNTIME_NATIVE_DOMAINS = [
+  "relay",
   "identity",
   "storage",
   "inc",
   "theme",
   "keys",
   "media",
-  "notify",
+  "notify"
+];
+var SERVICE_ONLY_DOMAINS = [
+  "outbox",
   "config",
   "resource",
-  "cvm"
-];
-var NAP_INC_PROTOCOLS = [
-  "inc:NAP-01",
-  "inc:NAP-02",
-  "inc:NAP-03",
-  "inc:NAP-04",
-  "inc:NAP-05",
-  "inc:NAP-06"
+  "cvm",
+  "upload",
+  "intent",
+  "link",
+  "common",
+  "lists",
+  "serial",
+  "ble",
+  "webrtc",
+  "dm",
+  "count"
 ];
 function buildShellCapabilities(hooks) {
-  const domains = hooks.relayPool ? ["relay", "outbox", ...NAP_DOMAINS] : [...NAP_DOMAINS];
-  if (hooks.upload) domains.push("upload");
-  if (hooks.intent?.isAvailable()) domains.push("intent");
-  if (hooks.services?.count) domains.push("count");
-  if (hooks.link?.isAvailable()) domains.push("link");
-  if (hooks.common?.isAvailable()) domains.push("common");
-  if (hooks.lists?.isAvailable()) domains.push("lists");
-  if (hooks.serial?.isAvailable()) domains.push("serial");
-  if (hooks.ble?.isAvailable()) domains.push("ble");
-  if (hooks.webrtc?.isAvailable()) domains.push("webrtc");
-  if (hooks.dm) domains.push("dm");
-  const sandbox = [];
-  const protocols = {};
-  for (const entry of NAP_INC_PROTOCOLS) {
-    const [domain, protocol] = entry.split(":");
-    (protocols[domain] ??= []).push(protocol);
-  }
-  const naps = hooks.relayPool ? ["relay", "outbox", ...NAP_DOMAINS, ...NAP_INC_PROTOCOLS] : [...NAP_DOMAINS, ...NAP_INC_PROTOCOLS];
-  if (hooks.upload) naps.push("upload");
-  if (hooks.intent?.isAvailable()) naps.push("intent");
-  if (hooks.services?.count) naps.push("count");
-  if (hooks.link?.isAvailable()) naps.push("link");
-  if (hooks.common?.isAvailable()) naps.push("common");
-  if (hooks.lists?.isAvailable()) naps.push("lists");
-  if (hooks.serial?.isAvailable()) naps.push("serial");
-  if (hooks.ble?.isAvailable()) naps.push("ble");
-  if (hooks.webrtc?.isAvailable()) naps.push("webrtc");
-  if (hooks.dm) naps.push("dm");
-  return applyCapabilityOverrides(
-    { domains, protocols, naps, sandbox },
-    hooks.capabilities?.disabledDomains ?? []
-  );
+  const disabled = new Set(hooks.capabilities?.disabledDomains ?? []);
+  const domains = RUNTIME_NATIVE_DOMAINS.filter((domain) => !disabled.has(domain));
+  for (const domain of SERVICE_ONLY_DOMAINS) {
+    if (!disabled.has(domain) && isServiceDomainLive(hooks, domain)) domains.push(domain);
+  }
+  return Object.freeze({ domains: freezeList(domains) });
 }
-function applyCapabilityOverrides(capabilities, disabledDomains) {
-  if (disabledDomains.length === 0) return capabilities;
-  const disabled = new Set(disabledDomains);
-  const protocols = {};
-  for (const [domain, supportedProtocols] of Object.entries(capabilities.protocols)) {
-    if (!disabled.has(domain)) protocols[domain] = supportedProtocols;
+function resolveShellEnvironment(hooks, identity) {
+  const capabilities = buildShellCapabilities(hooks);
+  const disabled = new Set(hooks.capabilities?.disabledDomains ?? []);
+  const services = getLiveServices(hooks, capabilities.domains, disabled);
+  const available = Object.freeze({
+    domains: freezeList(capabilities.domains),
+    services: freezeList(services)
+  });
+  const granted = hooks.capabilities?.resolveEnvironment?.(identity, available) ?? available;
+  return Object.freeze({
+    capabilities: Object.freeze({
+      domains: freezeList(intersectInOrder(available.domains, granted.domains))
+    }),
+    services: freezeList(intersectInOrder(available.services, granted.services))
+  });
+}
+function isServiceDomainLive(hooks, domain) {
+  if (!hooks.services?.[domain]) return false;
+  switch (domain) {
+    case "outbox":
+      return Boolean(hooks.relayPool);
+    case "upload":
+      return hooks.upload?.getUploader() !== null && hooks.upload?.getUploader() !== void 0;
+    case "intent":
+      return hooks.intent?.isAvailable() === true;
+    case "link":
+      return hooks.link?.isAvailable() === true;
+    case "common":
+      return hooks.common?.isAvailable() === true;
+    case "lists":
+      return hooks.lists?.isAvailable() === true;
+    case "serial":
+      return hooks.serial?.isAvailable() === true;
+    case "ble":
+      return hooks.ble?.isAvailable() === true;
+    case "webrtc":
+      return hooks.webrtc?.isAvailable() === true;
+    case "dm":
+      return hooks.dm !== void 0;
+    default:
+      return true;
   }
+}
+function getLiveServices(hooks, domains, disabled) {
+  const liveDomains = new Set(domains);
+  return Object.keys(hooks.services ?? {}).filter((name) => {
+    if (disabled.has(name)) return false;
+    return !SERVICE_ONLY_DOMAINS.includes(name) || liveDomains.has(name);
+  });
+}
+function intersectInOrder(available, requested) {
+  const requestedSet = new Set(requested);
+  return available.filter((entry) => requestedSet.has(entry));
+}
+function freezeList(values) {
+  return Object.freeze([...values]);
+}
+function createShellReadyState() {
+  const initSent = /* @__PURE__ */ new WeakMap();
+  const sessionRegistration = /* @__PURE__ */ new Map();
+  const environments = /* @__PURE__ */ new Map();
   return {
-    domains: capabilities.domains.filter((entry) => !disabled.has(entry)),
-    protocols,
-    naps: capabilities.naps.filter((entry) => !disabled.has(entry.split(":")[0] ?? entry)),
-    sandbox: capabilities.sandbox
+    initSent,
+    sessionRegistration,
+    environments,
+    isDomainAllowed(windowId, domain) {
+      return environments.get(windowId)?.capabilities.domains.includes(domain) ?? false;
+    },
+    clear() {
+      sessionRegistration.clear();
+      environments.clear();
+    }
   };
 }
-var initSent = /* @__PURE__ */ new WeakMap();
 function handleShellReady({
   hooks,
   origin,
   runtime,
+  state,
   sourceRegistrationId,
   sourceWindow,
   windowId
 }) {
-  registerNip5dSessionIfNeeded({
-    hooks,
-    origin,
-    runtime,
-    sourceRegistrationId,
-    sourceWindow,
-    windowId
-  });
-  if (initSent.get(sourceWindow) === sourceRegistrationId) {
+  if (state.initSent.get(sourceWindow) === sourceRegistrationId) {
     return;
   }
-  const capabilities = buildShellCapabilities(hooks);
-  postShellInit(sourceWindow, capabilities, Object.keys(hooks.services ?? {}));
-  initSent.set(sourceWindow, sourceRegistrationId);
+  const identity = resolveNip5dIdentity(hooks, windowId, sourceWindow);
+  if (!identity) return;
+  registerNip5dSessionIfNeeded({ origin, runtime, state, sourceRegistrationId, windowId, identity });
+  const environment = originRegistry.getEnvironment(sourceWindow) ?? resolveShellEnvironment(hooks, identity);
+  state.environments.set(windowId, environment);
+  postShellInit(sourceWindow, environment);
+  state.initSent.set(sourceWindow, sourceRegistrationId);
 }
 function registerNip5dSessionIfNeeded({
-  hooks,
   origin,
   runtime,
-  windowId
+  state,
+  sourceRegistrationId,
+  windowId,
+  identity
 }) {
-  if (runtime.sessionRegistry.getEntryByWindowId(windowId)) {
+  const existing = runtime.sessionRegistry.getEntryByWindowId(windowId);
+  const previousRegistration = state.sessionRegistration.get(windowId);
+  if (existing && previousRegistration === sourceRegistrationId) {
     return;
   }
-  const identity = resolveNip5dIdentity(hooks, windowId);
-  if (!identity) {
-    return;
+  if (existing && previousRegistration !== void 0) {
+    runtime.sessionRegistry.unregister(windowId);
   }
+  if (existing && previousRegistration === void 0) return;
   const entry = {
     pubkey: "",
     windowId,
@@ -3422,33 +3783,30 @@ function registerNip5dSessionIfNeeded({
     provenance: "nip-5d"
   };
   runtime.sessionRegistry.register(windowId, entry);
+  state.sessionRegistration.set(windowId, sourceRegistrationId);
 }
-function resolveNip5dIdentity(hooks, windowId) {
+function resolveNip5dIdentity(hooks, windowId, sourceWindow) {
   const hookIdentity = hooks.onNip5dIframeCreate?.(windowId);
   if (hookIdentity !== null && hookIdentity !== void 0) {
-    return {
+    return Object.freeze({
       dTag: hookIdentity.dTag,
       aggregateHash: hookIdentity.aggregateHash
-    };
-  }
-  const win = originRegistry.getIframeWindow(windowId);
-  if (!win) {
-    return null;
+    });
   }
-  const originIdentity = originRegistry.getIdentity(win);
+  const originIdentity = originRegistry.getIdentity(sourceWindow);
   if (!originIdentity) {
     return null;
   }
-  return {
+  return Object.freeze({
     dTag: originIdentity.dTag,
     aggregateHash: originIdentity.aggregateHash
-  };
+  });
 }
-function postShellInit(win, capabilities, services) {
+function postShellInit(win, environment) {
   const initMsg = {
     type: "shell.init",
-    capabilities,
-    services
+    capabilities: environment.capabilities,
+    services: environment.services
   };
   win.postMessage(initMsg, "*");
 }
@@ -3462,6 +3820,7 @@ function reportUnrouted(hooks, event, reason) {
   }
 }
 function createShellBridge(hooks) {
+  const shellReadyState = createShellReadyState();
   const runtimeHooks = adaptHooks(hooks, {
     originRegistry,
     manifestCache,
@@ -3469,11 +3828,16 @@ function createShellBridge(hooks) {
     audioManager,
     nappKeyRegistry
   });
-  const runtime = createRuntime(runtimeHooks);
-  function broadcastToNapplets(envelope) {
-    const windowIds = originRegistry.getAllWindowIds();
-    for (const windowId of windowIds) {
-      const win = originRegistry.getIframeWindow(windowId);
+  const runtime = createRuntime({
+    ...runtimeHooks,
+    isDomainAllowed: shellReadyState.isDomainAllowed
+  });
+  function publishToEligibleNapplets(envelope, domain, capability) {
+    for (const entry of runtime.sessionRegistry.getAllEntries()) {
+      const environment = shellReadyState.environments.get(entry.windowId);
+      if (!environment?.capabilities.domains.includes(domain)) continue;
+      if (!runtime.aclState.check(entry.pubkey, entry.dTag, entry.aggregateHash, capability)) continue;
+      const win = originRegistry.getIframeWindow(entry.windowId);
       if (!win) continue;
       win.postMessage(envelope, "*");
     }
@@ -3497,6 +3861,7 @@ function createShellBridge(hooks) {
           hooks,
           origin: event.origin,
           runtime,
+          state: shellReadyState,
           sourceRegistrationId: originRegistry.getRegistrationId(sourceWindow) ?? 0,
           sourceWindow,
           windowId
@@ -3510,17 +3875,18 @@ function createShellBridge(hooks) {
     },
     destroy() {
       runtime.destroy();
+      shellReadyState.clear();
     },
     registerConsentHandler(handler) {
       runtime.registerConsentHandler(handler);
     },
     publishTheme(theme) {
       const envelope = { type: "theme.changed", theme };
-      broadcastToNapplets(envelope);
+      publishToEligibleNapplets(envelope, "theme", "theme:read");
     },
     publishIdentityChanged(pubkey) {
       const envelope = { type: "identity.changed", pubkey };
-      broadcastToNapplets(envelope);
+      publishToEligibleNapplets(envelope, "identity", "identity:read");
     },
     get runtime() {
       return runtime;
@@ -3582,7 +3948,7 @@ function nappletNamespacePrelude(domains) {
   function request(message, resultType, map, options = {}) {
     const requestId = message.id ?? id();
     const outbound = { ...message, id: requestId };
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve, reject2) => {
       const off = listen((event) => {
         if (!isParentMessage(event)) return;
         const incoming = event.data;
@@ -3594,18 +3960,18 @@ function nappletNamespacePrelude(domains) {
         clearTimeout(timer);
         const error = typeof msg.error === "string" ? msg.error : "";
         if (error && options.rejectOnError !== false) {
-          reject(new Error(error));
+          reject2(new Error(error));
           return;
         }
         try {
           resolve(map(msg));
         } catch (err) {
-          reject(err);
+          reject2(err);
         }
       });
       const timer = setTimeout(() => {
         off();
-        reject(new Error(`${message.type} timed out`));
+        reject2(new Error(`${message.type} timed out`));
       }, requestTimeoutMs);
       post(outbound);
     });
@@ -3613,12 +3979,47 @@ function nappletNamespacePrelude(domains) {
   function fire(message) {
     post(message);
   }
-  function resultOrError(msg) {
-    return msg;
-  }
-  function withoutEnvelope(msg) {
-    const { type: _type, id: _id, ...result2 } = msg;
-    return result2;
+  function normalizeConventionUri(topic, hasExplicitPayload) {
+    if (typeof topic !== "string") throw new TypeError("INC topic must be text");
+    if (!topic.startsWith("napplet:")) return { topic };
+    if (topic.includes("#")) throw new TypeError("Convention topics cannot contain fragments");
+    const queryStart = topic.indexOf("?");
+    if (queryStart === -1) {
+      return { topic };
+    }
+    if (hasExplicitPayload) {
+      throw new TypeError("Convention queries cannot be combined with an explicit payload");
+    }
+    const values = {};
+    const names = /* @__PURE__ */ new Set();
+    const query = topic.slice(queryStart + 1);
+    if (query) {
+      for (const pair of query.split("&")) {
+        const separator = pair.indexOf("=");
+        if (separator < 0) {
+          throw new TypeError("Convention query parameters must use name=value form");
+        }
+        let name;
+        let value;
+        try {
+          name = decodeURIComponent(pair.slice(0, separator));
+          value = decodeURIComponent(pair.slice(separator + 1));
+        } catch {
+          throw new TypeError("Convention query contains malformed percent encoding");
+        }
+        if (names.has(name)) throw new TypeError("Convention query names must be unique");
+        names.add(name);
+        values[name] = value;
+      }
+    }
+    return { topic: topic.slice(0, queryStart), payload: values };
+  }
+  function resultOrError(msg) {
+    return msg;
+  }
+  function withoutEnvelope(msg) {
+    const { type: _type, id: _id, ...result2 } = msg;
+    return result2;
   }
   function fieldOrThrow(msg, field, fallback) {
     if (Object.prototype.hasOwnProperty.call(msg, field)) return msg[field];
@@ -3652,11 +4053,13 @@ function nappletNamespacePrelude(domains) {
       if (typeof incoming !== "object" || incoming === null) return;
       const message = incoming;
       if (message.type !== "shell.init") return;
-      const services = Object.freeze(
-        Array.isArray(message.services) ? message.services.filter((service) => typeof service === "string") : []
-      );
+      const rawCapabilities = message.capabilities;
+      const rawDomains = typeof rawCapabilities === "object" && rawCapabilities !== null ? rawCapabilities.domains : void 0;
+      if (!Array.isArray(rawDomains)) return;
+      const domains2 = freezeStrings(rawDomains);
+      const services = freezeStrings(Array.isArray(message.services) ? message.services : []);
       environment = Object.freeze({
-        capabilities: message.capabilities ?? {},
+        capabilities: Object.freeze({ domains: domains2 }),
         services
       });
       off();
@@ -3664,20 +4067,18 @@ function nappletNamespacePrelude(domains) {
       for (const handler of readyHandlers) handler(environment);
       readyHandlers.clear();
     });
-    function supports(domain, protocol) {
-      if (!environment || typeof environment.capabilities !== "object" || environment.capabilities === null) {
-        return false;
-      }
-      const capabilities = environment.capabilities;
-      if (protocol !== void 0) {
-        const protocols = capabilities.protocols;
-        if (typeof protocols === "object" && protocols !== null) {
-          const supported = protocols[domain];
-          if (Array.isArray(supported) && supported.includes(protocol)) return true;
-        }
-        return Array.isArray(capabilities.naps) && capabilities.naps.includes(`${domain}:${protocol}`);
+    function freezeStrings(values) {
+      const seen = /* @__PURE__ */ new Set();
+      const strings = [];
+      for (const value of values) {
+        if (typeof value !== "string" || value.length === 0 || seen.has(value)) continue;
+        seen.add(value);
+        strings.push(value);
       }
-      return Array.isArray(capabilities.domains) && capabilities.domains.includes(domain) || Array.isArray(capabilities.naps) && capabilities.naps.includes(domain);
+      return Object.freeze(strings);
+    }
+    function supports(domain) {
+      return typeof domain === "string" && environment?.capabilities.domains.includes(domain) === true;
     }
     const shell2 = {
       ready: () => ready,
@@ -3761,38 +4162,205 @@ function nappletNamespacePrelude(domains) {
     };
   }
   function makeInc() {
-    return {
-      emit(topic, _extraTags, content) {
-        let payload = content;
-        if (typeof content === "string" && content.length > 0) {
-          try {
-            payload = JSON.parse(content);
-          } catch {
-            payload = content;
-          }
+    const topicStates = /* @__PURE__ */ new Map();
+    const maxRetainedEvents = 32;
+    const channelStates = /* @__PURE__ */ new Map();
+    const openedHandlers = /* @__PURE__ */ new Set();
+    const pendingOpened = [];
+    const unopenedEvents = /* @__PURE__ */ new Map();
+    const unopenedClosed = /* @__PURE__ */ new Map();
+    function stableSubscriptionTopic(topic) {
+      if (typeof topic !== "string") throw new TypeError("INC topic must be text");
+      if (topic.includes("?") || topic.includes("#")) {
+        throw new TypeError("INC subscriptions require a queryless topic identity");
+      }
+      return topic;
+    }
+    function closeChannelState(state, closed, notifyShell) {
+      if (state.closed) return;
+      state.closed = closed;
+      if (notifyShell) fire({ type: "inc.channel.close", channelId: state.channelId });
+      for (const handler of state.closedHandlers) handler(closed);
+    }
+    function makeChannelHandle(state) {
+      return {
+        id: state.channelId,
+        peer: state.peer,
+        emit(payload) {
+          if (state.closed) return;
+          fire({ type: "inc.channel.emit", channelId: state.channelId, ...payload === void 0 ? {} : { payload } });
+        },
+        on(handler) {
+          if (typeof handler !== "function") throw new TypeError("INC channel event handler must be a function");
+          if (state.closed) return subscriptionHandle(() => void 0);
+          state.eventHandlers.add(handler);
+          const pending = state.pendingEvents.splice(0);
+          for (const event of pending) handler(event);
+          return subscriptionHandle(() => state.eventHandlers.delete(handler));
+        },
+        onClosed(handler) {
+          if (typeof handler !== "function") throw new TypeError("INC channel close handler must be a function");
+          state.closedHandlers.add(handler);
+          if (state.closed) handler(state.closed);
+          return subscriptionHandle(() => state.closedHandlers.delete(handler));
+        },
+        close() {
+          closeChannelState(state, { channelId: state.channelId }, true);
+        }
+      };
+    }
+    function materializeChannel(channelId, peer) {
+      const existing = channelStates.get(channelId);
+      if (existing) return existing;
+      const state = {
+        channelId,
+        peer,
+        eventHandlers: /* @__PURE__ */ new Set(),
+        closedHandlers: /* @__PURE__ */ new Set(),
+        pendingEvents: unopenedEvents.get(channelId) ?? []
+      };
+      unopenedEvents.delete(channelId);
+      channelStates.set(channelId, state);
+      const closed = unopenedClosed.get(channelId);
+      unopenedClosed.delete(channelId);
+      if (closed) closeChannelState(state, closed, false);
+      return state;
+    }
+    function deliverOpened(state) {
+      const handle = makeChannelHandle(state);
+      if (openedHandlers.size > 0) {
+        for (const handler of openedHandlers) handler(handle);
+        return;
+      }
+      pendingOpened.push(state);
+    }
+    function receiveChannelEvent(channelId, sender, payloadPresent, payload) {
+      const event = payloadPresent ? { channelId, sender, payload } : { channelId, sender };
+      const state = channelStates.get(channelId);
+      if (!state) {
+        const pending = unopenedEvents.get(channelId) ?? [];
+        if (pending.length >= maxRetainedEvents) {
+          unopenedEvents.delete(channelId);
+          unopenedClosed.set(channelId, { channelId, reason: "buffer overflow" });
+          fire({ type: "inc.channel.close", channelId });
+          return;
         }
-        fire({ type: "inc.emit", topic, ...payload === void 0 || payload === "" ? {} : { payload } });
+        pending.push(event);
+        unopenedEvents.set(channelId, pending);
+        return;
+      }
+      if (state.closed) return;
+      if (state.eventHandlers.size > 0) {
+        for (const handler of state.eventHandlers) handler(event);
+        return;
+      }
+      if (state.pendingEvents.length >= maxRetainedEvents) {
+        closeChannelState(state, { channelId, reason: "buffer overflow" }, true);
+        return;
+      }
+      state.pendingEvents.push(event);
+    }
+    listen((event) => {
+      if (!isParentMessage(event)) return;
+      const msg = event.data;
+      if (typeof msg !== "object" || msg === null || typeof msg.type !== "string") return;
+      if (msg.type === "inc.channel.opened" && typeof msg.channelId === "string" && typeof msg.peer === "string") {
+        deliverOpened(materializeChannel(msg.channelId, msg.peer));
+        return;
+      }
+      if (msg.type === "inc.channel.event" && typeof msg.channelId === "string" && typeof msg.sender === "string") {
+        receiveChannelEvent(msg.channelId, msg.sender, Object.prototype.hasOwnProperty.call(msg, "payload"), msg.payload);
+        return;
+      }
+      if (msg.type === "inc.channel.closed" && typeof msg.channelId === "string") {
+        const closed = typeof msg.reason === "string" ? { channelId: msg.channelId, reason: msg.reason } : { channelId: msg.channelId };
+        const state = channelStates.get(msg.channelId);
+        if (state) closeChannelState(state, closed, false);
+        else unopenedClosed.set(msg.channelId, closed);
+      }
+    });
+    return {
+      emit(topic, payload) {
+        const transposed = normalizeConventionUri(topic, arguments.length > 1);
+        fire({
+          type: "inc.emit",
+          topic: transposed.topic,
+          ...transposed.payload === void 0 && payload === void 0 ? {} : { payload: transposed.payload ?? payload }
+        });
       },
       on(topic, callback) {
-        const off = listen((event) => {
-          if (!isParentMessage(event)) return;
-          const msg = event.data;
-          if (typeof msg !== "object" || msg === null || msg.type !== "inc.event" || msg.topic !== topic) return;
-          callback(msg.payload ?? {}, {
-            id: "",
-            pubkey: typeof msg.sender === "string" ? msg.sender : "",
-            created_at: Math.floor(Date.now() / 1e3),
-            kind: 0,
-            tags: [["t", topic]],
-            content: typeof msg.payload === "string" ? msg.payload : JSON.stringify(msg.payload ?? {}),
-            sig: ""
+        const stableTopic = stableSubscriptionTopic(topic);
+        if (typeof callback !== "function") throw new TypeError("INC subscription handler must be a function");
+        let state = topicStates.get(stableTopic);
+        if (!state) {
+          const handlers = /* @__PURE__ */ new Set();
+          const subscriptionId = id();
+          const offEvent = listen((event) => {
+            if (!isParentMessage(event)) return;
+            const msg = event.data;
+            if (typeof msg !== "object" || msg === null || msg.type !== "inc.event" || msg.topic !== stableTopic || typeof msg.sender !== "string") return;
+            const delivered = Object.prototype.hasOwnProperty.call(msg, "payload") ? { topic: stableTopic, sender: msg.sender, payload: msg.payload } : { topic: stableTopic, sender: msg.sender };
+            for (const handler of handlers) handler(delivered);
           });
-        });
-        fire({ type: "inc.subscribe", id: id(), topic });
+          const offResult = listen((event) => {
+            if (!isParentMessage(event)) return;
+            const msg = event.data;
+            if (typeof msg !== "object" || msg === null || msg.type !== "inc.subscribe.result" || msg.id !== subscriptionId) return;
+            offResult();
+            if (typeof msg.error === "string" && msg.error) {
+              offEvent();
+              topicStates.delete(stableTopic);
+            }
+          });
+          state = { handlers, offEvent, offResult };
+          topicStates.set(stableTopic, state);
+          fire({ type: "inc.subscribe", id: subscriptionId, topic: stableTopic });
+        }
+        state.handlers.add(callback);
         return subscriptionHandle(() => {
-          fire({ type: "inc.unsubscribe", topic });
-          off();
+          const current = topicStates.get(stableTopic);
+          if (!current) return;
+          current.handlers.delete(callback);
+          if (current.handlers.size !== 0) return;
+          current.offEvent();
+          current.offResult();
+          topicStates.delete(stableTopic);
+          fire({ type: "inc.unsubscribe", topic: stableTopic });
         });
+      },
+      channel: {
+        open(targetDTag) {
+          return request(
+            { type: "inc.channel.open", target: targetDTag },
+            "inc.channel.open.result",
+            (msg) => {
+              if (typeof msg.channelId !== "string" || typeof msg.peer !== "string") {
+                throw new Error("inc.channel.open.result missing channel identity");
+              }
+              return makeChannelHandle(materializeChannel(msg.channelId, msg.peer));
+            }
+          );
+        },
+        onOpened(handler) {
+          if (typeof handler !== "function") throw new TypeError("INC opened handler must be a function");
+          openedHandlers.add(handler);
+          const pending = pendingOpened.splice(0);
+          for (const state of pending) handler(makeChannelHandle(state));
+          return subscriptionHandle(() => openedHandlers.delete(handler));
+        },
+        list() {
+          return request(
+            { type: "inc.channel.list" },
+            "inc.channel.list.result",
+            (msg) => Object.freeze((Array.isArray(msg.channels) ? msg.channels : []).flatMap((channel) => channel && typeof channel === "object" && typeof channel.id === "string" && typeof channel.peer === "string" ? [Object.freeze({
+              id: channel.id,
+              peer: channel.peer
+            })] : []))
+          );
+        },
+        broadcast(payload) {
+          fire({ type: "inc.channel.broadcast", ...payload === void 0 ? {} : { payload } });
+        }
       }
     };
   }
@@ -3830,14 +4398,22 @@ function nappletNamespacePrelude(domains) {
     return { ...makeScope(), instance: makeScope("instance") };
   }
   function makeIdentity() {
-    const read = (type, field, fallback) => request(
-      { type },
+    const read = (type, field, fallback, payload = {}) => request(
+      { type, ...payload },
       `${type}.result`,
       (msg) => Object.prototype.hasOwnProperty.call(msg, field) ? msg[field] : fallback,
       { rejectOnError: type !== "identity.getPublicKey" }
     );
-    return {
+    return Object.freeze({
       getPublicKey: () => read("identity.getPublicKey", "pubkey", ""),
+      getRelays: () => read("identity.getRelays", "relays", {}),
+      getProfile: () => read("identity.getProfile", "profile", null),
+      getFollows: () => read("identity.getFollows", "pubkeys", []),
+      getList: (listType) => read("identity.getList", "entries", [], { listType }),
+      getZaps: () => read("identity.getZaps", "zaps", []),
+      getMutes: () => read("identity.getMutes", "pubkeys", []),
+      getBlocked: () => read("identity.getBlocked", "pubkeys", []),
+      getBadges: () => read("identity.getBadges", "badges", []),
       onChanged(handler) {
         const off = listen((event) => {
           if (!isParentMessage(event)) return;
@@ -3846,20 +4422,8 @@ function nappletNamespacePrelude(domains) {
           if (typeof msg.pubkey === "string") handler(msg.pubkey);
         });
         return subscriptionHandle(off);
-      },
-      getRelays: () => read("identity.getRelays", "relays", {}),
-      getProfile: () => read("identity.getProfile", "profile", null),
-      getFollows: () => read("identity.getFollows", "pubkeys", []),
-      getList: (listType) => request(
-        { type: "identity.getList", listType },
-        "identity.getList.result",
-        (msg) => Array.isArray(msg.entries) ? msg.entries : []
-      ),
-      getZaps: () => read("identity.getZaps", "zaps", []),
-      getMutes: () => read("identity.getMutes", "pubkeys", []),
-      getBlocked: () => read("identity.getBlocked", "pubkeys", []),
-      getBadges: () => read("identity.getBadges", "badges", [])
-    };
+      }
+    });
   }
   function makeTheme() {
     return {
@@ -4298,18 +4862,69 @@ function nappletNamespacePrelude(domains) {
     };
   }
   function makeIntent() {
-    const invoke = (requestPayload) => request(
-      { type: "intent.invoke", request: requestPayload },
-      "intent.invoke.result",
-      (msg) => fieldOrThrow(msg, "result", "intent.invoke.result missing result")
-    );
+    const hasOwn2 = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+    const normalizeRequest = (value) => {
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new TypeError("Intent request must be an object");
+      }
+      const supplied = value;
+      if (hasOwn2(supplied, "sender")) {
+        throw new TypeError("Intent callers cannot supply sender");
+      }
+      const allowed22 = ["archetype", "action", "convention", "payload", "handler", "behavior"];
+      if (Object.keys(supplied).some((field) => !allowed22.includes(field))) {
+        throw new TypeError("Intent request contains unsupported fields");
+      }
+      if (typeof supplied.archetype !== "string" || supplied.archetype.length === 0) {
+        throw new TypeError("Intent request requires an archetype");
+      }
+      const action = supplied.action === void 0 ? "open" : supplied.action;
+      if (typeof action !== "string" || action.length === 0) {
+        throw new TypeError("Intent action must be a non-empty string");
+      }
+      if (supplied.convention !== void 0 && (typeof supplied.convention !== "string" || !/^napplet:[^/?#\s]+\/[^/?#\s]+$/.test(supplied.convention))) {
+        throw new TypeError("Intent convention must be queryless");
+      }
+      if (supplied.handler !== void 0 && (typeof supplied.handler !== "string" || supplied.handler.length === 0)) {
+        throw new TypeError("Intent handler must be a non-empty string");
+      }
+      const behaviorValue = supplied?.behavior;
+      const behavior = behaviorValue && typeof behaviorValue === "object" ? behaviorValue : void 0;
+      if (behaviorValue !== void 0 && (!behavior || Array.isArray(behaviorValue) || Object.keys(behavior).some((field) => field !== "focus" && field !== "newWindow" && field !== "reuse") || hasOwn2(behavior, "focus") && typeof behavior.focus !== "boolean" || hasOwn2(behavior, "newWindow") && typeof behavior.newWindow !== "boolean" || hasOwn2(behavior, "reuse") && typeof behavior.reuse !== "boolean")) {
+        throw new TypeError("Intent behavior contains unsupported fields");
+      }
+      const sanitizedBehavior = {
+        ...typeof behavior?.focus === "boolean" ? { focus: behavior.focus } : {},
+        ...typeof behavior?.newWindow === "boolean" ? { newWindow: behavior.newWindow } : {},
+        ...typeof behavior?.reuse === "boolean" ? { reuse: behavior.reuse } : {}
+      };
+      return {
+        archetype: supplied.archetype,
+        action,
+        ...typeof supplied.convention === "string" ? { convention: supplied.convention } : {},
+        ...hasOwn2(supplied, "payload") ? { payload: supplied.payload } : {},
+        ...typeof supplied.handler === "string" ? { handler: supplied.handler } : {},
+        ...Object.keys(sanitizedBehavior).length === 0 ? {} : { behavior: sanitizedBehavior }
+      };
+    };
+    const invoke = (value) => {
+      const normalized = normalizeRequest(value);
+      return request(
+        {
+          type: "intent.invoke",
+          request: normalized
+        },
+        "intent.invoke.result",
+        (msg) => fieldOrThrow(msg, "result", "intent.invoke.result missing result")
+      );
+    };
     return {
       invoke,
       open: (archetype, payload, opts) => invoke({
         archetype,
         action: "open",
-        payload,
-        ...opts && typeof opts === "object" ? opts : {}
+        ...payload === void 0 ? {} : { payload },
+        ...opts
       }),
       available: (archetype) => request(
         { type: "intent.available", archetype },
@@ -4460,14 +5075,40 @@ function nappletNamespacePrelude(domains) {
     };
   }
   const shell = makeShell();
+  let inc;
+  let identity;
+  let theme;
+  let intent;
+  function makeProtectedInc(existing) {
+    const extensions = existing && typeof existing === "object" ? existing : {};
+    inc ??= makeInc();
+    return { ...extensions, ...inc };
+  }
+  function makeProtectedIdentity() {
+    identity ??= makeIdentity();
+    return identity;
+  }
+  function makeProtectedTheme() {
+    theme ??= Object.freeze(makeTheme());
+    return theme;
+  }
+  function makeProtectedIntent() {
+    intent ??= Object.freeze(makeIntent());
+    return intent;
+  }
+  function isProtectedDomain(domain) {
+    return domain === "shell" || domain === "inc" || domain === "identity" || domain === "theme" || domain === "intent";
+  }
   function makeDomain(domain, existing) {
     if (domain === "shell") return shell;
+    if (domain === "inc") return makeProtectedInc(existing);
+    if (domain === "identity") return makeProtectedIdentity();
+    if (domain === "theme") return makeProtectedTheme();
+    if (domain === "intent") return makeProtectedIntent();
     if (existing && typeof existing === "object" && Object.keys(existing).length > 0) return existing;
     switch (domain) {
       case "relay":
         return makeRelay();
-      case "inc":
-        return makeInc();
       case "storage":
         return makeStorage();
       case "keys":
@@ -4476,10 +5117,6 @@ function nappletNamespacePrelude(domains) {
         return makeMedia();
       case "notify":
         return makeNotify();
-      case "identity":
-        return makeIdentity();
-      case "theme":
-        return makeTheme();
       case "config":
         return makeConfig();
       case "resource":
@@ -4490,8 +5127,6 @@ function nappletNamespacePrelude(domains) {
         return makeOutbox();
       case "upload":
         return makeUpload();
-      case "intent":
-        return makeIntent();
       case "webrtc":
         return makeWebrtc();
       case "ble":
@@ -4521,10 +5156,22 @@ function nappletNamespacePrelude(domains) {
       },
       defineProperty(obj, prop, descriptor) {
         if (typeof prop !== "string" || !allowed2.has(prop)) return true;
+        if (isProtectedDomain(prop)) {
+          return Reflect.defineProperty(obj, prop, {
+            value: makeDomain(prop, descriptor.value),
+            enumerable: true,
+            configurable: true,
+            writable: true
+          });
+        }
         return Reflect.defineProperty(obj, prop, {
           ...descriptor,
           value: makeDomain(prop, descriptor.value)
         });
+      },
+      deleteProperty(obj, prop) {
+        if (typeof prop === "string" && allowed2.has(prop) && isProtectedDomain(prop)) return true;
+        return Reflect.deleteProperty(obj, prop);
       }
     });
   }
@@ -4554,7 +5201,7 @@ function nappletNamespacePrelude(domains) {
       root = buildNappletNamespace(value);
     },
     enumerable: false,
-    configurable: true
+    configurable: false
   });
 }
 
@@ -8159,14 +8806,11 @@ function enforceLimit(store2, list) {
     list.shift();
   }
 }
-function findById(store2, id) {
-  for (const [windowId, list] of store2.notifications) {
-    const index = list.findIndex((n) => n.id === id);
-    if (index !== -1) {
-      return [windowId, list[index], index];
-    }
-  }
-  return void 0;
+function findById(store2, windowId, id) {
+  const list = store2.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(store2, windowId, title, body) {
   const notification = {
@@ -8183,20 +8827,20 @@ function createNotification(store2, windowId, title, body) {
   notify(store2);
   return notification;
 }
-function dismissNotification(store2, id) {
-  const found = findById(store2, id);
+function dismissNotification(store2, windowId, id) {
+  const found = findById(store2, windowId, id);
   if (!found) return;
-  const [foundWindowId, , index] = found;
-  const list = store2.notifications.get(foundWindowId);
+  const [, index] = found;
+  const list = store2.notifications.get(windowId);
   if (!list) return;
   list.splice(index, 1);
-  if (list.length === 0) store2.notifications.delete(foundWindowId);
+  if (list.length === 0) store2.notifications.delete(windowId);
   notify(store2);
 }
-function markNotificationRead(store2, id) {
-  const found = findById(store2, id);
+function markNotificationRead(store2, windowId, id) {
+  const found = findById(store2, windowId, id);
   if (!found) return;
-  const [, notification] = found;
+  const [notification] = found;
   if (!notification.read) {
     notification.read = true;
     notify(store2);
@@ -8213,12 +8857,12 @@ function handleNotifyEnvelope(store2, windowId, action, msg, send) {
     }
     case "dismiss": {
       const notifId = typeof msg.notificationId === "string" ? msg.notificationId : "";
-      if (notifId) dismissNotification(store2, notifId);
+      if (notifId) dismissNotification(store2, windowId, notifId);
       break;
     }
     case "read": {
       const notifId = typeof msg.notificationId === "string" ? msg.notificationId : "";
-      if (notifId) markNotificationRead(store2, notifId);
+      if (notifId) markNotificationRead(store2, windowId, notifId);
       break;
     }
     case "list": {
@@ -8230,34 +8874,6 @@ function handleNotifyEnvelope(store2, windowId, action, msg, send) {
       break;
   }
 }
-function handleIncNotification(store2, 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(store2, 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(store2, id);
-      break;
-    }
-    case "read": {
-      const id = typeof payload.id === "string" ? payload.id : "";
-      if (id) markNotificationRead(store2, id);
-      break;
-    }
-    case "list": {
-      const windowNotifs = store2.notifications.get(windowId) ?? [];
-      send({ type: "inc.event", topic: "notifications:listed", payload: { notifications: windowNotifs } });
-      break;
-    }
-    default:
-      break;
-  }
-}
 function createNotificationService(options) {
   const store2 = {
     notifications: /* @__PURE__ */ new Map(),
@@ -8265,23 +8881,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(store2, 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(store2, windowId, topic.slice(14), payload, send);
+      if (!message.type.startsWith("notify.")) return;
+      handleNotifyEnvelope(
+        store2,
+        windowId,
+        message.type.slice(7),
+        message,
+        send
+      );
     },
     onWindowDestroyed(windowId) {
       if (store2.notifications.delete(windowId)) {
@@ -8291,16 +8905,16 @@ function createNotificationService(options) {
   };
 }
 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 "";
@@ -8313,46 +8927,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) {
@@ -8361,11 +8958,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;
@@ -8374,11 +8971,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;
@@ -8390,11 +8987,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;
@@ -8403,11 +9000,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;
@@ -8416,11 +9013,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;
@@ -8429,11 +9026,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;
@@ -8446,11 +9043,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
   );
 }
@@ -8464,9 +9061,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) {
@@ -8487,6 +9082,37 @@ function createIdentityService(options) {
 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",
@@ -8546,17 +9172,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;
       }
     },
@@ -9488,8 +10108,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,
@@ -9508,19 +10135,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;
   }
@@ -11071,42 +11694,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;
@@ -11116,7 +11829,7 @@ function createIntentService(options) {
       return;
     }
     const archetype = m.archetype;
-    settle6(
+    settleResolverCall(
       () => resolver.available(archetype),
       send,
       "intent.available.result",
@@ -11127,7 +11840,7 @@ function createIntentService(options) {
   function handleHandlers(msg, send) {
     const m = msg;
     const id = m.id ?? "";
-    settle6(
+    settleResolverCall(
       () => resolver.handlers(),
       send,
       "intent.handlers.result",
@@ -11137,8 +11850,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);
@@ -11152,12 +11888,196 @@ function createIntentService(options) {
         default:
           return;
       }
-    },
-    onWindowDestroyed(windowId) {
-      windows.delete(windowId);
     }
   };
 }
+function candidatesFor(catalog, archetype, defaultHandler) {
+  const candidates = [];
+  for (const entry of catalog) {
+    const support = entry.archetypes[archetype];
+    if (!support) continue;
+    candidates.push({
+      dTag: entry.dTag,
+      ...entry.title === void 0 ? {} : { title: entry.title },
+      actions: [...support.actions],
+      conventions: [...support.conventions],
+      ...entry.dTag === defaultHandler ? { isDefault: true } : {}
+    });
+  }
+  return candidates;
+}
+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.targets || typeof options.targets.dispatch !== "function") {
+    throw new Error("createCatalogIntentResolver: options.targets is required");
+  }
+  const listeners = /* @__PURE__ */ new Set();
+  const availabilityFor = (archetype) => availabilityForCatalog(options, archetype);
+  async function handlers() {
+    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((archetype) => availabilityFor(archetype)));
+  }
+  return {
+    invoke: (request, context) => invokeFromCatalog(options, request, context),
+    available: availabilityFor,
+    handlers,
+    onChanged(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    notifyChanged(archetype) {
+      if (listeners.size === 0) return;
+      void availabilityFor(archetype).then((availability) => {
+        for (const listener of listeners) listener(availability);
+      });
+    }
+  };
+}
+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, 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,
+    ...manifest.title === void 0 ? {} : { title: manifest.title },
+    archetypes
+  };
+}
 var CVM_SERVICE_VERSION = "1.0.0";
 var CVM_DESCRIPTOR = {
   name: "cvm",
@@ -12148,6 +13068,193 @@ function createDevWebrtcController() {
   };
 }
 
+// src/browser-intent-controller.ts
+var MAX_INTENT_DELIVERY_ATTEMPTS = 10;
+var BrowserIntentController = class {
+  constructor(options) {
+    this.options = options;
+    this.maxAttempts = normalizeAttempts(options.maxAttempts);
+  }
+  options;
+  maxAttempts;
+  async dispatch(params) {
+    const dispatch2 = freezeDispatch(params);
+    let reason = "no-current-target";
+    for (let attempt = 1; attempt <= this.maxAttempts; attempt += 1) {
+      let generation;
+      try {
+        generation = await this.options.openOrReuse(dispatch2, attempt);
+      } catch {
+        reason = "open-failed";
+        continue;
+      }
+      if (!generation) {
+        reason = "open-failed";
+        continue;
+      }
+      try {
+        await this.options.waitForReady(generation);
+      } catch {
+        reason = "ready-failed";
+        continue;
+      }
+      if (!await this.options.isCurrent(generation)) {
+        reason = "no-current-target";
+        continue;
+      }
+      try {
+        await this.options.send(generation, dispatch2);
+        const windowId = this.options.getWindowId(generation);
+        if (!windowId) throw new Error("intent target window is unavailable");
+        return { windowId };
+      } catch {
+        this.options.onTerminal?.(dispatch2, "send-failed");
+        throw new Error("intent target send failed");
+      }
+    }
+    this.options.onTerminal?.(dispatch2, reason);
+    throw new Error(`intent target ${reason}`);
+  }
+};
+function normalizeAttempts(value) {
+  if (value === void 0) return 2;
+  if (!Number.isFinite(value)) throw new TypeError("maxAttempts must be finite");
+  return Math.min(MAX_INTENT_DELIVERY_ATTEMPTS, Math.max(1, Math.floor(value)));
+}
+function freezeDispatch(params) {
+  if (!params || typeof params.handler !== "string" || params.handler.length === 0) {
+    throw new TypeError("Intent dispatch requires a handler");
+  }
+  if (typeof params.sender !== "string" || params.sender.length === 0 || typeof params.archetype !== "string" || params.archetype.length === 0 || typeof params.action !== "string" || params.action.length === 0 || typeof params.convention !== "string" || params.convention.length === 0) {
+    throw new TypeError("Intent dispatch requires canonical routing fields");
+  }
+  const payload = freezeValue(params.payload);
+  const behavior = params.behavior === void 0 ? void 0 : freezeValue({ ...params.behavior });
+  return Object.freeze({
+    handler: params.handler,
+    sender: params.sender,
+    archetype: params.archetype,
+    action: params.action,
+    convention: params.convention,
+    ...params.payload === void 0 ? {} : { payload },
+    ...behavior === void 0 ? {} : { behavior }
+  });
+}
+function freezeValue(value, seen = /* @__PURE__ */ new WeakMap()) {
+  if (typeof value !== "object" || value === null) return value;
+  const existing = seen.get(value);
+  if (existing !== void 0) return existing;
+  if (Array.isArray(value)) {
+    const copy2 = [];
+    seen.set(value, copy2);
+    for (const item of value) copy2.push(freezeValue(item, seen));
+    return Object.freeze(copy2);
+  }
+  const copy = {};
+  seen.set(value, copy);
+  for (const [key, item] of Object.entries(value)) copy[key] = freezeValue(item, seen);
+  return Object.freeze(copy);
+}
+
+// src/installed-napplet-catalog.ts
+function matchesInstalledNappletRecord(record, target) {
+  return target.dTag === record.dTag && target.aggregateHash === record.aggregateHash;
+}
+var InstalledNappletCatalog = class {
+  records = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  /** Insert or replace a record from an already resolver-verified pointer. */
+  install(resolved) {
+    const record = freezeRecord({
+      dTag: resolved.dTag,
+      aggregateHash: resolved.aggregateHash,
+      pointer: copyPointer(resolved.pointer),
+      ...resolved.manifest.title === void 0 ? {} : { title: resolved.manifest.title },
+      requires: [...resolved.manifest.requires],
+      archetypes: resolved.manifest.archetypes.map((archetype) => ({
+        slug: archetype.slug,
+        convention: archetype.convention
+      }))
+    });
+    this.records.set(record.dTag, record);
+    this.notify(record.dTag);
+    return record;
+  }
+  /** Remove an artifact explicitly; frame teardown never calls this method. */
+  remove(dTag) {
+    const removed = this.records.delete(dTag);
+    if (removed) this.notify(dTag);
+    return removed;
+  }
+  /** Return whether a verified installation exists for a d-tag. */
+  has(dTag) {
+    return this.records.has(dTag);
+  }
+  /** Return immutable serializable installed-artifact facts. */
+  installed() {
+    return [...this.records.values()];
+  }
+  /** Return a verified record by d-tag. */
+  get(dTag) {
+    return this.records.get(dTag);
+  }
+  /**
+   * Atomically confirm that a resolved target still belongs to the exact record
+   * selected before an async operation. The record object is the catalog version
+   * token, so even a same-identity replacement cannot pass this check.
+   */
+  validateCurrent(selected, target) {
+    if (this.records.get(selected.dTag) !== selected) return null;
+    return matchesInstalledNappletRecord(selected, target) ? selected : null;
+  }
+  /** Return exact handler candidates derived only from installed manifests. */
+  intentCatalog() {
+    return this.installed().filter((record) => record.requires.includes("inc")).map((record) => manifestToIntentCatalogEntry({
+      dTag: record.dTag,
+      ...record.title === void 0 ? {} : { title: record.title },
+      archetypes: record.archetypes.map((archetype) => ({
+        slug: archetype.slug,
+        convention: archetype.convention
+      }))
+    }));
+  }
+  /** Subscribe to explicit install and artifact-removal changes. */
+  onChanged(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  notify(dTag) {
+    for (const listener of this.listeners) listener(dTag);
+  }
+};
+function copyPointer(pointer) {
+  if (pointer.type === "naddr") {
+    return Object.freeze({
+      type: "naddr",
+      value: pointer.value,
+      identifier: pointer.identifier,
+      pubkey: pointer.pubkey,
+      kind: pointer.kind,
+      relays: Object.freeze([...pointer.relays])
+    });
+  }
+  return Object.freeze({
+    type: "nevent",
+    value: pointer.value,
+    id: pointer.id,
+    ...pointer.author === void 0 ? {} : { author: pointer.author },
+    ...pointer.kind === void 0 ? {} : { kind: pointer.kind },
+    relays: Object.freeze([...pointer.relays])
+  });
+}
+function freezeRecord(record) {
+  return Object.freeze({
+    ...record,
+    requires: Object.freeze([...record.requires]),
+    archetypes: Object.freeze(record.archetypes.map((archetype) => Object.freeze({ ...archetype })))
+  });
+}
+
 // src/simulation.ts
 var PajaSimulationError = class extends Error {
   constructor(message) {
@@ -12725,10 +13832,10 @@ var AbstractRelay = class {
     this.challenge = void 0;
     this.authPromise = void 0;
     this.skipReconnection = false;
-    this.connectionPromise = new Promise((resolve, reject) => {
+    this.connectionPromise = new Promise((resolve, reject2) => {
       if (opts?.timeout) {
         connectionTimeoutHandle = setTimeout(() => {
-          reject("connection timed out");
+          reject2("connection timed out");
           this.connectionPromise = void 0;
           this.skipReconnection = true;
           this.onclose?.();
@@ -12736,13 +13843,13 @@ var AbstractRelay = class {
         }, opts.timeout);
       }
       if (opts?.abort) {
-        opts.abort.onabort = reject;
+        opts.abort.onabort = reject2;
       }
       try {
         this.ws = new this._WebSocket(this.url);
       } catch (err) {
         clearTimeout(connectionTimeoutHandle);
-        reject(err);
+        reject2(err);
         return;
       }
       this.ws.onopen = () => {
@@ -12772,7 +13879,7 @@ var AbstractRelay = class {
       };
       this.ws.onerror = () => {
         clearTimeout(connectionTimeoutHandle);
-        reject("connection failed");
+        reject2("connection failed");
         this.connectionPromise = void 0;
         this.skipReconnection = true;
         this.onclose?.();
@@ -12780,7 +13887,7 @@ var AbstractRelay = class {
       };
       this.ws.onclose = (ev) => {
         clearTimeout(connectionTimeoutHandle);
-        reject(ev.message || "websocket closed");
+        reject2(ev.message || "websocket closed");
         this.handleHardClose("relay connection closed");
       };
       this.ws.onmessage = this._onmessage.bind(this);
@@ -12795,9 +13902,9 @@ var AbstractRelay = class {
     });
   }
   waitForDummyReq() {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve, reject2) => {
       if (!this.connectionPromise)
-        return reject(new Error(`no connection to ${this.url}, can't ping`));
+        return reject2(new Error(`no connection to ${this.url}, can't ping`));
       try {
         const sub = this.subscribe(
           [{ ids: ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"], limit: 0 }],
@@ -12814,7 +13921,7 @@ var AbstractRelay = class {
           }
         );
       } catch (err) {
-        reject(err);
+        reject2(err);
       }
     });
   }
@@ -12844,7 +13951,7 @@ var AbstractRelay = class {
       throw new Error("can't perform auth, no challenge was received");
     if (this.authPromise)
       return this.authPromise;
-    this.authPromise = new Promise(async (resolve, reject) => {
+    this.authPromise = new Promise(async (resolve, reject2) => {
       try {
         let evt = await signAuthEvent(makeAuthEvent(this.url, challenge2));
         let timeout = setTimeout(() => {
@@ -12854,7 +13961,7 @@ var AbstractRelay = class {
             this.openEventPublishes.delete(evt.id);
           }
         }, this.publishTimeout);
-        this.openEventPublishes.set(evt.id, { resolve, reject, timeout });
+        this.openEventPublishes.set(evt.id, { resolve, reject: reject2, timeout });
         this.send('["AUTH",' + JSON.stringify(evt) + "]");
       } catch (err) {
         console.warn("subscribe auth function failed:", err);
@@ -12865,7 +13972,7 @@ var AbstractRelay = class {
   async publish(event) {
     this.idleSince = void 0;
     this.ongoingOperations++;
-    const ret = new Promise((resolve, reject) => {
+    const ret = new Promise((resolve, reject2) => {
       const timeout = setTimeout(() => {
         const ep = this.openEventPublishes.get(event.id);
         if (ep) {
@@ -12873,7 +13980,7 @@ var AbstractRelay = class {
           this.openEventPublishes.delete(event.id);
         }
       }, this.publishTimeout);
-      this.openEventPublishes.set(event.id, { resolve, reject, timeout });
+      this.openEventPublishes.set(event.id, { resolve, reject: reject2, timeout });
     });
     this.send('["EVENT",' + JSON.stringify(event) + "]");
     this.ongoingOperations--;
@@ -12884,8 +13991,8 @@ var AbstractRelay = class {
   async count(filters, params) {
     this.serial++;
     const id = params?.id || "count:" + this.serial;
-    const ret = new Promise((resolve, reject) => {
-      this.openCountRequests.set(id, { resolve, reject });
+    const ret = new Promise((resolve, reject2) => {
+      this.openCountRequests.set(id, { resolve, reject: reject2 });
     });
     this.send('["COUNT","' + id + '",' + JSON.stringify(filters).substring(1));
     return ret;
@@ -13472,9 +14579,8 @@ async function publishLive(pool, relayUrls, event) {
   const results = await Promise.allSettled(pool.publish(relayUrls, event));
   return Object.fromEntries(relayUrls.map((relayUrl, index) => [relayUrl, results[index]?.status === "fulfilled"]));
 }
-function createPajaRelayBackend(getSimulation, confirmRequest) {
+function createPajaRelayBackend(getSimulation, confirmRequest, livePool = new SimplePool()) {
   const events = getSimulation().relay.fixtures.flatMap(toNostrEvent);
-  const livePool = new SimplePool();
   const subscribers = /* @__PURE__ */ new Set();
   const isAvailable = () => getSimulation().relay.mode !== "disabled" && getPajaRelayUrls(getSimulation()).length > 0;
   const query = async (relayUrls, filters, maxWaitMs) => {
@@ -13485,6 +14591,28 @@ function createPajaRelayBackend(getSimulation, confirmRequest) {
     for (const event of [...memoryEvents, ...liveEvents]) out.set(event.id, event);
     return [...out.values()].sort((a, b) => b.created_at - a.created_at);
   };
+  function retainPublishedEvent(event) {
+    events.push(event);
+    for (const subscriber of subscribers) {
+      if (matchesAnyFilter2(event, subscriber.filters)) subscriber.next(event);
+    }
+  }
+  async function attemptPublish(relayUrls, event) {
+    const simulation = getSimulation();
+    const rejected = Object.fromEntries(relayUrls.map((url) => [url, false]));
+    if (simulation.relay.mode === "disabled") {
+      return { outcomes: rejected, error: "relay unavailable" };
+    }
+    if (!confirmRequest({ action: "publish", event })) {
+      return { outcomes: rejected, error: "publish denied" };
+    }
+    const outcomes = simulation.relay.mode === "live" ? await publishLive(livePool, relayUrls, event) : Object.fromEntries(relayUrls.map((url) => [url, true]));
+    if (!Object.values(outcomes).some(Boolean)) {
+      return { outcomes, error: "publish failed" };
+    }
+    retainPublishedEvent(event);
+    return { outcomes };
+  }
   const backend = {
     subscription(relayUrls, filtersInput) {
       return {
@@ -13509,16 +14637,9 @@ function createPajaRelayBackend(getSimulation, confirmRequest) {
         }
       };
     },
-    publish(relayUrls, event) {
-      if (getSimulation().relay.mode === "disabled") return;
-      if (!confirmRequest({ action: "publish", event })) return;
-      events.push(event);
-      for (const subscriber of subscribers) {
-        if (matchesAnyFilter2(event, subscriber.filters)) subscriber.next(event);
-      }
-      if (getSimulation().relay.mode === "live") {
-        void publishLive(livePool, relayUrls, event);
-      }
+    async publish(relayUrls, event) {
+      const attempt = await attemptPublish(relayUrls, event);
+      if (attempt.error) throw new Error(attempt.error);
     },
     request(relayUrls, filtersInput) {
       return {
@@ -13538,14 +14659,7 @@ function createPajaRelayBackend(getSimulation, confirmRequest) {
     },
     query,
     async publishToRelays(relayUrls, event) {
-      if (getSimulation().relay.mode === "disabled") return Object.fromEntries(relayUrls.map((url) => [url, false]));
-      if (!confirmRequest({ action: "publish", event })) return Object.fromEntries(relayUrls.map((url) => [url, false]));
-      events.push(event);
-      for (const subscriber of subscribers) {
-        if (matchesAnyFilter2(event, subscriber.filters)) subscriber.next(event);
-      }
-      if (getSimulation().relay.mode !== "live") return Object.fromEntries(relayUrls.map((url) => [url, true]));
-      return publishLive(livePool, relayUrls, event);
+      return (await attemptPublish(relayUrls, event)).outcomes;
     },
     isAvailable,
     close() {
@@ -13666,7 +14780,6 @@ function createPajaIdentityProviders(backend, getSimulation, signerProvider) {
 }
 
 // src/browser-adapter.ts
-var DEV_INTENT_ARCHETYPE = "paja-target";
 var DEV_COMMON_PUBKEY = "1".repeat(64);
 var DEV_COMMON_EVENT_ID = "2".repeat(64);
 var DEV_SIGNER_SECRET_KEY = generateSecretKey();
@@ -13693,10 +14806,14 @@ function createRelayHooks(pool, getSimulation) {
     },
     closeScopedRelay: () => {
     },
-    publishToScopedRelay: (_windowId, event) => {
+    publishToScopedRelay: async (_windowId, event) => {
       if (getSimulation().relay.mode === "disabled") return false;
-      pool.publish(getPajaRelayUrls(getSimulation()), event);
-      return true;
+      try {
+        await pool.publish(getPajaRelayUrls(getSimulation()), event);
+        return true;
+      } catch {
+        return false;
+      }
     },
     selectRelayTier: () => getPajaRelayUrls(getSimulation())
   };
@@ -13749,18 +14866,16 @@ function createDevUploader(getSimulation) {
     }
   };
 }
-function createDevIntentAvailability() {
+function createDefaultIntentHost() {
   return {
-    archetype: DEV_INTENT_ARCHETYPE,
-    available: true,
-    hasDefault: true,
-    candidates: [{
-      dTag: "dev-target",
-      title: "Dev runtime target",
-      actions: ["open"],
-      protocols: ["NAP-01"],
-      isDefault: true
-    }]
+    catalog: new InstalledNappletCatalog(),
+    controller: new BrowserIntentController({
+      openOrReuse: () => null,
+      waitForReady: () => void 0,
+      isCurrent: () => false,
+      getWindowId: () => null,
+      send: () => void 0
+    })
   };
 }
 function createDevCvmTransport(getSimulation) {
@@ -13853,12 +14968,11 @@ function createRuntimeSigner(getSimulation, confirmRequest, signerProvider) {
   }
   return signer;
 }
-function createDevServices(backend, getSimulation, onThemeService, confirmRequest, uploadRuntime, signerProvider) {
+function createDevServices(backend, getSimulation, onThemeService, onThemeBroadcast, confirmRequest, uploadRuntime, signerProvider, intentHost = createDefaultIntentHost()) {
   const notification = createNotificationService({ maxPerWindow: 50 });
   const theme = createThemeService({
     initialTheme: createDevTheme(getSimulation().theme.mode, getSimulation().theme.values),
-    onBroadcast: () => {
-    }
+    onBroadcast: onThemeBroadcast
   });
   onThemeService(theme);
   const config = createConfigService({
@@ -13938,26 +15052,15 @@ function createDevServices(backend, getSimulation, onThemeService, confirmReques
     });
   }
   if (getSimulation().intent.enabled) {
+    const resolver = createCatalogIntentResolver({
+      loadCatalog: () => intentHost.catalog.intentCatalog(),
+      targets: intentHost.controller,
+      getDefaultHandler: intentHost.getDefaultHandler,
+      chooseHandler: intentHost.chooseHandler,
+      authorizeExplicitHandler: intentHost.authorizeExplicitHandler
+    });
     services.intent = createIntentService({
-      resolver: {
-        invoke(request) {
-          return {
-            ok: true,
-            archetype: request.archetype,
-            action: request.action ?? "open",
-            handled: request.archetype === DEV_INTENT_ARCHETYPE,
-            handler: "dev-target",
-            windowId: "kehto-paja-window",
-            protocol: request.protocol ?? "NAP-01"
-          };
-        },
-        available: (archetype) => ({
-          ...createDevIntentAvailability(),
-          archetype,
-          available: archetype === DEV_INTENT_ARCHETYPE
-        }),
-        handlers: () => [createDevIntentAvailability()]
-      }
+      resolver
     });
   }
   if (getSimulation().capabilities.domains.link) {
@@ -13999,7 +15102,7 @@ function createDevServices(backend, getSimulation, onThemeService, confirmReques
   }
   return services;
 }
-function createPajaAdapter(config, getSimulation, onThemeService, confirmRequest, signerProvider, getIdentity) {
+function createPajaAdapter(config, getSimulation, onThemeService, onThemeBroadcast, confirmRequest, signerProvider, getIdentity, onEnvironmentChanged, intentHost) {
   const relayBackend = createPajaRelayBackend(getSimulation, confirmRequest);
   const uploadRuntime = getSimulation().upload.mode === "blossom" ? createPajaUploadRuntime({
     getSimulation,
@@ -14015,7 +15118,11 @@ function createPajaAdapter(config, getSimulation, onThemeService, confirmRequest
     subscribeSignerChange: signerProvider?.subscribe?.bind(signerProvider)
   }) : void 0;
   void uploadRuntime?.refreshIdentity();
+  signerProvider?.subscribe?.(() => {
+    void uploadRuntime?.refreshIdentity().finally(() => onEnvironmentChanged?.());
+  });
   const workerRelayEvents = [];
+  const resolvedIntentHost = intentHost ?? createDefaultIntentHost();
   return {
     relayPool: createRelayHooks(relayBackend, getSimulation),
     relayConfig: {
@@ -14034,7 +15141,16 @@ function createPajaAdapter(config, getSimulation, onThemeService, confirmRequest
       getUserPubkey: () => getRuntimePubkey(getSimulation, signerProvider),
       getSigner: () => createRuntimeSigner(getSimulation, confirmRequest, signerProvider)
     },
-    services: createDevServices(relayBackend, getSimulation, onThemeService, confirmRequest, uploadRuntime, signerProvider),
+    services: createDevServices(
+      relayBackend,
+      getSimulation,
+      onThemeService,
+      onThemeBroadcast,
+      confirmRequest,
+      uploadRuntime,
+      signerProvider,
+      resolvedIntentHost
+    ),
     get capabilities() {
       return { disabledDomains: getSimulation().capabilities.disabledDomains };
     },
@@ -14052,119 +15168,358 @@ function createPajaAdapter(config, getSimulation, onThemeService, confirmRequest
     webrtc: { isAvailable: () => getSimulation().capabilities.domains.webrtc },
     crypto: {
       verifyEvent: async () => true
-    },
-    onNip5dIframeCreate: () => {
-      const identity = getIdentity?.();
-      return {
-        dTag: identity?.dTag ?? config.window.dTag,
-        aggregateHash: identity?.aggregateHash ?? config.window.aggregateHash
-      };
     }
   };
 }
 
-// ../../node_modules/.pnpm/@noble+ciphers@2.1.1/node_modules/@noble/ciphers/aes.js
-var BLOCK_SIZE = 16;
-var POLY = 283;
-function validateKeyLength(key) {
-  if (![16, 24, 32].includes(key.length))
-    throw new Error('"aes key" expected Uint8Array of length 16/24/32, got length=' + key.length);
+// src/browser-devtools.ts
+var PAJA_LOG_LIMIT = 500;
+var proxyToReal = /* @__PURE__ */ new WeakMap();
+var realToProxy = /* @__PURE__ */ new WeakMap();
+var proxyContexts = /* @__PURE__ */ new WeakMap();
+function isNappletMessage(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.type === "string";
 }
-function mul2(n) {
-  return n << 1 ^ POLY & -(n >> 7);
+function describeMessage(raw) {
+  if (isNappletMessage(raw)) return raw.type;
+  if (Array.isArray(raw) && typeof raw[0] === "string") return raw[0];
+  return "unknown";
 }
-function mul(a, b) {
-  let res = 0;
-  for (; b > 0; b >>= 1) {
-    res ^= a & -(b & 1);
-    a = mul2(a);
+function previewMessage(raw) {
+  try {
+    return JSON.stringify(raw);
+  } catch (error) {
+    return `unserializable:${error instanceof Error ? error.message : String(error)}`;
   }
-  return res;
 }
-var sbox = /* @__PURE__ */ (() => {
-  const t = new Uint8Array(256);
-  for (let i4 = 0, x = 1; i4 < 256; i4++, x ^= mul2(x))
-    t[i4] = x;
-  const box = new Uint8Array(256);
-  box[0] = 99;
-  for (let i4 = 0; i4 < 255; i4++) {
-    let x = t[255 - i4];
-    x |= x << 8;
-    box[t[i4]] = (x ^ x >> 4 ^ x >> 5 ^ x >> 6 ^ x >> 7 ^ 99) & 255;
+function compactMessageDetail(raw) {
+  const detail = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (key !== "type" && key !== "id" && value !== void 0) detail[key] = value;
   }
-  clean2(t);
-  return box;
-})();
-var invSbox = /* @__PURE__ */ sbox.map((_, j) => sbox.indexOf(j));
-var rotr32_8 = (n) => n << 24 | n >>> 8;
-var rotl32_8 = (n) => n << 8 | n >>> 24;
-function genTtable(sbox2, fn) {
-  if (sbox2.length !== 256)
-    throw new Error("Wrong sbox length");
-  const T0 = new Uint32Array(256).map((_, j) => fn(sbox2[j]));
-  const T1 = T0.map(rotl32_8);
-  const T2 = T1.map(rotl32_8);
-  const T3 = T2.map(rotl32_8);
-  const T01 = new Uint32Array(256 * 256);
-  const T23 = new Uint32Array(256 * 256);
-  const sbox22 = new Uint16Array(256 * 256);
-  for (let i4 = 0; i4 < 256; i4++) {
-    for (let j = 0; j < 256; j++) {
-      const idx = i4 * 256 + j;
-      T01[idx] = T0[i4] ^ T1[j];
-      T23[idx] = T2[i4] ^ T3[j];
-      sbox22[idx] = sbox2[i4] << 8 | sbox2[j];
-    }
+  if (Object.keys(detail).length === 0) return "";
+  try {
+    return JSON.stringify(detail);
+  } catch {
+    return "";
   }
-  return { sbox: sbox2, sbox2: sbox22, T0, T1, T2, T3, T01, T23 };
 }
-var tableEncoding = /* @__PURE__ */ genTtable(sbox, (s) => mul(s, 3) << 24 | s << 16 | s << 8 | mul(s, 2));
-var tableDecoding = /* @__PURE__ */ genTtable(invSbox, (s) => mul(s, 11) << 24 | mul(s, 13) << 16 | mul(s, 9) << 8 | mul(s, 14));
-var xPowers = /* @__PURE__ */ (() => {
-  const p = new Uint8Array(16);
-  for (let i4 = 0, x = 1; i4 < 16; i4++, x = mul2(x))
-    p[i4] = x;
-  return p;
-})();
-function expandKeyLE(key) {
-  abytes3(key);
-  const len = key.length;
-  validateKeyLength(key);
-  const { sbox2 } = tableEncoding;
-  const toClean = [];
-  if (!isAligned32(key))
-    toClean.push(key = copyBytes2(key));
-  const k32 = u32(key);
-  const Nk = k32.length;
-  const subByte = (n) => applySbox(sbox2, n, n, n, n);
-  const xk = new Uint32Array(len + 28);
-  xk.set(k32);
-  for (let i4 = Nk; i4 < xk.length; i4++) {
-    let t = xk[i4 - 1];
-    if (i4 % Nk === 0)
-      t = subByte(rotr32_8(t)) ^ xPowers[i4 / Nk - 1];
-    else if (Nk > 6 && i4 % Nk === 4)
-      t = subByte(t);
-    xk[i4] = xk[i4 - Nk] ^ t;
+function describeMessageDetail(raw) {
+  if (!isNappletMessage(raw)) return "";
+  const value = raw;
+  for (const key of ["error", "message", "reason"]) {
+    const detail = value[key];
+    if (typeof detail === "string" && detail.length > 0) return detail;
   }
-  clean2(...toClean);
-  return xk;
+  return raw.type.endsWith(".error") ? compactMessageDetail(value) : "";
 }
-function expandKeyDecLE(key) {
-  const encKey = expandKeyLE(key);
-  const xk = encKey.slice();
-  const Nk = encKey.length;
-  const { sbox2 } = tableEncoding;
-  const { T0, T1, T2, T3 } = tableDecoding;
-  for (let i4 = 0; i4 < Nk; i4 += 4) {
-    for (let j = 0; j < 4; j++)
-      xk[i4 + j] = encKey[Nk - i4 - 4 + j];
-  }
-  clean2(encKey);
-  for (let i4 = 4; i4 < Nk - 4; i4++) {
-    const x = xk[i4];
-    const w = applySbox(sbox2, x, x, x, x);
-    xk[i4] = T0[w & 255] ^ T1[w >>> 8 & 255] ^ T2[w >>> 16 & 255] ^ T3[w >>> 24];
+function domainEnabled(simulation, domain) {
+  return simulation.capabilities.domains[domain] === true;
+}
+function getTargetIdentity(config) {
+  return {
+    pubkey: "",
+    dTag: config.window.dTag,
+    aggregateHash: config.window.aggregateHash
+  };
+}
+function appendPajaMessageLog(state, direction, raw, windowId) {
+  if (!state) return;
+  state.messageLog.push({
+    index: state.messageLog.length,
+    timestamp: Date.now(),
+    direction,
+    type: describeMessage(raw),
+    windowId,
+    preview: previewMessage(raw),
+    detail: describeMessageDetail(raw)
+  });
+  if (state.messageLog.length > PAJA_LOG_LIMIT) {
+    state.messageLog.splice(0, state.messageLog.length - PAJA_LOG_LIMIT);
+  }
+  renderPajaMessageLog(state);
+}
+function createPajaPostMessageProxy(realWin, state, windowId) {
+  const existing = realToProxy.get(realWin);
+  if (existing) {
+    proxyContexts.set(existing, { state, windowId });
+    return existing;
+  }
+  const proxy = new Proxy(realWin, {
+    get(target, prop) {
+      if (prop === "postMessage") {
+        return (msg, targetOrigin, transfer) => {
+          const context = proxyContexts.get(proxy);
+          appendPajaMessageLog(
+            context?.state ?? state,
+            "shell->napplet",
+            msg,
+            context?.windowId ?? windowId
+          );
+          return target.postMessage(msg, targetOrigin, transfer);
+        };
+      }
+      try {
+        const val = Reflect.get(target, prop, target);
+        return typeof val === "function" ? val.bind(target) : val;
+      } catch {
+        return void 0;
+      }
+    }
+  });
+  proxyToReal.set(proxy, realWin);
+  realToProxy.set(realWin, proxy);
+  proxyContexts.set(proxy, { state, windowId });
+  return proxy;
+}
+function installPajaOriginRegistryProxy(originRegistry2, stateRef) {
+  const originalGetIframeWindow = originRegistry2.getIframeWindow.bind(originRegistry2);
+  originRegistry2.getIframeWindow = (windowId) => {
+    const win = originalGetIframeWindow(windowId);
+    if (!win) return null;
+    return createPajaPostMessageProxy(win, stateRef(), windowId);
+  };
+  const originalGetWindowId = originRegistry2.getWindowId.bind(originRegistry2);
+  originRegistry2.getWindowId = (win) => {
+    const result2 = originalGetWindowId(win);
+    if (result2) return result2;
+    const real = proxyToReal.get(win);
+    return real ? originalGetWindowId(real) : void 0;
+  };
+  const originalGetIdentity = originRegistry2.getIdentity.bind(originRegistry2);
+  originRegistry2.getIdentity = (win) => {
+    const real = proxyToReal.get(win);
+    return originalGetIdentity(win) ?? (real ? originalGetIdentity(real) : void 0);
+  };
+  const originalGetRegistrationId = originRegistry2.getRegistrationId.bind(originRegistry2);
+  originRegistry2.getRegistrationId = (win) => {
+    const real = proxyToReal.get(win);
+    return originalGetRegistrationId(win) ?? (real ? originalGetRegistrationId(real) : void 0);
+  };
+  const originalGetEnvironment = originRegistry2.getEnvironment.bind(originRegistry2);
+  originRegistry2.getEnvironment = (win) => {
+    const real = proxyToReal.get(win);
+    return originalGetEnvironment(win) ?? (real ? originalGetEnvironment(real) : void 0);
+  };
+}
+function renderPajaDevtools(state, options) {
+  renderInterfaceControls(state);
+  renderAclControls(state, options.bridge);
+  renderSignerStatus(state, options.devSignerPubkey);
+}
+function renderPajaMessageLog(state) {
+  const container = document.getElementById("message-log");
+  if (!container) return;
+  const filter = state.messageFilter.trim().toLowerCase();
+  const rows = state.messageLog.filter((entry) => filter.length === 0 || `${entry.direction} ${entry.type} ${entry.detail} ${entry.preview}`.toLowerCase().includes(filter)).slice(-120).map((entry) => {
+    const row = document.createElement("div");
+    row.className = "log-row";
+    row.dataset.messageType = entry.type;
+    if (entry.type.endsWith(".error")) row.dataset.error = "true";
+    const dir = document.createElement("div");
+    dir.className = "log-dir";
+    dir.textContent = entry.direction;
+    const body = document.createElement("div");
+    body.className = "log-body";
+    const type = document.createElement("div");
+    type.className = "log-type";
+    type.title = entry.preview;
+    type.textContent = entry.type;
+    body.append(type);
+    if (entry.detail) {
+      const detail = document.createElement("div");
+      detail.className = "log-detail";
+      detail.textContent = entry.detail;
+      detail.title = entry.preview;
+      body.append(detail);
+    }
+    row.append(dir, body);
+    return row;
+  });
+  container.replaceChildren(...rows);
+  container.scrollTop = container.scrollHeight;
+}
+function renderInterfaceControls(state) {
+  const container = document.getElementById("interface-toggles");
+  if (!container) return;
+  container.replaceChildren(...PAJA_SIMULATION_DOMAINS.map((domain) => {
+    const enabled = domainEnabled(state.simulation, domain);
+    const button = document.createElement("button");
+    button.type = "button";
+    button.className = "toggle";
+    button.dataset.interfaceDomain = domain;
+    button.dataset.enabled = String(enabled);
+    button.textContent = domain;
+    button.title = `${domain} injection ${enabled ? "enabled" : "disabled"}`;
+    button.addEventListener("click", () => {
+      state.setDomainEnabled(domain, !domainEnabled(state.simulation, domain));
+    });
+    return button;
+  }));
+}
+function renderAclControls(state, bridge) {
+  const container = document.getElementById("acl-controls");
+  if (!container) return;
+  const identity = getTargetIdentity(state.config);
+  container.replaceChildren(...ALL_CAPABILITIES.map((capability) => {
+    const allowed2 = bridge?.runtime.aclState.check(
+      identity.pubkey,
+      identity.dTag,
+      identity.aggregateHash,
+      capability
+    ) ?? true;
+    const button = document.createElement("button");
+    button.type = "button";
+    button.className = "toggle";
+    button.dataset.aclCapability = capability;
+    button.dataset.enabled = String(allowed2);
+    button.textContent = capability;
+    button.title = `${capability} ${allowed2 ? "allowed" : "blocked"}`;
+    button.addEventListener("click", () => state.setAclCapability(capability, !allowed2));
+    return button;
+  }));
+}
+function renderSignerStatus(state, signerPubkey) {
+  const el = document.getElementById("signer-status");
+  const controls = document.getElementById("signer-controls");
+  if (!el || !controls) return;
+  const fallbackPubkey = state.simulation.identity.pubkey || (state.signer.method === "dev" ? signerPubkey : "");
+  const pubkey = state.simulation.identity.pubkey || state.signer.pubkey || (state.signer.method === "dev" ? signerPubkey : "");
+  const methodLabel = state.signer.method === "nip07" ? "NIP-07" : state.signer.method === "nip46" ? "bunker" : state.signer.method === "dev" ? "dev" : "none";
+  const relay = state.signer.relay ? ` \xB7 relay ${state.signer.relay}` : "";
+  const prefix = state.signer.status === "disconnected" ? "no signer connected" : state.signer.status === "error" ? `${methodLabel} error: ${state.signer.error ?? "unknown error"} \xB7 fallback pubkey ${fallbackPubkey}` : `${methodLabel} ${state.signer.status} \xB7 pubkey ${pubkey || "(none)"}${relay}`;
+  el.textContent = `${prefix} \xB7 every sign/publish request prompts`;
+  const previousInput = controls.querySelector("#signer-bunker-uri")?.value ?? "";
+  const devButton = document.createElement("button");
+  devButton.type = "button";
+  devButton.id = "signer-dev";
+  devButton.dataset.active = String(state.signer.method === "dev");
+  devButton.textContent = "Dev";
+  devButton.addEventListener("click", () => state.useDevSigner());
+  const nip07Button = document.createElement("button");
+  nip07Button.type = "button";
+  nip07Button.id = "signer-nip07";
+  nip07Button.dataset.active = String(state.signer.method === "nip07");
+  nip07Button.textContent = "NIP-07";
+  nip07Button.addEventListener("click", () => void state.connectNip07());
+  const bunkerInput = document.createElement("input");
+  bunkerInput.id = "signer-bunker-uri";
+  bunkerInput.type = "text";
+  bunkerInput.autocomplete = "off";
+  bunkerInput.placeholder = "bunker://...";
+  bunkerInput.setAttribute("aria-label", "Bunker connection URI");
+  bunkerInput.value = previousInput;
+  const bunkerButton = document.createElement("button");
+  bunkerButton.type = "button";
+  bunkerButton.id = "signer-bunker";
+  bunkerButton.dataset.active = String(state.signer.method === "nip46");
+  bunkerButton.textContent = "Bunker";
+  bunkerButton.addEventListener("click", () => void state.connectBunker(bunkerInput.value));
+  controls.replaceChildren(devButton, nip07Button, bunkerInput, bunkerButton);
+}
+
+// ../../node_modules/.pnpm/@noble+ciphers@2.1.1/node_modules/@noble/ciphers/aes.js
+var BLOCK_SIZE = 16;
+var POLY = 283;
+function validateKeyLength(key) {
+  if (![16, 24, 32].includes(key.length))
+    throw new Error('"aes key" expected Uint8Array of length 16/24/32, got length=' + key.length);
+}
+function mul2(n) {
+  return n << 1 ^ POLY & -(n >> 7);
+}
+function mul(a, b) {
+  let res = 0;
+  for (; b > 0; b >>= 1) {
+    res ^= a & -(b & 1);
+    a = mul2(a);
+  }
+  return res;
+}
+var sbox = /* @__PURE__ */ (() => {
+  const t = new Uint8Array(256);
+  for (let i4 = 0, x = 1; i4 < 256; i4++, x ^= mul2(x))
+    t[i4] = x;
+  const box = new Uint8Array(256);
+  box[0] = 99;
+  for (let i4 = 0; i4 < 255; i4++) {
+    let x = t[255 - i4];
+    x |= x << 8;
+    box[t[i4]] = (x ^ x >> 4 ^ x >> 5 ^ x >> 6 ^ x >> 7 ^ 99) & 255;
+  }
+  clean2(t);
+  return box;
+})();
+var invSbox = /* @__PURE__ */ sbox.map((_, j) => sbox.indexOf(j));
+var rotr32_8 = (n) => n << 24 | n >>> 8;
+var rotl32_8 = (n) => n << 8 | n >>> 24;
+function genTtable(sbox2, fn) {
+  if (sbox2.length !== 256)
+    throw new Error("Wrong sbox length");
+  const T0 = new Uint32Array(256).map((_, j) => fn(sbox2[j]));
+  const T1 = T0.map(rotl32_8);
+  const T2 = T1.map(rotl32_8);
+  const T3 = T2.map(rotl32_8);
+  const T01 = new Uint32Array(256 * 256);
+  const T23 = new Uint32Array(256 * 256);
+  const sbox22 = new Uint16Array(256 * 256);
+  for (let i4 = 0; i4 < 256; i4++) {
+    for (let j = 0; j < 256; j++) {
+      const idx = i4 * 256 + j;
+      T01[idx] = T0[i4] ^ T1[j];
+      T23[idx] = T2[i4] ^ T3[j];
+      sbox22[idx] = sbox2[i4] << 8 | sbox2[j];
+    }
+  }
+  return { sbox: sbox2, sbox2: sbox22, T0, T1, T2, T3, T01, T23 };
+}
+var tableEncoding = /* @__PURE__ */ genTtable(sbox, (s) => mul(s, 3) << 24 | s << 16 | s << 8 | mul(s, 2));
+var tableDecoding = /* @__PURE__ */ genTtable(invSbox, (s) => mul(s, 11) << 24 | mul(s, 13) << 16 | mul(s, 9) << 8 | mul(s, 14));
+var xPowers = /* @__PURE__ */ (() => {
+  const p = new Uint8Array(16);
+  for (let i4 = 0, x = 1; i4 < 16; i4++, x = mul2(x))
+    p[i4] = x;
+  return p;
+})();
+function expandKeyLE(key) {
+  abytes3(key);
+  const len = key.length;
+  validateKeyLength(key);
+  const { sbox2 } = tableEncoding;
+  const toClean = [];
+  if (!isAligned32(key))
+    toClean.push(key = copyBytes2(key));
+  const k32 = u32(key);
+  const Nk = k32.length;
+  const subByte = (n) => applySbox(sbox2, n, n, n, n);
+  const xk = new Uint32Array(len + 28);
+  xk.set(k32);
+  for (let i4 = Nk; i4 < xk.length; i4++) {
+    let t = xk[i4 - 1];
+    if (i4 % Nk === 0)
+      t = subByte(rotr32_8(t)) ^ xPowers[i4 / Nk - 1];
+    else if (Nk > 6 && i4 % Nk === 4)
+      t = subByte(t);
+    xk[i4] = xk[i4 - Nk] ^ t;
+  }
+  clean2(...toClean);
+  return xk;
+}
+function expandKeyDecLE(key) {
+  const encKey = expandKeyLE(key);
+  const xk = encKey.slice();
+  const Nk = encKey.length;
+  const { sbox2 } = tableEncoding;
+  const { T0, T1, T2, T3 } = tableDecoding;
+  for (let i4 = 0; i4 < Nk; i4 += 4) {
+    for (let j = 0; j < 4; j++)
+      xk[i4 + j] = encKey[Nk - i4 - 4 + j];
+  }
+  clean2(encKey);
+  for (let i4 = 4; i4 < Nk - 4; i4++) {
+    const x = xk[i4];
+    const w = applySbox(sbox2, x, x, x, x);
+    xk[i4] = T0[w & 255] ^ T1[w >>> 8 & 255] ^ T2[w >>> 16 & 255] ^ T3[w >>> 24];
   }
   return xk;
 }
@@ -16890,12 +18245,12 @@ async function sendRequestWithId(state, correlationId, method, params) {
     tags: [["p", state.bunkerPubkey]],
     content: encryptedContent
   }, state.localSecretKey);
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve, reject2) => {
     const timer = setTimeout(() => {
       state.pending.delete(correlationId);
-      reject(new Error(`NIP-46 request timed out: ${method}`));
+      reject2(new Error(`NIP-46 request timed out: ${method}`));
     }, state.timeout);
-    state.pending.set(correlationId, { resolve, reject, timer });
+    state.pending.set(correlationId, { resolve, reject: reject2, timer });
     state.ws.send(JSON.stringify(["EVENT", signedEvent]));
   });
 }
@@ -16934,7 +18289,7 @@ function rejectPendingOnClose(state) {
   state.pending.clear();
 }
 function openWebSocket(state) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve, reject2) => {
     state.ws = new WebSocket(state.relayUrl);
     state.ws.onopen = () => {
       state.ws.send(JSON.stringify([
@@ -16948,7 +18303,7 @@ function openWebSocket(state) {
       handleRelayMessage(state, event.data).catch(() => {
       });
     };
-    state.ws.onerror = () => reject(new Error(`NIP-46 WebSocket connection failed: ${state.relayUrl}`));
+    state.ws.onerror = () => reject2(new Error(`NIP-46 WebSocket connection failed: ${state.relayUrl}`));
     state.ws.onclose = () => rejectPendingOnClose(state);
   });
 }
@@ -17123,245 +18478,77 @@ function createPajaSignerController(options) {
   };
 }
 
-// src/browser-devtools.ts
-var PAJA_LOG_LIMIT = 500;
-var proxyToReal = /* @__PURE__ */ new WeakMap();
-var realToProxy = /* @__PURE__ */ new WeakMap();
-var proxyContexts = /* @__PURE__ */ new WeakMap();
-function isNappletMessage(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.type === "string";
-}
-function describeMessage(raw) {
-  if (isNappletMessage(raw)) return raw.type;
-  if (Array.isArray(raw) && typeof raw[0] === "string") return raw[0];
-  return "unknown";
-}
-function previewMessage(raw) {
-  try {
-    return JSON.stringify(raw);
-  } catch (error) {
-    return `unserializable:${error instanceof Error ? error.message : String(error)}`;
-  }
-}
-function compactMessageDetail(raw) {
-  const detail = {};
-  for (const [key, value] of Object.entries(raw)) {
-    if (key !== "type" && key !== "id" && value !== void 0) detail[key] = value;
-  }
-  if (Object.keys(detail).length === 0) return "";
-  try {
-    return JSON.stringify(detail);
-  } catch {
-    return "";
-  }
-}
-function describeMessageDetail(raw) {
-  if (!isNappletMessage(raw)) return "";
-  const value = raw;
-  for (const key of ["error", "message", "reason"]) {
-    const detail = value[key];
-    if (typeof detail === "string" && detail.length > 0) return detail;
-  }
-  return raw.type.endsWith(".error") ? compactMessageDetail(value) : "";
-}
-function domainEnabled(simulation, domain) {
-  return simulation.capabilities.domains[domain] === true;
-}
-function getTargetIdentity(config) {
-  return {
-    pubkey: "",
-    dTag: config.window.dTag,
-    aggregateHash: config.window.aggregateHash
-  };
-}
-function appendPajaMessageLog(state, direction, raw, windowId) {
-  if (!state) return;
-  state.messageLog.push({
-    index: state.messageLog.length,
-    timestamp: Date.now(),
-    direction,
-    type: describeMessage(raw),
-    windowId,
-    preview: previewMessage(raw),
-    detail: describeMessageDetail(raw)
-  });
-  if (state.messageLog.length > PAJA_LOG_LIMIT) {
-    state.messageLog.splice(0, state.messageLog.length - PAJA_LOG_LIMIT);
-  }
-  renderPajaMessageLog(state);
-}
-function createPajaPostMessageProxy(realWin, state, windowId) {
-  const existing = realToProxy.get(realWin);
-  if (existing) {
-    proxyContexts.set(existing, { state, windowId });
-    return existing;
+// src/browser-host-signer.ts
+function confirmPajaRequest(state, request) {
+  if (request.action === "upload") {
+    const filename = request.filename ?? "(unnamed blob)";
+    const mimeType = request.mimeType ?? "application/octet-stream";
+    const allowed3 = window.confirm([
+      "Paja upload request",
+      `napplet: ${request.napplet.dTag} (${request.windowId})`,
+      `file: ${filename}`,
+      `size: ${request.size} bytes`,
+      `type: ${mimeType}`,
+      `server: ${request.server}`,
+      request.warning
+    ].join("\n"));
+    appendPajaMessageLog(state, "paja", {
+      type: `paja.upload.${allowed3 ? "confirmed" : "denied"}`,
+      windowId: request.windowId,
+      dTag: request.napplet.dTag,
+      aggregateHash: request.napplet.aggregateHash,
+      filename,
+      size: request.size,
+      mimeType,
+      server: request.server,
+      warning: request.warning
+    });
+    return allowed3;
   }
-  const proxy = new Proxy(realWin, {
-    get(target, prop) {
-      if (prop === "postMessage") {
-        return (msg, targetOrigin, transfer) => {
-          const context = proxyContexts.get(proxy);
-          appendPajaMessageLog(
-            context?.state ?? state,
-            "shell->napplet",
-            msg,
-            context?.windowId ?? windowId
-          );
-          return target.postMessage(msg, targetOrigin, transfer);
-        };
-      }
-      try {
-        const val = Reflect.get(target, prop, target);
-        return typeof val === "function" ? val.bind(target) : val;
-      } catch {
-        return void 0;
-      }
-    }
-  });
-  proxyToReal.set(proxy, realWin);
-  realToProxy.set(realWin, proxy);
-  proxyContexts.set(proxy, { state, windowId });
-  return proxy;
-}
-function installPajaOriginRegistryProxy(originRegistry2, stateRef) {
-  const originalGetIframeWindow = originRegistry2.getIframeWindow.bind(originRegistry2);
-  originRegistry2.getIframeWindow = (windowId) => {
-    const win = originalGetIframeWindow(windowId);
-    if (!win) return null;
-    return createPajaPostMessageProxy(win, stateRef(), windowId);
-  };
-  const originalGetWindowId = originRegistry2.getWindowId.bind(originRegistry2);
-  originRegistry2.getWindowId = (win) => {
-    const result2 = originalGetWindowId(win);
-    if (result2) return result2;
-    const real = proxyToReal.get(win);
-    return real ? originalGetWindowId(real) : void 0;
-  };
-  const originalGetIdentity = originRegistry2.getIdentity.bind(originRegistry2);
-  originRegistry2.getIdentity = (win) => {
-    const real = proxyToReal.get(win);
-    return originalGetIdentity(win) ?? (real ? originalGetIdentity(real) : void 0);
-  };
-  const originalGetRegistrationId = originRegistry2.getRegistrationId.bind(originRegistry2);
-  originRegistry2.getRegistrationId = (win) => {
-    const real = proxyToReal.get(win);
-    return originalGetRegistrationId(win) ?? (real ? originalGetRegistrationId(real) : void 0);
-  };
-}
-function renderPajaDevtools(state, options) {
-  renderInterfaceControls(state);
-  renderAclControls(state, options.bridge);
-  renderSignerStatus(state, options.devSignerPubkey);
-}
-function renderPajaMessageLog(state) {
-  const container = document.getElementById("message-log");
-  if (!container) return;
-  const filter = state.messageFilter.trim().toLowerCase();
-  const rows = state.messageLog.filter((entry) => filter.length === 0 || `${entry.direction} ${entry.type} ${entry.detail} ${entry.preview}`.toLowerCase().includes(filter)).slice(-120).map((entry) => {
-    const row = document.createElement("div");
-    row.className = "log-row";
-    row.dataset.messageType = entry.type;
-    if (entry.type.endsWith(".error")) row.dataset.error = "true";
-    const dir = document.createElement("div");
-    dir.className = "log-dir";
-    dir.textContent = entry.direction;
-    const body = document.createElement("div");
-    body.className = "log-body";
-    const type = document.createElement("div");
-    type.className = "log-type";
-    type.title = entry.preview;
-    type.textContent = entry.type;
-    body.append(type);
-    if (entry.detail) {
-      const detail = document.createElement("div");
-      detail.className = "log-detail";
-      detail.textContent = entry.detail;
-      detail.title = entry.preview;
-      body.append(detail);
-    }
-    row.append(dir, body);
-    return row;
+  const event = request.event;
+  const kind = typeof event.kind === "number" ? event.kind : "unknown";
+  const content = typeof event.content === "string" && event.content.length > 0 ? `
+
+${event.content.slice(0, 240)}` : "";
+  const allowed2 = window.confirm(`Paja ${request.action} request
+kind: ${kind}${content}`);
+  appendPajaMessageLog(state, "paja", {
+    type: `paja.${request.action}.${allowed2 ? "confirmed" : "denied"}`,
+    kind
   });
-  container.replaceChildren(...rows);
-  container.scrollTop = container.scrollHeight;
-}
-function renderInterfaceControls(state) {
-  const container = document.getElementById("interface-toggles");
-  if (!container) return;
-  container.replaceChildren(...PAJA_SIMULATION_DOMAINS.map((domain) => {
-    const enabled = domainEnabled(state.simulation, domain);
-    const button = document.createElement("button");
-    button.type = "button";
-    button.className = "toggle";
-    button.dataset.interfaceDomain = domain;
-    button.dataset.enabled = String(enabled);
-    button.textContent = domain;
-    button.title = `${domain} injection ${enabled ? "enabled" : "disabled"}`;
-    button.addEventListener("click", () => {
-      state.setDomainEnabled(domain, !domainEnabled(state.simulation, domain));
-    });
-    return button;
-  }));
+  return allowed2;
 }
-function renderAclControls(state, bridge) {
-  const container = document.getElementById("acl-controls");
-  if (!container) return;
-  const identity = getTargetIdentity(state.config);
-  container.replaceChildren(...ALL_CAPABILITIES.map((capability) => {
-    const allowed2 = bridge?.runtime.aclState.check(
-      identity.pubkey,
-      identity.dTag,
-      identity.aggregateHash,
-      capability
-    ) ?? true;
-    const button = document.createElement("button");
-    button.type = "button";
-    button.className = "toggle";
-    button.dataset.aclCapability = capability;
-    button.dataset.enabled = String(allowed2);
-    button.textContent = capability;
-    button.title = `${capability} ${allowed2 ? "allowed" : "blocked"}`;
-    button.addEventListener("click", () => state.setAclCapability(capability, !allowed2));
-    return button;
-  }));
+function createHostSignerController(getState, refreshState) {
+  return createPajaSignerController({
+    confirmRequest: (request) => confirmPajaRequest(getState(), request),
+    onChange(signer) {
+      const state = getState();
+      if (!state) return;
+      state.signer = signer;
+      appendPajaMessageLog(state, "paja", {
+        type: `paja.signer.${signer.method}.${signer.status}`,
+        pubkey: signer.pubkey,
+        relay: signer.relay,
+        error: signer.error
+      });
+      refreshState(state);
+      if (signer.status === "connected") state.reload();
+    }
+  });
 }
-function renderSignerStatus(state, signerPubkey) {
-  const el = document.getElementById("signer-status");
-  const controls = document.getElementById("signer-controls");
-  if (!el || !controls) return;
-  const fallbackPubkey = state.simulation.identity.pubkey || (state.signer.method === "dev" ? signerPubkey : "");
-  const pubkey = state.simulation.identity.pubkey || state.signer.pubkey || (state.signer.method === "dev" ? signerPubkey : "");
-  const methodLabel = state.signer.method === "nip07" ? "NIP-07" : state.signer.method === "nip46" ? "bunker" : state.signer.method === "dev" ? "dev" : "none";
-  const relay = state.signer.relay ? ` \xB7 relay ${state.signer.relay}` : "";
-  const prefix = state.signer.status === "disconnected" ? "no signer connected" : state.signer.status === "error" ? `${methodLabel} error: ${state.signer.error ?? "unknown error"} \xB7 fallback pubkey ${fallbackPubkey}` : `${methodLabel} ${state.signer.status} \xB7 pubkey ${pubkey || "(none)"}${relay}`;
-  el.textContent = `${prefix} \xB7 every sign/publish request prompts`;
-  const previousInput = controls.querySelector("#signer-bunker-uri")?.value ?? "";
-  const devButton = document.createElement("button");
-  devButton.type = "button";
-  devButton.id = "signer-dev";
-  devButton.dataset.active = String(state.signer.method === "dev");
-  devButton.textContent = "Dev";
-  devButton.addEventListener("click", () => state.useDevSigner());
-  const nip07Button = document.createElement("button");
-  nip07Button.type = "button";
-  nip07Button.id = "signer-nip07";
-  nip07Button.dataset.active = String(state.signer.method === "nip07");
-  nip07Button.textContent = "NIP-07";
-  nip07Button.addEventListener("click", () => void state.connectNip07());
-  const bunkerInput = document.createElement("input");
-  bunkerInput.id = "signer-bunker-uri";
-  bunkerInput.type = "text";
-  bunkerInput.autocomplete = "off";
-  bunkerInput.placeholder = "bunker://...";
-  bunkerInput.setAttribute("aria-label", "Bunker connection URI");
-  bunkerInput.value = previousInput;
-  const bunkerButton = document.createElement("button");
-  bunkerButton.type = "button";
-  bunkerButton.id = "signer-bunker";
-  bunkerButton.dataset.active = String(state.signer.method === "nip46");
-  bunkerButton.textContent = "Bunker";
-  bunkerButton.addEventListener("click", () => void state.connectBunker(bunkerInput.value));
-  controls.replaceChildren(devButton, nip07Button, bunkerInput, bunkerButton);
+function hasNip07Signer() {
+  const signer = globalThis.nostr;
+  return typeof signer === "object" && signer !== null;
+}
+
+// src/browser-host-runtime.ts
+function unregisterSingleFrameWindow(bridge, runtime, windowId) {
+  if (!windowId) return;
+  bridge.runtime.destroyWindow(windowId);
+  bridge.runtime.sessionRegistry.unregister(windowId);
+  originRegistry.unregister(windowId);
+  runtime.readyWindowIds.delete(windowId);
+  if (runtime.currentWindowId === windowId) runtime.currentWindowId = null;
 }
 
 // src/browser-runtime-tabs.ts
@@ -17374,6 +18561,9 @@ function resolvedTargetKey(target) {
     target.aggregateHash
   ].join(":");
 }
+function runtimeTabGenerationId(tab) {
+  return `${tab.id}:${tab.generation}`;
+}
 function getActiveTab(state) {
   return state.tabs.find((tab) => tab.id === state.activeTabId) ?? null;
 }
@@ -17619,11 +18809,13 @@ function resolvedTargetTitle(target) {
   return title && title.length > 0 ? title : target.dTag || target.aggregateHash.slice(0, 12);
 }
 function destroyRuntimeTab(tab, context) {
+  context.onTabDestroyed?.(tab);
   if (tab.windowId) {
     context.bridge.runtime.destroyWindow(tab.windowId);
     context.bridge.runtime.sessionRegistry.unregister(tab.windowId);
     originRegistry.unregister(tab.windowId);
     context.runtime.readyWindowIds.delete(tab.windowId);
+    if (context.runtime.currentWindowId === tab.windowId) context.runtime.currentWindowId = null;
   }
   tab.frame.remove();
 }
@@ -17637,18 +18829,6 @@ function createRuntimeTabFrame(tab, state, context) {
   frame.dataset.tabId = tab.id;
   frame.dataset.targetUrl = tab.pointerValue;
   frame.hidden = true;
-  frame.addEventListener("load", () => {
-    if (tab.status !== "booting" && tab.status !== "reloading") return;
-    tab.windowId = context.registerFrameForGeneration(
-      context.bridge,
-      frame,
-      context.config,
-      tab.generation,
-      tab.resolvedTarget,
-      runtimeTabWindowId(context.config, tab)
-    );
-    if (state.activeTabId === tab.id) context.runtime.currentWindowId = tab.windowId;
-  });
   frame.addEventListener("error", () => {
     tab.status = "error";
     if (state.activeTabId === tab.id) context.setStatus(state, "error");
@@ -17662,14 +18842,18 @@ function startRuntimeTabNavigation(tab, state, context) {
   context.setStatus(state, "booting");
   renderRuntimeTabs(state);
   void context.navigateFrame(
-    context.bridge,
     tab.frame,
     context.config,
     generation,
-    context.capabilities,
-    context.runtime.currentSimulation,
+    context.adapter,
     tab.resolvedTarget,
-    runtimeTabWindowId(context.config, tab)
+    runtimeTabWindowId(context.config, tab),
+    () => tab.generation === generation,
+    (windowId) => {
+      if (tab.generation !== generation) return;
+      tab.windowId = windowId;
+      if (state.activeTabId === tab.id) context.runtime.currentWindowId = windowId;
+    }
   ).then((windowId) => {
     if (tab.generation !== generation) return;
     tab.windowId = windowId;
@@ -17692,13 +18876,6 @@ function runtimeTabWindowId(config, tab) {
   return `${config.window.id}:${tab.id}:${tab.generation}`;
 }
 
-// src/parity.ts
-var PAJA_LEGACY_COMPATIBILITY_DOMAIN = `i${"fc"}`;
-var PAJA_HANDSHAKE_DOMAINS = ["shell"];
-var PAJA_COMPATIBILITY_ALIASES = {
-  [PAJA_LEGACY_COMPATIBILITY_DOMAIN]: "inc"
-};
-
 // ../nip/dist/chunk-JT5WCCCX.js
 function computeAggregateHash(entries) {
   const lines = entries.map((entry) => `${entry.sha256} ${entry.path}
@@ -17724,7 +18901,7 @@ function aggregateTagValue(tags) {
   return void 0;
 }
 
-// ../nip/dist/chunk-NRUVARZL.js
+// ../nip/dist/chunk-ZQSTY6HR.js
 var MIB = 1024 * 1024;
 var NAPPLET_ARTIFACT_CACHE_NAME = "kehto:napplet-artifacts:v1";
 var SCHEMA_VERSION = 1;
@@ -18159,10 +19336,43 @@ function archetypesFromTags(tags) {
   const out = [];
   for (const tag of tags) {
     if (tag[0] !== "archetype") continue;
-    if (typeof tag[1] !== "string" || tag[1].length === 0) continue;
-    out.push(
-      typeof tag[2] === "string" && tag[2].length > 0 ? { slug: tag[1], nap: tag[2] } : { slug: tag[1] }
-    );
+    const slug = tag[1];
+    if (typeof slug !== "string" || !/^[a-z0-9][a-z0-9-]*$/.test(slug)) {
+      throw new NappletResolutionError(
+        "invalid-manifest",
+        "archetype slug must contain lowercase letters, numbers, and hyphens"
+      );
+    }
+    const convention = tag[2];
+    if (typeof convention !== "string" || convention.length === 0) {
+      throw new NappletResolutionError("invalid-manifest", "archetype convention is required");
+    }
+    if (/^NAP-\d+$/.test(convention)) {
+      throw new NappletResolutionError(
+        "invalid-manifest",
+        "numbered NAP identifier is not an archetype convention"
+      );
+    }
+    const conventionMatch = /^napplet:([^/?#\s]+)\/([^/?#\s]+)$/.exec(convention);
+    if (!conventionMatch) {
+      throw new NappletResolutionError(
+        "invalid-manifest",
+        "archetype convention must be a queryless napplet:<archetype>/<intent> identity"
+      );
+    }
+    if (conventionMatch[1] !== slug) {
+      throw new NappletResolutionError(
+        "invalid-manifest",
+        "archetype slug must match the convention archetype"
+      );
+    }
+    if (tag.length !== 3) {
+      throw new NappletResolutionError(
+        "invalid-manifest",
+        "archetype tags must contain exactly slug and convention"
+      );
+    }
+    out.push({ slug, convention });
   }
   return out;
 }
@@ -18295,12 +19505,12 @@ async function resolvePajaPointer(value, options = {}) {
   const pointer = decodePajaPointer(value);
   const relays = uniqueRelayUrls([...pointer.relays, ...options.relays ?? []]);
   if (relays.length === 0) {
-    throw new Error("Pointer does not include relay hints; add a relay-bearing naddr or nevent.");
+    throw new Error("Pointer has no relay hints or enabled configured live relays.");
   }
   const pool = options.pool ?? new SimplePool();
   const ownsPool = options.pool === void 0;
   try {
-    const event = await resolvePointerEvent(pointer, pool, relays, options.maxWaitMs ?? 5e3);
+    const event = await resolvePointerEvent(pointer, pool, relays, normalizeMaxWaitMs(options.maxWaitMs));
     const blossomServers = [...options.blossomServers ?? []];
     const resolved = await resolveNapplet({
       event,
@@ -18329,7 +19539,26 @@ async function resolvePajaPointer(value, options = {}) {
   }
 }
 function injectPajaRuntimeCsp(html, origins) {
-  const value = origins.length > 0 ? `connect-src ${[...new Set(origins)].sort().join(" ")}` : "connect-src 'none'";
+  const grantedOrigins = [...new Set(origins)].sort();
+  const connectSrc = grantedOrigins.length > 0 ? `connect-src ${grantedOrigins.join(" ")}` : "connect-src 'none'";
+  const value = [
+    "default-src 'none'",
+    "script-src 'unsafe-inline'",
+    "style-src 'unsafe-inline'",
+    "img-src data: blob:",
+    "font-src data:",
+    connectSrc,
+    "worker-src 'none'",
+    "child-src 'none'",
+    "frame-src 'none'",
+    "media-src 'none'",
+    "object-src 'none'",
+    "manifest-src 'none'",
+    "prefetch-src 'none'",
+    "base-uri 'none'",
+    "form-action 'none'",
+    "frame-ancestors 'self'"
+  ].join("; ");
   const meta = `<meta http-equiv="Content-Security-Policy" content="${escapeAttribute(value)}">`;
   if (/<head[^>]*>/i.test(html)) {
     return html.replace(/<head[^>]*>/i, (open) => `${open}${meta}`);
@@ -18341,19 +19570,96 @@ function injectPajaRuntimeCsp(html, origins) {
 }
 async function resolvePointerEvent(pointer, pool, relays, maxWaitMs) {
   const filter = pointer.type === "naddr" ? addressableFilter(pointer) : eventFilter(pointer);
-  const events = await pool.querySync([...relays], filter, {
-    maxWait: maxWaitMs,
-    label: "kehto-paja-runtime"
-  });
-  const event = events.filter((candidate) => matchesPointer(pointer, candidate)).sort((a, b) => b.created_at - a.created_at)[0];
+  const result2 = await queryPointerRelays(pool, relays, filter, maxWaitMs);
+  const event = result2.events.filter((candidate) => matchesPointer(pointer, candidate)).sort((a, b) => b.created_at - a.created_at)[0];
   if (!event) {
-    throw new Error(`No napplet manifest event found for ${pointer.type} pointer.`);
+    if (result2.timedOut) {
+      throw new Error(
+        `Relay resolution timed out after ${maxWaitMs}ms for ${pointer.type} pointer across ${relays.length} relays before complete EOSE.`
+      );
+    }
+    const failures = relayFailureReasons(result2.reasons);
+    if (result2.error || failures.length > 0) {
+      const detail = result2.error instanceof Error ? result2.error.message : result2.error === void 0 ? failures.join("; ") : String(result2.error);
+      throw new Error(`Relay query failed for ${pointer.type} pointer before complete EOSE: ${detail}`);
+    }
+    throw new Error(
+      `All ${relays.length} relays reached EOSE without a matching ${pointer.type} napplet manifest event.`
+    );
   }
   if (!isNappletManifestKind(event.kind)) {
     throw new Error(`Pointer resolved kind ${event.kind}; expected ${formatNappletManifestKinds()}.`);
   }
   return event;
 }
+function queryPointerRelays(pool, relays, filter, maxWaitMs) {
+  if (pool.subscribeManyEose) {
+    return queryPointerRelaySubscription(pool, relays, filter, maxWaitMs);
+  }
+  return queryPointerRelaySync(pool, relays, filter, maxWaitMs);
+}
+function queryPointerRelaySubscription(pool, relays, filter, maxWaitMs) {
+  return new Promise((resolve) => {
+    const events = [];
+    let settled = false;
+    let subscription;
+    const finish = (result2) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(deadline);
+      resolve({ events, ...result2 });
+    };
+    const deadline = setTimeout(() => {
+      finish({ reasons: [], timedOut: true });
+      void subscription?.close("Paja pointer relay deadline exceeded");
+    }, maxWaitMs);
+    try {
+      subscription = pool.subscribeManyEose([...relays], filter, {
+        maxWait: maxWaitMs,
+        label: "kehto-paja-runtime",
+        onevent(event) {
+          events.push(event);
+        },
+        onclose(reasons) {
+          finish({ reasons, timedOut: false });
+        }
+      });
+    } catch (error) {
+      finish({ reasons: [], timedOut: false, error });
+    }
+  });
+}
+function queryPointerRelaySync(pool, relays, filter, maxWaitMs) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (result2) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(deadline);
+      resolve(result2);
+    };
+    const deadline = setTimeout(() => {
+      finish({ events: [], reasons: [], timedOut: true });
+    }, maxWaitMs);
+    void pool.querySync([...relays], filter, {
+      maxWait: maxWaitMs,
+      label: "kehto-paja-runtime"
+    }).then(
+      (events) => finish({ events, reasons: [], timedOut: false }),
+      (error) => finish({ events: [], reasons: [], timedOut: false, error })
+    );
+  });
+}
+function relayFailureReasons(reasons) {
+  return [...new Set(reasons.map((reason) => reason.trim()).filter((reason) => reason.length > 0 && reason !== "closed automatically on eose").map((reason) => reason.slice(0, 160)))].slice(0, 3);
+}
+function normalizeMaxWaitMs(value) {
+  if (value === void 0) return 5e3;
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error("Pointer relay deadline must be a positive number of milliseconds.");
+  }
+  return Math.floor(value);
+}
 function addressableFilter(pointer) {
   if (pointer.kind !== NAPPLET_KIND_NAMED) {
     throw new Error(`naddr kind ${pointer.kind} is not a named NIP-5D napplet manifest kind.`);
@@ -18413,7 +19719,192 @@ function formatNappletManifestKinds() {
   return PAJA_NAPPLET_MANIFEST_KINDS.join(" / ");
 }
 
+// src/browser-intent-host.ts
+function createPajaIntentTargetOptions(getState, getContext, effects = {}) {
+  return {
+    async openOrReuse(params) {
+      const state = getState();
+      const context = getContext();
+      if (!state || !context) return null;
+      const record = context.runtime.catalog.get(params.handler);
+      if (!record || !recordSupportsDelivery(record, params)) return null;
+      for (const stale of state.tabs) {
+        if (stale.resolvedTarget.dTag === params.handler && !matchesInstalledNappletRecord(record, stale.resolvedTarget)) closeRuntimeTab(state, context, stale.id);
+      }
+      const current = state.tabs.find(
+        (tab2) => matchesInstalledNappletRecord(record, tab2.resolvedTarget) && isCurrentRuntimeTabGeneration(state, context, tab2)
+      );
+      if (current && params.behavior?.newWindow !== true && params.behavior?.reuse !== false) {
+        return bindPajaIntentGeneration(current, record, context.runtime);
+      }
+      const resolved = await resolvePajaPointer(record.pointer.value, pajaPointerResolverOptions(context));
+      if (resolved.dTag !== record.dTag || resolved.aggregateHash !== record.aggregateHash || !resolvedSupportsDelivery(resolved, params)) return null;
+      const currentRecord = context.runtime.catalog.validateCurrent(record, resolved);
+      if (!currentRecord) return null;
+      const tab = addRuntimeTab(state, context, currentRecord.pointer.value, resolved);
+      effects.persistTabs?.(state);
+      return bindPajaIntentGeneration(tab, currentRecord, context.runtime);
+    },
+    waitForReady(generation) {
+      const state = getState();
+      const context = getContext();
+      if (!state || !context) return Promise.reject(new Error("Paja host is not available"));
+      const tab = findRuntimeTabGeneration(state, generation);
+      if (!tab || !isCurrentPajaIntentGeneration(generation, state, context, tab)) {
+        invalidatePajaIntentGeneration(generation, context.runtime);
+        return Promise.reject(new Error("intent target generation is not current"));
+      }
+      if (tab.windowId && context.runtime.readyWindowIds.has(tab.windowId)) return void 0;
+      return new Promise((resolve, reject2) => {
+        const waiters = context.runtime.readyWaiters.get(generation) ?? /* @__PURE__ */ new Set();
+        waiters.add({ resolve, reject: reject2 });
+        context.runtime.readyWaiters.set(generation, waiters);
+      });
+    },
+    isCurrent(generation) {
+      const state = getState();
+      const context = getContext();
+      const tab = state && context ? findRuntimeTabGeneration(state, generation) : null;
+      if (!tab || !state || !context || !isCurrentPajaIntentGeneration(generation, state, context, tab)) {
+        if (context) invalidatePajaIntentGeneration(generation, context.runtime);
+        return false;
+      }
+      return true;
+    },
+    getWindowId(generation) {
+      const state = getState();
+      const tab = state ? findRuntimeTabGeneration(state, generation) : null;
+      return tab?.windowId ?? null;
+    },
+    send(generation, params) {
+      const state = getState();
+      const context = getContext();
+      const tab = state && context ? findRuntimeTabGeneration(state, generation) : null;
+      if (!state || !context || !tab || !tab.windowId || !isCurrentPajaIntentGeneration(generation, state, context, tab)) {
+        if (context) invalidatePajaIntentGeneration(generation, context.runtime);
+        throw new Error("intent target generation is not current and ready");
+      }
+      const source = tab.frame.contentWindow;
+      if (!source || originRegistry.getWindowId(source) !== tab.windowId) {
+        throw new Error("intent target source is no longer registered");
+      }
+      createPajaPostMessageProxy(source, state, tab.windowId).postMessage({
+        type: "inc.event",
+        topic: params.convention,
+        sender: params.sender,
+        ...params.payload === void 0 ? {} : { payload: params.payload }
+      }, "*");
+    }
+  };
+}
+function pajaPointerResolverOptions(context) {
+  return {
+    relays: [
+      ...context.config.target.pointer?.relays ?? [],
+      ...getPajaRelayUrls(context.runtime.currentSimulation)
+    ],
+    blossomServers: context.config.target.pointer?.blossomServers ?? [],
+    maxWaitMs: context.config.target.pointer?.maxWaitMs
+  };
+}
+function recordSupportsDelivery(record, params) {
+  return record.archetypes.some(
+    (archetype) => archetype.slug === params.archetype && archetype.convention === params.convention
+  );
+}
+function resolvedSupportsDelivery(resolved, params) {
+  return resolved.manifest.archetypes.some(
+    (archetype) => archetype.slug === params.archetype && archetype.convention === params.convention
+  );
+}
+function findRuntimeTabGeneration(state, generation) {
+  return state.tabs.find((tab) => runtimeTabGenerationId(tab) === generation.id) ?? null;
+}
+function bindPajaIntentGeneration(tab, record, runtime) {
+  const generation = { id: runtimeTabGenerationId(tab) };
+  runtime.intentRecords.set(generation, record);
+  return generation;
+}
+function isCurrentPajaIntentGeneration(generation, state, context, tab) {
+  const record = context.runtime.intentRecords.get(generation);
+  return record !== void 0 && context.runtime.catalog.validateCurrent(record, tab.resolvedTarget) !== null && isCurrentRuntimeTabGeneration(state, context, tab);
+}
+function invalidatePajaIntentGeneration(generation, runtime) {
+  const waiters = runtime.readyWaiters.get(generation);
+  if (!waiters) return;
+  runtime.readyWaiters.delete(generation);
+  for (const waiter of waiters) waiter.reject(new Error("intent target catalog record was replaced"));
+}
+function subscribePajaIntentCatalogChanges(state, context) {
+  return context.runtime.catalog.onChanged((dTag) => {
+    for (const [generation] of context.runtime.readyWaiters) {
+      const record = context.runtime.intentRecords.get(generation);
+      if (!record || record.dTag !== dTag) continue;
+      const tab = findRuntimeTabGeneration(state, generation);
+      if (!tab || !isCurrentPajaIntentGeneration(generation, state, context, tab)) {
+        invalidatePajaIntentGeneration(generation, context.runtime);
+      }
+    }
+  });
+}
+function isCurrentRuntimeTabGeneration(state, context, tab) {
+  const source = tab.frame.contentWindow;
+  return state.tabs.includes(tab) && tab.windowId !== null && source !== null && originRegistry.getWindowId(source) === tab.windowId && runtimeTabGenerationId(tab) === `${tab.id}:${tab.generation}`;
+}
+function markRuntimeTabReady(state, context, tab, source, registeredWindowId, effects = {}) {
+  if (!tab.windowId || tab.frame.contentWindow !== source || registeredWindowId !== tab.windowId || !isCurrentRuntimeTabGeneration(state, context, tab)) return false;
+  context.runtime.readyWindowIds.add(tab.windowId);
+  for (const [generation, waiters] of context.runtime.readyWaiters) {
+    if (findRuntimeTabGeneration(state, generation) !== tab) continue;
+    context.runtime.readyWaiters.delete(generation);
+    if (!isCurrentPajaIntentGeneration(generation, state, context, tab)) {
+      for (const waiter of waiters) waiter.reject(new Error("intent target catalog record was replaced"));
+      continue;
+    }
+    for (const waiter of waiters) waiter.resolve();
+  }
+  tab.status = "ready";
+  if (state.activeTabId === tab.id) {
+    if (effects.setReadyStatus) effects.setReadyStatus(state);
+    else state.status = "ready";
+  }
+  renderRuntimeTabs(state);
+  return true;
+}
+function clearRuntimeTabGeneration(tab, runtime) {
+  for (const [generation, waiters] of runtime.readyWaiters) {
+    if (generation.id !== runtimeTabGenerationId(tab)) continue;
+    runtime.readyWaiters.delete(generation);
+    for (const waiter of waiters) waiter.reject(new Error("intent target generation replaced"));
+  }
+}
+
+// src/theme-broadcast.ts
+function createPajaThemeBroadcastLink() {
+  let attachedBridge;
+  return {
+    attach(bridge) {
+      if (attachedBridge) {
+        throw new Error("Paja theme broadcast link is already attached.");
+      }
+      attachedBridge = bridge;
+    },
+    onBroadcast(envelope) {
+      if (!attachedBridge) {
+        throw new Error("Paja theme broadcast occurred before a ShellBridge is attached.");
+      }
+      attachedBridge.publishTheme(envelope.theme);
+    }
+  };
+}
+
 // src/browser-target-frame.ts
+function resolvePajaFrameEnvironment(hooks, identity) {
+  if (!identity.dTag || !identity.aggregateHash) {
+    throw new Error("Paja frame identity requires a dTag and aggregate hash");
+  }
+  return resolveShellEnvironment(hooks, identity);
+}
 function getTargetIdentity2(config, resolvedTarget) {
   return {
     pubkey: "",
@@ -18421,18 +19912,21 @@ function getTargetIdentity2(config, resolvedTarget) {
     aggregateHash: resolvedTarget?.aggregateHash ?? config.window.aggregateHash
   };
 }
-function registerFrameForGeneration(_bridge, frame, config, generation, resolvedTarget, windowId = `${config.window.id}:${generation}`) {
+function getTargetOriginIdentity(config, resolvedTarget) {
+  const target = getTargetIdentity2(config, resolvedTarget);
+  return Object.freeze({ dTag: target.dTag, aggregateHash: target.aggregateHash });
+}
+function registerFrameForGeneration(frame, config, generation, identity, environment, windowId = `${config.window.id}:${generation}`) {
   const win = frame.contentWindow;
   if (!win) return null;
-  const identity = getTargetIdentity2(config, resolvedTarget);
-  originRegistry.register(win, windowId, {
-    dTag: identity.dTag,
-    aggregateHash: identity.aggregateHash
-  });
+  originRegistry.register(win, windowId, identity);
+  originRegistry.setEnvironment(win, environment);
   return windowId;
 }
-async function navigateFrame(bridge, frame, config, generation, capabilities, simulation, resolvedTarget, windowId, isCurrent) {
-  const domains = getInjectedDomains(capabilities, simulation, resolvedTarget);
+async function navigateFrame(frame, config, generation, adapter, resolvedTarget, windowId, isCurrent, onRegistered) {
+  const identity = getTargetOriginIdentity(config, resolvedTarget);
+  const environment = resolvePajaFrameEnvironment(adapter, identity);
+  const domains = environment.capabilities.domains;
   if (config.target.mode === "runtime-pointer") {
     if (!resolvedTarget) {
       frame.removeAttribute("src");
@@ -18440,7 +19934,8 @@ async function navigateFrame(bridge, frame, config, generation, capabilities, si
       return null;
     }
     if (isCurrent && !isCurrent()) return null;
-    const registeredWindowId2 = registerFrameForGeneration(bridge, frame, config, generation, resolvedTarget, windowId);
+    const registeredWindowId2 = registerFrameForGeneration(frame, config, generation, identity, environment, windowId);
+    onRegistered?.(registeredWindowId2);
     frame.removeAttribute("src");
     frame.srcdoc = injectNappletNamespacePrelude(
       injectPajaRuntimeCsp(
@@ -18453,7 +19948,8 @@ async function navigateFrame(bridge, frame, config, generation, capabilities, si
   }
   const html = await fetchTargetHtml();
   if (isCurrent && !isCurrent()) return null;
-  const registeredWindowId = registerFrameForGeneration(bridge, frame, config, generation, resolvedTarget, windowId);
+  const registeredWindowId = registerFrameForGeneration(frame, config, generation, identity, environment, windowId);
+  onRegistered?.(registeredWindowId);
   frame.removeAttribute("src");
   frame.srcdoc = injectNappletNamespacePrelude(
     injectBaseHref(html, config.target.url),
@@ -18480,21 +19976,6 @@ function connectOrigins(urls) {
   }
   return [...out];
 }
-function getInjectedDomains(capabilities, simulation, resolvedTarget) {
-  const available = capabilities.domains.filter((domain) => {
-    const knownDomain = domain;
-    return simulation.capabilities.domains[knownDomain] !== false;
-  });
-  const required = resolvedTarget?.manifest.requires ?? [];
-  const availableSet = new Set(available);
-  const optionalDomains = required.length === 0 ? available : required.filter((domain) => availableSet.has(domain));
-  return [
-    ...PAJA_HANDSHAKE_DOMAINS,
-    ...optionalDomains.filter(
-      (domain) => !PAJA_HANDSHAKE_DOMAINS.some((handshakeDomain) => handshakeDomain === domain)
-    )
-  ];
-}
 async function fetchTargetHtml() {
   const response = await fetch(new URL("./__kehto/target.html", window.location.href), {
     cache: "no-store",
@@ -18524,6 +20005,30 @@ function escapeHtml(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
 
+// src/browser-target-diagnostics.ts
+async function reportTargetCorsDiagnostic(state) {
+  let diagnostic;
+  try {
+    const response = await fetch(new URL("./__kehto/target-cors.json", window.location.href), {
+      cache: "no-store"
+    });
+    if (!response.ok) return;
+    diagnostic = await response.json();
+  } catch {
+    return;
+  }
+  if (diagnostic.status === "allowed") return;
+  appendPajaMessageLog(state, "paja", {
+    type: "paja.target.cors.error",
+    status: diagnostic.status,
+    targetUrl: diagnostic.targetUrl,
+    allowOrigin: diagnostic.allowOrigin,
+    message: `${diagnostic.detail} ${diagnostic.hint ?? ""}`.trim()
+  });
+  console.warn(`[paja] ${diagnostic.detail}
+[paja] ${diagnostic.hint ?? ""}`.trimEnd());
+}
+
 // src/browser-host.ts
 var bridgeRef = null;
 function readConfig() {
@@ -18621,68 +20126,22 @@ function getFrame() {
   frame.sandbox.remove("allow-same-origin");
   return frame;
 }
-function confirmPajaRequest(state, request) {
-  if (request.action === "upload") {
-    const filename = request.filename ?? "(unnamed blob)";
-    const mimeType = request.mimeType ?? "application/octet-stream";
-    const allowed3 = window.confirm([
-      "Paja upload request",
-      `napplet: ${request.napplet.dTag} (${request.windowId})`,
-      `file: ${filename}`,
-      `size: ${request.size} bytes`,
-      `type: ${mimeType}`,
-      `server: ${request.server}`,
-      request.warning
-    ].join("\n"));
-    appendPajaMessageLog(state, "paja", {
-      type: `paja.upload.${allowed3 ? "confirmed" : "denied"}`,
-      windowId: request.windowId,
-      dTag: request.napplet.dTag,
-      aggregateHash: request.napplet.aggregateHash,
-      filename,
-      size: request.size,
-      mimeType,
-      server: request.server,
-      warning: request.warning
-    });
-    return allowed3;
-  }
-  const event = request.event;
-  const kind = typeof event.kind === "number" ? event.kind : "unknown";
-  const content = typeof event.content === "string" && event.content.length > 0 ? `
-
-${event.content.slice(0, 240)}` : "";
-  const allowed2 = window.confirm(`Paja ${request.action} request
-kind: ${kind}${content}`);
-  appendPajaMessageLog(state, "paja", {
-    type: `paja.${request.action}.${allowed2 ? "confirmed" : "denied"}`,
-    kind
-  });
-  return allowed2;
-}
-function unregisterSingleFrameWindow(bridge, runtime, windowId) {
-  if (!windowId) return;
-  bridge.runtime.destroyWindow(windowId);
-  bridge.runtime.sessionRegistry.unregister(windowId);
-  originRegistry.unregister(windowId);
-  runtime.readyWindowIds.delete(windowId);
-  if (runtime.currentWindowId === windowId) runtime.currentWindowId = null;
-}
 function startFrameNavigation(state, context) {
-  const { config, frame, bridge, capabilities, runtime } = context;
+  const { config, frame, bridge, adapter, runtime } = context;
   if (!frame) return;
   const generation = state.generation;
   const isCurrentGeneration = () => state.generation === generation;
   void navigateFrame(
-    bridge,
     frame,
     config,
     generation,
-    capabilities,
-    runtime.currentSimulation,
+    adapter,
     state.resolvedTarget,
     void 0,
-    isCurrentGeneration
+    isCurrentGeneration,
+    (windowId) => {
+      if (isCurrentGeneration()) runtime.currentWindowId = windowId;
+    }
   ).then((windowId) => {
     if (!isCurrentGeneration()) {
       unregisterSingleFrameWindow(bridge, runtime, windowId);
@@ -18701,28 +20160,6 @@ function startFrameNavigation(state, context) {
     console.error(error);
   });
 }
-function createHostSignerController(getState) {
-  return createPajaSignerController({
-    confirmRequest: (request) => confirmPajaRequest(getState(), request),
-    onChange(signer) {
-      const state = getState();
-      if (!state) return;
-      state.signer = signer;
-      appendPajaMessageLog(state, "paja", {
-        type: `paja.signer.${signer.method}.${signer.status}`,
-        pubkey: signer.pubkey,
-        relay: signer.relay,
-        error: signer.error
-      });
-      setSimulationStatus(state);
-      if (signer.status === "connected") state.reload();
-    }
-  });
-}
-function hasNip07Signer() {
-  const signer = globalThis.nostr;
-  return typeof signer === "object" && signer !== null;
-}
 function installPajaControlListeners(state) {
   document.getElementById("reload-target")?.addEventListener("click", () => {
     state.reload();
@@ -18784,7 +20221,7 @@ function setRuntimeDomainEnabled(state, context, domain, enabled) {
   state.reload();
 }
 async function loadRuntimePointer(state, context, value, options = {}) {
-  const { config } = context;
+  const { config, runtime } = context;
   if (config.target.mode !== "runtime-pointer") return;
   const pointer = value.trim();
   const input = document.getElementById("runtime-pointer-input");
@@ -18798,11 +20235,8 @@ async function loadRuntimePointer(state, context, value, options = {}) {
   setStatus(state, "booting");
   appendPajaMessageLog(state, "paja", { type: "paja.pointer.resolve", pointer });
   try {
-    const resolvedTarget = await resolvePajaPointer(pointer, {
-      relays: config.target.pointer?.relays ?? [],
-      blossomServers: config.target.pointer?.blossomServers ?? [],
-      maxWaitMs: config.target.pointer?.maxWaitMs
-    });
+    const resolvedTarget = await resolvePajaPointer(pointer, pajaPointerResolverOptions(context));
+    runtime.catalog.install(resolvedTarget);
     const pointerStatus = `${resolvedTarget.dTag}:${resolvedTarget.aggregateHash.slice(0, 12)}`;
     setPointerStatus(state, pointerStatus);
     appendPajaMessageLog(state, "paja", {
@@ -18947,16 +20381,30 @@ async function installPajaHost() {
   const runtime = {
     currentSimulation: config.simulation,
     themeService: null,
+    catalog: new InstalledNappletCatalog(),
+    readyWaiters: /* @__PURE__ */ new Map(),
+    intentRecords: /* @__PURE__ */ new WeakMap(),
     currentWindowId: null,
     readyWindowIds: /* @__PURE__ */ new Set()
   };
   const getSimulation = () => runtime.currentSimulation;
+  const themeBroadcast = createPajaThemeBroadcastLink();
   let stateRef = null;
-  const signerController = createHostSignerController(() => stateRef);
+  let contextRef = null;
+  const intentController = new BrowserIntentController(createPajaIntentTargetOptions(
+    () => stateRef,
+    () => contextRef,
+    { persistTabs: persistRuntimeTabs }
+  ));
+  const signerController = createHostSignerController(() => stateRef, setSimulationStatus);
   const adapter = createPajaAdapter(config, getSimulation, (theme) => {
     runtime.themeService = theme;
-  }, (request) => confirmPajaRequest(stateRef, request), signerController, () => getTargetIdentity2(config, stateRef?.resolvedTarget));
+  }, themeBroadcast.onBroadcast, (request) => confirmPajaRequest(stateRef, request), signerController, () => getTargetIdentity2(config, stateRef?.resolvedTarget), () => stateRef?.reload(), {
+    catalog: runtime.catalog,
+    controller: intentController
+  });
   const bridge = createShellBridge(adapter);
+  themeBroadcast.attach(bridge);
   bridgeRef = bridge;
   installPajaOriginRegistryProxy(originRegistry, () => stateRef);
   const capabilities = buildShellCapabilities(adapter);
@@ -18970,21 +20418,25 @@ async function installPajaHost() {
     capabilities,
     runtime,
     navigateFrame,
-    registerFrameForGeneration,
     renderTargetErrorHtml,
+    onTabDestroyed: (tab) => clearRuntimeTabGeneration(tab, runtime),
     setPointerStatus: (state2, message) => setPointerStatus(state2, message),
     setStatus: (state2, status) => setStatus(state2, status)
   };
+  contextRef = context;
   const state = createPajaBrowserState(context);
   stateRef = state;
+  const stopIntentCatalogChanges = subscribePajaIntentCatalogChanges(state, context);
+  window.addEventListener("pagehide", stopIntentCatalogChanges, { once: true });
   window.__KEHTO_PAJA__ = state;
   window.addEventListener("message", (event) => {
     const source = event.source;
     const sourceTab = source ? state.tabs.find((tab) => tab.frame.contentWindow === source) ?? null : null;
     const isSingleFrameMessage = frame ? event.source === frame.contentWindow : false;
     if (!sourceTab && !isSingleFrameMessage) return;
-    const registeredWindowId = source ? originRegistry.getWindowId(source) : null;
+    const registeredWindowId = source ? originRegistry.getWindowId(source) ?? null : null;
     const sourceWindowId = sourceTab?.windowId ?? registeredWindowId ?? void 0;
+    if (sourceTab && (!source || !sourceWindowId || registeredWindowId !== sourceWindowId)) return;
     if (isSingleFrameMessage && (!sourceWindowId || sourceWindowId !== runtime.currentWindowId)) return;
     appendPajaMessageLog(state, "napplet->shell", event.data, sourceWindowId);
     const proxiedSource = createPajaPostMessageProxy(event.source, state, sourceWindowId);
@@ -18998,22 +20450,21 @@ async function installPajaHost() {
     bridge.handleMessage(syntheticEvent);
     const data = event.data;
     if (data && typeof data === "object" && data.type === "shell.ready") {
-      if (sourceWindowId) runtime.readyWindowIds.add(sourceWindowId);
       if (sourceTab) {
-        sourceTab.status = "ready";
-        if (state.activeTabId === sourceTab.id) setStatus(state, "ready");
-        renderRuntimeTabs(state);
+        if (source && !markRuntimeTabReady(
+          state,
+          context,
+          sourceTab,
+          source,
+          registeredWindowId,
+          { setReadyStatus: (current) => setStatus(current, "ready") }
+        )) return;
       } else {
+        if (sourceWindowId) runtime.readyWindowIds.add(sourceWindowId);
         setStatus(state, "ready");
       }
     }
   });
-  frame?.addEventListener("load", () => {
-    if (!frame) return;
-    if (state.status === "booting" || state.status === "reloading") {
-      runtime.currentWindowId = registerFrameForGeneration(bridge, frame, config, state.generation, state.resolvedTarget);
-    }
-  });
   frame?.addEventListener("error", () => {
     setStatus(state, "error");
   });
@@ -19034,20 +20485,28 @@ async function installPajaHost() {
     }
   } else {
     startFrameNavigation(state, context);
+    void reportTargetCorsDiagnostic(state);
   }
   if (hasNip07Signer()) void state.connectNip07();
 }
-try {
-  void installPajaHost().catch((error) => {
+if (typeof document !== "undefined") {
+  try {
+    void installPajaHost().catch((error) => {
+      const statusEl = document.getElementById("lifecycle-status");
+      if (statusEl) statusEl.textContent = "error";
+      console.error(error);
+    });
+  } catch (error) {
     const statusEl = document.getElementById("lifecycle-status");
     if (statusEl) statusEl.textContent = "error";
     console.error(error);
-  });
-} catch (error) {
-  const statusEl = document.getElementById("lifecycle-status");
-  if (statusEl) statusEl.textContent = "error";
-  console.error(error);
+  }
 }
+export {
+  createPajaIntentTargetOptions,
+  markRuntimeTabReady,
+  subscribePajaIntentCatalogChanges
+};
 /*! Bundled license information:
 
 @noble/hashes/utils.js: