@kehto/paja 0.10.0 → 0.11.0

package/dist/browser-host.js

@@ -1599,17 +1599,29 @@ function isRuntimeOwnedIdentityOrThemeRequest(type) {
 function createRuntimeOwnedResultEnvelope(type, id) {
   return Object.assign({ type }, { id });
 }
+function intentRequestDetails(message) {
+  const request = message.request;
+  return {
+    archetype: typeof request?.archetype === "string" ? request.archetype : "",
+    action: typeof request?.action === "string" && request.action.length > 0 ? request.action : "open"
+  };
+}
+function createIntentInvokeRejection(message, error) {
+  const id = message.id ?? "";
+  const { archetype, action } = intentRequestDetails(message);
+  return {
+    type: "intent.invoke.result",
+    id,
+    result: { ok: false, archetype, action, handled: false, error }
+  };
+}
 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" }
-    };
+    return createIntentInvokeRejection(message, "invoke rejected");
   }
   if (message.type === "intent.available" || message.type === "intent.handlers") {
     return {
@@ -1620,6 +1632,29 @@ function createIntentPolicyDenial(message) {
   }
   return void 0;
 }
+function createIntentServiceUnavailableResult(message) {
+  const id = message.id ?? "";
+  if (message.type === "intent.invoke") {
+    return createIntentInvokeRejection(message, "no handler");
+  }
+  if (message.type === "intent.available") {
+    const archetype = message.archetype;
+    return {
+      type: "intent.available.result",
+      id,
+      availability: {
+        archetype: typeof archetype === "string" ? archetype : "",
+        available: false,
+        candidates: [],
+        hasDefault: false
+      }
+    };
+  }
+  if (message.type === "intent.handlers") {
+    return { type: "intent.handlers.result", id, handlers: [] };
+  }
+  return void 0;
+}
 function createCanonicalDomainResult(message) {
   if (!isRuntimeOwnedIdentityOrThemeRequest(message.type)) return void 0;
   const id = message.id ?? "";
@@ -1766,6 +1801,7 @@ function createIncRuntime(hooks, sessionRegistry2, authorizeChannelOpen) {
     },
     revokeWindow(windowId) {
       revokeWindowChannels(state, hooks, windowId);
+      removeWindowSubscriptions(state, windowId);
     },
     clear() {
       state.subscriptions.clear();
@@ -1851,7 +1887,12 @@ function handleEmit(state, hooks, sessionRegistry2, windowId, m) {
   if (!subscribers) return;
   for (const subscriberWindowId of subscribers) {
     if (subscriberWindowId !== windowId) {
-      hooks.sendToNapplet(subscriberWindowId, { type: "inc.event", topic, payload: m.payload, sender });
+      hooks.sendToNapplet(subscriberWindowId, {
+        type: "inc.event",
+        topic,
+        sender,
+        ...m.payload === void 0 ? {} : { payload: m.payload }
+      });
     }
   }
 }
@@ -1914,7 +1955,12 @@ function handleChannelEmit(state, hooks, sessionRegistry2, windowId, m) {
   const peer = peerOf(state, m.channelId ?? "", windowId);
   const sender = sessionRegistry2.getEntryByWindowId(windowId)?.dTag;
   if (peer && sender) {
-    hooks.sendToNapplet(peer, { type: "inc.channel.event", channelId: m.channelId ?? "", sender, payload: m.payload });
+    hooks.sendToNapplet(peer, {
+      type: "inc.channel.event",
+      channelId: m.channelId ?? "",
+      sender,
+      ...m.payload === void 0 ? {} : { payload: m.payload }
+    });
   }
 }
 function handleChannelBroadcast(state, hooks, sessionRegistry2, windowId, m) {
@@ -1924,7 +1970,12 @@ function handleChannelBroadcast(state, hooks, sessionRegistry2, windowId, m) {
   for (const channelId of channels) {
     const peer = peerOf(state, channelId, windowId);
     if (peer) {
-      hooks.sendToNapplet(peer, { type: "inc.channel.event", channelId, sender, payload: m.payload });
+      hooks.sendToNapplet(peer, {
+        type: "inc.channel.event",
+        channelId,
+        sender,
+        ...m.payload === void 0 ? {} : { payload: m.payload }
+      });
     }
   }
 }
@@ -2250,7 +2301,13 @@ function handleServiceOnlyMessage(context, name, windowId, msg) {
     return;
   }
   const service = context.serviceRegistry[name];
-  if (!service) return;
+  if (!service) {
+    if (name === "intent") {
+      const result2 = createIntentServiceUnavailableResult(msg);
+      if (result2) context.hooks.sendToNapplet(windowId, result2);
+    }
+    return;
+  }
   service.handleMessage(windowId, msg, (resp) => context.hooks.sendToNapplet(windowId, resp));
 }
 function createRegisteredServices(serviceRegistry) {
@@ -2476,6 +2533,10 @@ function createRuntimeInstance(context) {
         sessionRegistry2.getAllEntries().map((entry) => entry.windowId)
       );
     },
+    hasCapability(windowId, capability) {
+      const entry = sessionRegistry2.getEntryByWindowId(windowId);
+      return !!entry && aclState.check("", entry.dTag, entry.aggregateHash, capability);
+    },
     sendToEligibleNapplet(windowId, message) {
       const entry = sessionRegistry2.getEntryByWindowId(windowId);
       if (!entry || typeof message.type !== "string") return false;
@@ -3979,9 +4040,14 @@ function nappletNamespacePrelude(domains) {
   function fire(message) {
     post(message);
   }
+  function isConventionTopic(topic) {
+    const pathEnd = topic.search(/[?#]/);
+    const path = pathEnd === -1 ? topic : topic.slice(0, pathEnd);
+    return /^napplet:[^/?#]+\/[^/?#]+$/.test(path);
+  }
   function normalizeConventionUri(topic, hasExplicitPayload) {
     if (typeof topic !== "string") throw new TypeError("INC topic must be text");
-    if (!topic.startsWith("napplet:")) return { topic };
+    if (!isConventionTopic(topic)) return { topic };
     if (topic.includes("#")) throw new TypeError("Convention topics cannot contain fragments");
     const queryStart = topic.indexOf("?");
     if (queryStart === -1) {
@@ -3990,7 +4056,7 @@ function nappletNamespacePrelude(domains) {
     if (hasExplicitPayload) {
       throw new TypeError("Convention queries cannot be combined with an explicit payload");
     }
-    const values = {};
+    const entries = [];
     const names = /* @__PURE__ */ new Set();
     const query = topic.slice(queryStart + 1);
     if (query) {
@@ -4009,10 +4075,10 @@ function nappletNamespacePrelude(domains) {
         }
         if (names.has(name)) throw new TypeError("Convention query names must be unique");
         names.add(name);
-        values[name] = value;
+        entries.push([name, value]);
       }
     }
-    return { topic: topic.slice(0, queryStart), payload: values };
+    return { topic: topic.slice(0, queryStart), payload: Object.fromEntries(entries) };
   }
   function resultOrError(msg) {
     return msg;
@@ -4171,7 +4237,7 @@ function nappletNamespacePrelude(domains) {
     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("#")) {
+      if (isConventionTopic(topic) && (topic.includes("?") || topic.includes("#"))) {
         throw new TypeError("INC subscriptions require a queryless topic identity");
       }
       return topic;
@@ -4192,7 +4258,6 @@ function nappletNamespacePrelude(domains) {
         },
         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);
@@ -10719,9 +10784,10 @@ function createOutboxService(options) {
   if (!options || typeof options.router !== "object" || options.router === null) {
     throw new Error("createOutboxService: options.router is required");
   }
-  const { router } = options;
+  const { router, getQueryRouter } = options;
+  let runtimeContext;
   const subscriptions = /* @__PURE__ */ new Map();
-  function handleQuery(msg, send) {
+  function handleQuery(windowId, msg, send) {
     const m = msg;
     const id = m.id ?? "";
     const filters = normalizeFilters(m.filters);
@@ -10729,7 +10795,8 @@ function createOutboxService(options) {
       send({ type: "outbox.query.result", id, events: [], error: "invalid filter" });
       return;
     }
-    void router.query(filters, sanitizeQueryOptions(m.options)).then(
+    const queryRouter = getQueryRouter?.(windowId, runtimeContext) ?? router;
+    void queryRouter.query(filters, sanitizeQueryOptions(m.options)).then(
       (result2) => send({
         type: "outbox.query.result",
         id,
@@ -10806,13 +10873,19 @@ function createOutboxService(options) {
   }
   return {
     descriptor: OUTBOX_DESCRIPTOR,
+    onRegistered(context) {
+      runtimeContext = context;
+    },
+    onUnregistered() {
+      runtimeContext = void 0;
+    },
     handleMessage(windowId, message, send) {
       switch (message.type) {
         case "outbox.getEvent":
           handleGetEvent(router, message, send);
           return;
         case "outbox.query":
-          handleQuery(message, send);
+          handleQuery(windowId, message, send);
           return;
         case "outbox.subscribe":
           handleSubscribe2(windowId, message, send);
@@ -12051,20 +12124,20 @@ function createCatalogIntentResolver(options) {
     }
   };
 }
-function actionFromConvention(slug, convention) {
-  if (!/^[a-z0-9][a-z0-9-]*$/.test(slug)) {
-    throw new TypeError("manifest archetype slug is invalid");
-  }
+function actionFromConvention(convention) {
   const match = /^napplet:([^/?#\s]+)\/([^/?#\s]+)$/.exec(convention);
-  if (!match || match[1] !== slug) {
-    throw new TypeError("manifest archetype convention is invalid or mismatched");
+  if (!match) {
+    throw new TypeError("manifest archetype convention is invalid");
   }
   return match[2];
 }
 function manifestToIntentCatalogEntry(manifest) {
   const archetypes = {};
   for (const { slug, convention } of manifest.archetypes) {
-    const action = actionFromConvention(slug, convention);
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(slug)) {
+      throw new TypeError("manifest archetype slug is invalid");
+    }
+    const action = actionFromConvention(convention);
     const support = archetypes[slug] ??= {
       actions: [],
       conventions: []
@@ -14503,7 +14576,9 @@ var SimplePool = class extends AbstractSimplePool {
 // src/browser-relay-runtime.ts
 var PAJA_NIP65_RELAY_LIST_KIND = 10002;
 var PAJA_CONTACT_LIST_KIND = 3;
+var PAJA_CONTACT_LIST_CANDIDATE_LIMIT = 64;
 var PAJA_LIVE_QUERY_WAIT_MS = 4e3;
+var contactListCandidateQueries = /* @__PURE__ */ new WeakMap();
 function matchesFilter2(event, filter) {
   const ids = filter.ids;
   if (ids && !ids.some((id) => event.id === id || event.id.startsWith(id))) return false;
@@ -14563,14 +14638,54 @@ function subscribeLive(pool, relayUrls, filters, next) {
     }
   };
 }
-async function queryLive(pool, relayUrls, filters, maxWaitMs = PAJA_LIVE_QUERY_WAIT_MS) {
+function queryLiveBounded(pool, relayUrls, filter, maxWaitMs, limit, signal) {
+  if (limit === 0 || signal?.aborted) return Promise.resolve([]);
+  return new Promise((resolve) => {
+    const events = [];
+    let settled = false;
+    let closeRequested = false;
+    let closeReason = "paja query limit reached";
+    let subscription;
+    let abort;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      if (abort) signal?.removeEventListener("abort", abort);
+      resolve(events);
+    };
+    const close = (reason = closeReason) => {
+      closeRequested = true;
+      closeReason = reason;
+      if (!subscription) return;
+      void Promise.resolve(subscription.close(reason)).catch(() => {
+      });
+      finish();
+    };
+    abort = () => close("paja query aborted");
+    signal?.addEventListener("abort", abort, { once: true });
+    subscription = pool.subscribeEose(relayUrls, filter, {
+      label: "kehto-paja-runtime",
+      maxWait: maxWaitMs,
+      onevent(event) {
+        if (events.length >= limit) return;
+        events.push(event);
+        if (events.length === limit) close();
+      },
+      onclose: finish
+    });
+    if (closeRequested) close();
+  });
+}
+async function queryLive(pool, relayUrls, filters, maxWaitMs = PAJA_LIVE_QUERY_WAIT_MS, collectUntilLimit = false, signal) {
   const activeFilters = filters.length > 0 ? filters : [{}];
-  const batches = await Promise.all(activeFilters.map(
-    (filter) => pool.querySync(relayUrls, filter, {
+  const batches = await Promise.all(activeFilters.map((filter) => {
+    const limit = typeof filter.limit === "number" && filter.limit >= 0 ? filter.limit : void 0;
+    if (collectUntilLimit && limit !== void 0) return queryLiveBounded(pool, relayUrls, filter, maxWaitMs, limit, signal);
+    return pool.querySync(relayUrls, filter, {
       label: "kehto-paja-runtime",
       maxWait: maxWaitMs
-    })
-  ));
+    });
+  }));
   const out = /* @__PURE__ */ new Map();
   for (const event of batches.flat()) out.set(event.id, event);
   return [...out.values()].sort((a, b) => b.created_at - a.created_at);
@@ -14591,6 +14706,14 @@ function createPajaRelayBackend(getSimulation, confirmRequest, livePool = new Si
     for (const event of [...memoryEvents, ...liveEvents]) out.set(event.id, event);
     return [...out.values()].sort((a, b) => b.created_at - a.created_at);
   };
+  const queryContactListCandidates = async (relayUrls, filters, maxWaitMs, signal) => {
+    const memoryEvents = collectMemoryEvents(events, filters);
+    if (signal?.aborted || getSimulation().relay.mode !== "live" || relayUrls.length === 0) return memoryEvents;
+    const liveEvents = await queryLive(livePool, relayUrls, filters, maxWaitMs, true, signal);
+    const out = /* @__PURE__ */ new Map();
+    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) {
@@ -14666,6 +14789,7 @@ function createPajaRelayBackend(getSimulation, confirmRequest, livePool = new Si
       livePool.destroy();
     }
   };
+  contactListCandidateQueries.set(backend, queryContactListCandidates);
   return backend;
 }
 function toNostrEvent(value) {
@@ -14705,19 +14829,25 @@ async function getBootstrapRelayUrls(getSimulation, signerProvider) {
     ...await getSignerRelayUrls(signerProvider, "read")
   ]);
 }
+function createPajaContactListLoader(backend, getSimulation, signerProvider) {
+  return async (pubkey, signal) => {
+    if (!/^[0-9a-fA-F]{64}$/.test(pubkey) || signal?.aborted) return [];
+    const relayUrls = await getBootstrapRelayUrls(getSimulation, signerProvider);
+    if (signal?.aborted) return [];
+    const filters = [{
+      kinds: [PAJA_CONTACT_LIST_KIND],
+      authors: [pubkey],
+      limit: PAJA_CONTACT_LIST_CANDIDATE_LIMIT
+    }];
+    const contactQuery = contactListCandidateQueries.get(backend);
+    const candidates = contactQuery ? await contactQuery(relayUrls, filters, PAJA_LIVE_QUERY_WAIT_MS, signal) : await backend.query(relayUrls, filters, PAJA_LIVE_QUERY_WAIT_MS);
+    if (signal?.aborted) return [];
+    return candidates.filter((event) => event.kind === PAJA_CONTACT_LIST_KIND && event.pubkey.toLowerCase() === pubkey.toLowerCase()).sort((left, right) => right.created_at - left.created_at || left.id.localeCompare(right.id)).slice(0, PAJA_CONTACT_LIST_CANDIDATE_LIMIT);
+  };
+}
 function latestEvent(events, kind, pubkey) {
   return events.filter((event) => event.kind === kind && event.pubkey === pubkey).sort((a, b) => b.created_at - a.created_at)[0];
 }
-function contactPubkeys(event) {
-  if (!event) return [];
-  const out = /* @__PURE__ */ new Set();
-  for (const tag of event.tags) {
-    if (tag[0] === "p" && typeof tag[1] === "string" && /^[0-9a-fA-F]{64}$/.test(tag[1])) {
-      out.add(tag[1].toLowerCase());
-    }
-  }
-  return [...out];
-}
 function createPajaRelayListLoader(backend, getSimulation, signerProvider) {
   const registry2 = createNip65Registry();
   return async (pubkeys) => {
@@ -14760,24 +14890,210 @@ function createPajaOutboxRelayPool(backend) {
     }
   };
 }
-function createPajaIdentityProviders(backend, getSimulation, signerProvider) {
-  const followsCache = /* @__PURE__ */ new Map();
+
+// src/browser-social-cache.ts
+var HEX_PUBKEY = /^[0-9a-f]{64}$/i;
+var FOLLOW_PARSE_YIELD_EVERY = 64;
+var PROFILE_WARM_YIELD_EVERY = 64;
+function createPajaSocialCache(options) {
+  let generation = 0;
+  let activeRefreshController;
+  const snapshots = /* @__PURE__ */ new Map();
+  async function loadFollows(capturedPubkey) {
+    const normalizedPubkey = normalizePubkey(capturedPubkey);
+    if (!normalizedPubkey) return [];
+    const existing = snapshots.get(normalizedPubkey);
+    if (existing) return [...existing.follows];
+    const capturedGeneration = generation;
+    const follows = await verifiedFollows(normalizedPubkey);
+    const warmed = snapshots.get(normalizedPubkey);
+    if (warmed) return [...warmed.follows];
+    if (generation === capturedGeneration) {
+      snapshots.set(normalizedPubkey, { follows, profiles: /* @__PURE__ */ new Map() });
+    }
+    return [...follows];
+  }
+  async function verifiedFollows(capturedPubkey, isStillCurrent, signal) {
+    const candidates = await options.loadContactList(capturedPubkey, signal);
+    const verified = [];
+    for (const candidate of candidates) {
+      if (isStillCurrent && !isStillCurrent()) return [];
+      if (!isContactCandidate(candidate, capturedPubkey)) continue;
+      try {
+        if (await options.verifyEvent(candidate)) verified.push(candidate);
+      } catch {
+      }
+    }
+    return contactPubkeys(selectReplacement(verified), isStillCurrent);
+  }
+  async function refreshActiveIdentity() {
+    activeRefreshController?.abort();
+    activeRefreshController = void 0;
+    const currentGeneration = ++generation;
+    const capturedPubkey = normalizePubkey(options.getActivePubkey() ?? "");
+    if (!capturedPubkey) return;
+    const controller = new AbortController();
+    activeRefreshController = controller;
+    const isStillCurrent = () => !controller.signal.aborted && isCurrent(capturedPubkey, currentGeneration);
+    try {
+      const follows = await verifiedFollows(capturedPubkey, isStillCurrent, controller.signal);
+      if (!isStillCurrent()) return;
+      const snapshot = { follows, profiles: /* @__PURE__ */ new Map() };
+      snapshots.set(capturedPubkey, snapshot);
+      for (let index = 0; index < follows.length; index += 1) {
+        if (!isStillCurrent()) return;
+        const author = follows[index];
+        let warmed;
+        try {
+          warmed = await options.baseRouter.query(
+            [{ kinds: [0], authors: [author], limit: 1 }],
+            { authors: [author], limit: 1 }
+          );
+        } catch {
+        }
+        if (!isStillCurrent()) return;
+        if (warmed) {
+          const profile = profileResult(warmed, author);
+          if (profile) snapshot.profiles.set(author, profile);
+        }
+        if ((index + 1) % PROFILE_WARM_YIELD_EVERY === 0 && index + 1 < follows.length) {
+          if (!isStillCurrent()) return;
+          await yieldToEventLoop();
+          if (!isStillCurrent()) return;
+        }
+      }
+    } catch {
+    } finally {
+      if (activeRefreshController === controller) activeRefreshController = void 0;
+    }
+  }
+  function isCurrent(capturedPubkey, currentGeneration) {
+    return generation === currentGeneration && normalizePubkey(options.getActivePubkey() ?? "") === capturedPubkey;
+  }
+  function decorate(router, canReadIdentity) {
+    return {
+      ...router.getEvent ? { getEvent: router.getEvent.bind(router) } : {},
+      async query(filters, queryOptions) {
+        const canAugmentAtStart = canReadIdentity?.() ?? true;
+        const activePubkey = normalizePubkey(options.getActivePubkey() ?? "");
+        const snapshot = canAugmentAtStart && activePubkey ? snapshots.get(activePubkey) : void 0;
+        const base = await router.query(filters, queryOptions);
+        if (!canAugmentAtStart || !(canReadIdentity?.() ?? true)) return base;
+        const cached = matchingCachedProfiles(snapshot?.profiles, filters);
+        return mergeResult(base, cached, filters, queryOptions);
+      },
+      subscribe: router.subscribe.bind(router),
+      publish: router.publish.bind(router),
+      resolveRelays: router.resolveRelays.bind(router)
+    };
+  }
+  const unsubscribe = options.subscribeSignerChange?.(() => {
+    void refreshActiveIdentity();
+  });
   return {
-    async getFollows(pubkey) {
-      if (!/^[0-9a-fA-F]{64}$/.test(pubkey)) return [];
-      const cached = followsCache.get(pubkey);
-      if (cached) return [...cached];
-      const events = await backend.query(await getBootstrapRelayUrls(getSimulation, signerProvider), [{
-        kinds: [PAJA_CONTACT_LIST_KIND],
-        authors: [pubkey],
-        limit: 1
-      }], PAJA_LIVE_QUERY_WAIT_MS);
-      const follows = contactPubkeys(latestEvent(events, PAJA_CONTACT_LIST_KIND, pubkey));
-      followsCache.set(pubkey, follows);
-      return [...follows];
+    getFollows: loadFollows,
+    refreshActiveIdentity,
+    decorate,
+    dispose: () => {
+      activeRefreshController?.abort();
+      unsubscribe?.();
+    }
+  };
+}
+function normalizePubkey(value) {
+  return typeof value === "string" && HEX_PUBKEY.test(value) ? value.toLowerCase() : null;
+}
+function isContactCandidate(candidate, capturedPubkey) {
+  if (typeof candidate !== "object" || candidate === null) return false;
+  const event = candidate;
+  return event.kind === 3 && normalizePubkey(event.pubkey) === capturedPubkey;
+}
+function selectReplacement(events) {
+  return [...events].sort((left, right) => {
+    const timestampOrder = right.created_at - left.created_at;
+    if (timestampOrder !== 0) return timestampOrder;
+    if (left.id === right.id) return 0;
+    return left.id < right.id ? -1 : 1;
+  })[0];
+}
+async function contactPubkeys(event, isStillCurrent) {
+  if (!event || !Array.isArray(event.tags)) return [];
+  const follows = /* @__PURE__ */ new Set();
+  for (let index = 0; index < event.tags.length; index += 1) {
+    if (isStillCurrent && !isStillCurrent()) return [];
+    const tag = event.tags[index];
+    if (Array.isArray(tag) && tag[0] === "p") {
+      const pubkey = normalizePubkey(tag[1]);
+      if (pubkey) follows.add(pubkey);
+    }
+    if ((index + 1) % FOLLOW_PARSE_YIELD_EVERY === 0 && index + 1 < event.tags.length) {
+      await yieldToEventLoop();
+      if (isStillCurrent && !isStillCurrent()) return [];
+    }
+  }
+  return [...follows];
+}
+function profileResult(result2, author) {
+  let newest;
+  for (const entry of result2.events) {
+    if (entry.event.kind !== 0 || normalizePubkey(entry.event.pubkey) !== author) continue;
+    if (!newest || isNewerProfile(entry, newest)) newest = entry;
+  }
+  return newest;
+}
+function isNewerProfile(candidate, existing) {
+  if (candidate.event.created_at !== existing.event.created_at) {
+    return candidate.event.created_at > existing.event.created_at;
+  }
+  return candidate.event.id < existing.event.id;
+}
+function yieldToEventLoop() {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+function matchingCachedProfiles(profiles, filters) {
+  const readyProfiles = profiles ? [...profiles.values()] : [];
+  if (filters.length === 0) return readyProfiles;
+  const matched = /* @__PURE__ */ new Map();
+  for (const filter of filters) {
+    const limit = typeof filter.limit === "number" && filter.limit >= 0 ? filter.limit : void 0;
+    let count = 0;
+    for (const entry of readyProfiles) {
+      if (!matchesAnyFilter2(entry.event, [filter])) continue;
+      if (limit !== void 0 && count >= limit) continue;
+      count += 1;
+      if (!matched.has(entry.event.id)) matched.set(entry.event.id, entry);
     }
+  }
+  return [...matched.values()];
+}
+function mergeResult(base, cached, filters, queryOptions) {
+  const events = /* @__PURE__ */ new Map();
+  for (const entry of base.events) events.set(entry.event.id, entry);
+  for (const entry of cached) {
+    if (!events.has(entry.event.id)) events.set(entry.event.id, entry);
+  }
+  return {
+    events: applyFinalLimits([...events.values()], filters, queryOptions),
+    ...base.incomplete === void 0 ? {} : { incomplete: base.incomplete },
+    ...base.error === void 0 ? {} : { error: base.error }
   };
 }
+function applyFinalLimits(entries, filters, queryOptions) {
+  const aggregateLimit = typeof queryOptions?.limit === "number" && queryOptions.limit >= 0 ? queryOptions.limit : void 0;
+  const aggregateCapped = aggregateLimit === void 0 ? entries : entries.slice(0, aggregateLimit);
+  if (filters.length === 0) return aggregateCapped;
+  const counts = filters.map(() => 0);
+  return aggregateCapped.filter((entry) => {
+    const matching = filters.flatMap((filter, index) => matchesAnyFilter2(entry.event, [filter]) ? [index] : []);
+    const allowed2 = matching.some((index) => {
+      const limit = filters[index]?.limit;
+      return typeof limit !== "number" || limit < 0 || counts[index] < limit;
+    });
+    if (!allowed2) return false;
+    for (const index of matching) counts[index] += 1;
+    return true;
+  });
+}
 
 // src/browser-adapter.ts
 var DEV_COMMON_PUBKEY = "1".repeat(64);
@@ -14951,7 +15267,7 @@ function createDevSigner(getSimulation, confirmRequest) {
   };
 }
 function getRuntimePubkey(getSimulation, signerProvider) {
-  return getSimulation().identity.pubkey || signerProvider?.getPubkey() || (signerProvider?.getMethod() === "dev" ? PAJA_DEV_SIGNER_PUBKEY : "");
+  return signerProvider?.getPubkey() || (signerProvider?.getMethod() === "dev" ? PAJA_DEV_SIGNER_PUBKEY : "") || getSimulation().identity.pubkey;
 }
 function createRuntimeSigner(getSimulation, confirmRequest, signerProvider) {
   const signer = signerProvider?.getSigner();
@@ -14988,6 +15304,15 @@ function createDevServices(backend, getSimulation, onThemeService, onThemeBroadc
       }
     })
   });
+  const baseOutboxRouter = createOutboxRouter(backend, getSimulation, confirmRequest, signerProvider);
+  const socialCache = createPajaSocialCache({
+    baseRouter: baseOutboxRouter,
+    loadContactList: createPajaContactListLoader(backend, getSimulation, signerProvider),
+    verifyEvent: (event) => verifyEvent(event),
+    getActivePubkey: () => getRuntimePubkey(getSimulation, signerProvider),
+    subscribeSignerChange: signerProvider?.subscribe?.bind(signerProvider)
+  });
+  void socialCache.refreshActiveIdentity();
   const services = {
     keys: createKeysService(),
     resource: createResourceService({
@@ -15008,7 +15333,13 @@ function createDevServices(backend, getSimulation, onThemeService, onThemeBroadc
       selectRelayTier: () => getPajaRelayUrls(getSimulation()),
       isAvailable: () => backend.isAvailable()
     });
-    services.outbox = createOutboxService({ router: createOutboxRouter(backend, getSimulation, confirmRequest, signerProvider) });
+    services.outbox = createOutboxService({
+      router: baseOutboxRouter,
+      getQueryRouter: (windowId, context) => socialCache.decorate(
+        baseOutboxRouter,
+        () => context?.hasCapability(windowId, "identity:read") ?? false
+      )
+    });
   }
   if (getSimulation().capabilities.domains.count && typeof backend.count === "function") {
     services.count = createCountService({
@@ -15032,7 +15363,7 @@ function createDevServices(backend, getSimulation, onThemeService, onThemeBroadc
   if (getSimulation().capabilities.domains.identity) {
     services.identity = createIdentityService({
       getSigner: () => createRuntimeSigner(getSimulation, confirmRequest, signerProvider),
-      ...createPajaIdentityProviders(backend, getSimulation, signerProvider)
+      getFollows: socialCache.getFollows
     });
   }
   if (getSimulation().notifications.enabled) {
@@ -18901,7 +19232,7 @@ function aggregateTagValue(tags) {
   return void 0;
 }
 
-// ../nip/dist/chunk-ZQSTY6HR.js
+// ../nip/dist/chunk-YIG2IRN2.js
 var MIB = 1024 * 1024;
 var NAPPLET_ARTIFACT_CACHE_NAME = "kehto:napplet-artifacts:v1";
 var SCHEMA_VERSION = 1;
@@ -19388,10 +19719,14 @@ function parseNappletManifest(event) {
   if (!aggregateHash) {
     throw new NappletResolutionError("invalid-manifest", "manifest has no aggregate x tag");
   }
+  const dTag = firstTagValue(event.tags, "d");
+  if (event.kind !== NAPPLET_KIND_NAMED && dTag !== void 0) {
+    throw new NappletResolutionError("invalid-manifest", "only named manifests may carry a d tag");
+  }
   return {
     kind: event.kind,
     pubkey: event.pubkey,
-    dTag: firstTagValue(event.tags, "d") ?? "",
+    dTag: dTag ?? "",
     paths,
     aggregateHash,
     servers: allTagValues(event.tags, "server"),