@kehto/paja 0.9.0 → 0.11.0

package/dist/browser-host.js

@@ -262,7 +262,7 @@ function uploadMap(action) {
   return { senderCap: "upload:write", recipientCap: null };
 }
 function intentMap(action) {
-  if (action === "changed" || action === "deliver" || action === "invoke.result" || action === "available.result" || action === "handlers.result") {
+  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 };
@@ -623,7 +623,7 @@ function deserialize2(json) {
   return defaultConfig();
 }
 
-// ../../node_modules/.pnpm/@napplet+core@0.29.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) {
@@ -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);
@@ -4862,77 +4927,57 @@ function nappletNamespacePrelude(domains) {
     };
   }
   function makeIntent() {
-    const deliveryHandlers = /* @__PURE__ */ new Set();
-    const pendingDeliveries = [];
     const hasOwn2 = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
-    const normalizeDelivery = (value) => {
-      if (!value || typeof value !== "object" || typeof value.sender !== "string" || typeof value.archetype !== "string" || typeof value.action !== "string" || typeof value.convention !== "string") {
-        return void 0;
+    const normalizeRequest = (value) => {
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new TypeError("Intent request must be an object");
       }
-      const delivery = value;
-      return {
-        sender: delivery.sender,
-        archetype: delivery.archetype,
-        action: delivery.action,
-        convention: delivery.convention,
-        ...hasOwn2(delivery, "payload") ? { payload: delivery.payload } : {}
-      };
-    };
-    listen((event) => {
-      if (!isParentMessage(event)) return;
-      const msg = event.data;
-      if (typeof msg !== "object" || msg === null || msg.type !== "intent.deliver") return;
-      const delivery = normalizeDelivery(msg.delivery);
-      if (!delivery) return;
-      if (deliveryHandlers.size === 0) pendingDeliveries.push(delivery);
-      else for (const handler of deliveryHandlers) handler(delivery);
-    });
-    function normalizeIntentUri(uri, explicitPayload, actionMustBe) {
-      if (typeof uri !== "string" || !uri.startsWith("napplet:")) {
-        throw new TypeError("Intent convention URI must start with napplet:");
+      const supplied = value;
+      if (hasOwn2(supplied, "sender")) {
+        throw new TypeError("Intent callers cannot supply sender");
       }
-      if (uri.includes("#")) throw new TypeError("Intent convention URI cannot contain fragments");
-      const normalized = normalizeConventionUri(uri, explicitPayload);
-      const match = /^napplet:([^/?#]+)\/([^/?#]+)$/.exec(normalized.topic);
-      if (!match) throw new TypeError("Intent convention URI must be napplet:<archetype>/<intent>");
-      if (actionMustBe !== void 0 && match[2] !== actionMustBe) {
-        throw new TypeError(`Intent convention URI must use the ${actionMustBe} intent`);
+      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");
       }
-      return {
-        archetype: match[1],
-        action: match[2],
-        convention: normalized.topic,
-        ...normalized.payload === void 0 ? {} : { payload: normalized.payload }
-      };
-    }
-    const invoke = (uri, opts, actionMustBe) => {
-      const supplied = opts && typeof opts === "object" ? opts : void 0;
-      const explicitPayload = supplied?.payload !== void 0;
-      const normalized = normalizeIntentUri(uri, explicitPayload, actionMustBe);
-      if (supplied && hasOwn2(supplied, "sender")) {
-        throw new TypeError("Intent callers cannot supply sender");
+      if (typeof supplied.archetype !== "string" || supplied.archetype.length === 0) {
+        throw new TypeError("Intent request requires an archetype");
       }
-      for (const field of ["archetype", "action", "convention"]) {
-        if (supplied && hasOwn2(supplied, field) && supplied[field] !== normalized[field]) {
-          throw new TypeError(`Intent options cannot override URI-derived ${field}`);
-        }
+      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 } : {}
       };
-      const handler = typeof supplied?.handler === "string" ? supplied.handler : void 0;
+      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,
-            ...explicitPayload ? { payload: supplied?.payload } : {},
-            ...handler === void 0 ? {} : { handler },
-            ...Object.keys(sanitizedBehavior).length === 0 ? {} : { behavior: sanitizedBehavior }
-          }
+          request: normalized
         },
         "intent.invoke.result",
         (msg) => fieldOrThrow(msg, "result", "intent.invoke.result missing result")
@@ -4940,7 +4985,12 @@ function nappletNamespacePrelude(domains) {
     };
     return {
       invoke,
-      open: (uri, opts) => invoke(uri, opts, "open"),
+      open: (archetype, payload, opts) => invoke({
+        archetype,
+        action: "open",
+        ...payload === void 0 ? {} : { payload },
+        ...opts
+      }),
       available: (archetype) => request(
         { type: "intent.available", archetype },
         "intent.available.result",
@@ -4955,14 +5005,7 @@ function nappletNamespacePrelude(domains) {
         "intent.changed",
         callback,
         (msg) => msg.availability
-      ),
-      onDelivery: (callback) => {
-        if (typeof callback !== "function") throw new TypeError("Intent delivery handler must be a function");
-        deliveryHandlers.add(callback);
-        const pending = pendingDeliveries.splice(0);
-        for (const delivery of pending) callback(delivery);
-        return subscriptionHandle(() => deliveryHandlers.delete(callback));
-      }
+      )
     };
   }
   function makeWebrtc() {
@@ -10741,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);
@@ -10751,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,
@@ -10828,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);
@@ -11721,14 +11772,17 @@ function hasOwn(value, key) {
 }
 function validateIntentRequest(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return { error: "invalid convention" };
+    return { error: "invalid request" };
   }
   const request = value;
-  if (typeof request.archetype !== "string" || request.archetype.length === 0 || typeof request.action !== "string" || request.action.length === 0 || typeof request.convention !== "string" || request.convention.length === 0) {
-    return { error: "invalid convention" };
+  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" };
   }
-  const match = /^napplet:([^/?#\s]+)\/([^/?#\s]+)$/.exec(request.convention);
-  if (!match || match[1] !== request.archetype || match[2] !== request.action) {
+  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"];
@@ -11744,19 +11798,20 @@ function validateIntentRequest(value) {
       return { error: "invoke rejected" };
     }
     const record = request.behavior;
-    if (Object.keys(record).some((key) => key !== "focus" && key !== "reuse") || hasOwn(record, "focus") && typeof record.focus !== "boolean" || hasOwn(record, "reuse") && typeof record.reuse !== "boolean") {
+    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: request.action,
-      convention: request.convention,
+      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 }
@@ -11773,11 +11828,20 @@ function settleResolverCall(call, send, resultType, id, onValue) {
   }
   pending.then((value) => send(onValue(value))).catch((error) => send({ type: resultType, id, error: toErrorMessage4(error) }));
 }
-function rejectInvoke(send, id) {
+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: { ok: false, error: "invoke rejected" }
+    result: rejectedResult(request, error)
   });
 }
 function createIntentService(options) {
@@ -11792,46 +11856,40 @@ function createIntentService(options) {
     const id = m.id ?? "";
     const validation = validateIntentRequest(m.request);
     if ("error" in validation) {
-      send({
-        type: "intent.invoke.result",
+      const raw = typeof m.request === "object" && m.request !== null ? m.request : {};
+      rejectInvoke(
+        send,
         id,
-        result: { ok: false, error: validation.error }
-      });
+        {
+          archetype: typeof raw.archetype === "string" ? raw.archetype : "",
+          action: typeof raw.action === "string" ? raw.action : "open"
+        },
+        validation.error
+      );
       return;
     }
     const sender = runtimeContext?.resolveDTag(windowId);
     if (!sender) {
-      rejectInvoke(send, id);
+      rejectInvoke(send, id, validation.request);
       return;
     }
     let pending;
     try {
       pending = Promise.resolve(resolver.invoke(validation.request, { sender }));
     } catch {
-      rejectInvoke(send, id);
+      rejectInvoke(send, id, validation.request);
       return;
     }
     void pending.then(
-      (outcome) => {
-        if (outcome.result.ok && (!("retained" in outcome) || typeof outcome.retained.start !== "function")) {
-          rejectInvoke(send, id);
-          return;
-        }
+      (result2) => {
         send({
           type: "intent.invoke.result",
           id,
-          result: outcome.result
+          result: result2
         });
-        if (!outcome.result.ok || !("retained" in outcome)) return;
-        try {
-          const started = outcome.retained.start();
-          void Promise.resolve(started).catch(() => {
-          });
-        } catch {
-        }
       },
       () => {
-        rejectInvoke(send, id);
+        rejectInvoke(send, id, validation.request);
       }
     ).catch(() => {
     });
@@ -11916,128 +11974,134 @@ function candidatesFor(catalog, archetype, defaultHandler) {
       ...entry.title === void 0 ? {} : { title: entry.title },
       actions: [...support.actions],
       conventions: [...support.conventions],
-      contracts: support.contracts.map((contract) => ({
-        convention: contract.convention,
-        ...contract.eventKinds === void 0 ? {} : { eventKinds: [...contract.eventKinds] }
-      })),
       ...entry.dTag === defaultHandler ? { isDefault: true } : {}
     });
   }
   return candidates;
 }
-function reject(error) {
-  return { ok: false, error };
+function reject(request, error) {
+  return {
+    ok: false,
+    archetype: request.archetype,
+    action: request.action ?? "open",
+    handled: false,
+    error
+  };
+}
+async function availabilityForCatalog(options, archetype) {
+  const catalog = await options.loadCatalog();
+  const defaultHandler = options.getDefaultHandler?.(archetype);
+  const candidates = candidatesFor(catalog, archetype, defaultHandler);
+  return {
+    archetype,
+    available: candidates.length > 0,
+    candidates,
+    hasDefault: defaultHandler !== void 0 && candidates.some((candidate) => candidate.dTag === defaultHandler)
+  };
+}
+async function chooseCompatible(options, request, candidates, sender) {
+  if (!options.chooseHandler) {
+    return request.handler === "choose" ? { error: "user cancelled" } : { error: "invoke rejected" };
+  }
+  const picked = await options.chooseHandler(request.archetype, candidates, sender);
+  if (picked === void 0) return { error: "user cancelled" };
+  const candidate = candidates.find((item) => item.dTag === picked);
+  return candidate ? { candidate } : { error: "invoke rejected" };
+}
+async function pickHandler(options, request, compatible, sender) {
+  const preference = request.handler;
+  if (typeof preference === "string" && preference !== "default" && preference !== "choose") {
+    const candidate = compatible.find((item) => item.dTag === preference);
+    if (!candidate || !options.authorizeExplicitHandler) return { error: "invoke rejected" };
+    let authorized = false;
+    try {
+      authorized = await options.authorizeExplicitHandler(
+        sender,
+        preference,
+        request,
+        candidate
+      );
+    } catch {
+      return { error: "invoke rejected" };
+    }
+    return authorized ? { candidate } : { error: "invoke rejected" };
+  }
+  if (preference === "choose") {
+    return chooseCompatible(options, request, compatible, sender);
+  }
+  const defaultCandidate = compatible.find((candidate) => candidate.isDefault === true);
+  if (preference === "default") {
+    return defaultCandidate ? { candidate: defaultCandidate } : { error: "invoke rejected" };
+  }
+  if (defaultCandidate) return { candidate: defaultCandidate };
+  if (compatible.length === 1) return { candidate: compatible[0] };
+  return chooseCompatible(options, request, compatible, sender);
+}
+async function invokeFromCatalog(options, request, context) {
+  const catalog = await options.loadCatalog();
+  const defaultHandler = options.getDefaultHandler?.(request.archetype);
+  const candidates = candidatesFor(catalog, request.archetype, defaultHandler);
+  if (candidates.length === 0) return reject(request, "no handler");
+  const action = request.action ?? "open";
+  const actionCompatible = candidates.filter((candidate) => candidate.actions.includes(action));
+  if (actionCompatible.length === 0) return reject(request, "unsupported action");
+  const compatible = request.convention === void 0 ? actionCompatible : actionCompatible.filter((candidate) => candidate.conventions.includes(request.convention));
+  if (compatible.length === 0) return reject(request, "unsupported convention");
+  const sender = context.sender;
+  if (typeof sender !== "string" || sender.length === 0) {
+    return reject(request, "invoke rejected");
+  }
+  const selected = await pickHandler(options, request, compatible, sender);
+  if ("error" in selected) return reject(request, selected.error);
+  const convention = request.convention ?? selected.candidate.conventions.find((value) => {
+    const match = /^napplet:[^/?#\s]+\/([^/?#\s]+)$/.exec(value);
+    return match?.[1] === action;
+  });
+  if (!convention) return reject(request, "unsupported convention");
+  const behavior = request.behavior === void 0 ? void 0 : Object.freeze({
+    ...request.behavior.focus === void 0 ? {} : { focus: request.behavior.focus },
+    ...request.behavior.newWindow === void 0 ? {} : { newWindow: request.behavior.newWindow },
+    ...request.behavior.reuse === void 0 ? {} : { reuse: request.behavior.reuse }
+  });
+  const params = Object.freeze({
+    handler: selected.candidate.dTag,
+    sender,
+    archetype: request.archetype,
+    action,
+    convention,
+    ...request.payload === void 0 ? {} : { payload: request.payload },
+    ...behavior === void 0 ? {} : { behavior }
+  });
+  let target;
+  try {
+    target = await options.targets.dispatch(params);
+  } catch {
+    return reject(request, "invoke failed");
+  }
+  if (!target || typeof target.windowId !== "string" || target.windowId.length === 0) {
+    return reject(request, "invoke failed");
+  }
+  return {
+    ok: true,
+    archetype: request.archetype,
+    action,
+    handled: true,
+    handler: selected.candidate.dTag,
+    windowId: target.windowId,
+    convention
+  };
 }
 function createCatalogIntentResolver(options) {
   if (!options || typeof options.loadCatalog !== "function") {
     throw new Error("createCatalogIntentResolver: options.loadCatalog is required");
   }
-  if (!options.targets || typeof options.targets.retain !== "function") {
+  if (!options.targets || typeof options.targets.dispatch !== "function") {
     throw new Error("createCatalogIntentResolver: options.targets is required");
   }
-  const {
-    loadCatalog,
-    targets,
-    getDefaultHandler,
-    chooseHandler,
-    authorizeExplicitHandler
-  } = options;
   const listeners = /* @__PURE__ */ new Set();
-  async function availabilityFor(archetype) {
-    const catalog = await loadCatalog();
-    const defaultHandler = 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(request, candidates, sender) {
-    if (!chooseHandler) {
-      return request.handler === "choose" ? { error: "user cancelled" } : { error: "invoke rejected" };
-    }
-    const picked = await 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(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 || !authorizeExplicitHandler) return { error: "invoke rejected" };
-      let authorized = false;
-      try {
-        authorized = await authorizeExplicitHandler(sender, preference, request, candidate);
-      } catch {
-        return { error: "invoke rejected" };
-      }
-      return authorized ? { candidate } : { error: "invoke rejected" };
-    }
-    if (preference === "choose") {
-      return chooseCompatible(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(request, compatible, sender);
-  }
-  async function invoke(request, context) {
-    const catalog = await loadCatalog();
-    const defaultHandler = getDefaultHandler?.(request.archetype);
-    const candidates = candidatesFor(catalog, request.archetype, defaultHandler);
-    if (candidates.length === 0) return { result: reject("no handler") };
-    const compatible = candidates.filter((candidate) => candidate.contracts.some((contract) => contract.convention === request.convention));
-    if (compatible.length === 0) return { result: reject("unsupported convention") };
-    const sender = context.sender;
-    if (typeof sender !== "string" || sender.length === 0) {
-      return { result: reject("invoke rejected") };
-    }
-    const selected = await pickHandler(request, compatible, sender);
-    if ("error" in selected) return { result: reject(selected.error) };
-    const delivery = Object.freeze({
-      sender,
-      archetype: request.archetype,
-      action: request.action,
-      convention: request.convention,
-      ...request.payload === void 0 ? {} : { payload: request.payload }
-    });
-    const behavior = request.behavior === void 0 ? void 0 : Object.freeze({
-      ...request.behavior.focus === void 0 ? {} : { focus: request.behavior.focus },
-      ...request.behavior.reuse === void 0 ? {} : { reuse: request.behavior.reuse }
-    });
-    const params = Object.freeze({
-      handler: selected.candidate.dTag,
-      delivery,
-      ...behavior === void 0 ? {} : { behavior }
-    });
-    let retained;
-    try {
-      retained = await targets.retain(params);
-    } catch {
-      return { result: reject("invoke rejected") };
-    }
-    if (!retained || typeof retained.start !== "function") {
-      return { result: reject("invoke rejected") };
-    }
-    return {
-      result: {
-        ok: true,
-        archetype: request.archetype,
-        action: request.action,
-        convention: request.convention,
-        handler: selected.candidate.dTag
-      },
-      retained
-    };
-  }
+  const availabilityFor = (archetype) => availabilityForCatalog(options, archetype);
   async function handlers() {
-    const catalog = await loadCatalog();
+    const catalog = await options.loadCatalog();
     const archetypes = /* @__PURE__ */ new Set();
     for (const entry of catalog) {
       for (const slug of Object.keys(entry.archetypes)) archetypes.add(slug);
@@ -12045,7 +12109,7 @@ function createCatalogIntentResolver(options) {
     return Promise.all([...archetypes].map((archetype) => availabilityFor(archetype)));
   }
   return {
-    invoke,
+    invoke: (request, context) => invokeFromCatalog(options, request, context),
     available: availabilityFor,
     handlers,
     onChanged(listener) {
@@ -12060,33 +12124,24 @@ 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, eventKinds } of manifest.archetypes) {
-    const action = actionFromConvention(slug, convention);
-    if (eventKinds?.some((kind) => !Number.isSafeInteger(kind) || kind < 0)) {
-      throw new TypeError("manifest archetype event kinds must be unsigned safe integers");
+  for (const { slug, convention } of manifest.archetypes) {
+    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: [],
-      contracts: []
+      conventions: []
     };
-    const contract = {
-      convention,
-      ...eventKinds === void 0 || eventKinds.length === 0 ? {} : { eventKinds: [...eventKinds] }
-    };
-    support.contracts.push(contract);
     if (!support.actions.includes(action)) support.actions.push(action);
     if (!support.conventions.includes(convention)) support.conventions.push(convention);
   }
@@ -13095,25 +13150,13 @@ var BrowserIntentController = class {
   }
   options;
   maxAttempts;
-  retain(params) {
-    const retained = freezeRetention(params);
-    let started;
-    let delivered = false;
-    return {
-      start: () => {
-        started ??= this.start(retained, () => delivered, () => {
-          delivered = true;
-        });
-        return started;
-      }
-    };
-  }
-  async start(params, isDelivered, markDelivered) {
+  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(params, attempt);
+        generation = await this.options.openOrReuse(dispatch2, attempt);
       } catch {
         reason = "open-failed";
         continue;
@@ -13132,17 +13175,18 @@ var BrowserIntentController = class {
         reason = "no-current-target";
         continue;
       }
-      if (isDelivered()) return;
-      markDelivered();
       try {
-        await this.options.send(generation, params.delivery);
-        return;
+        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?.(params, "send-failed");
-        return;
+        this.options.onTerminal?.(dispatch2, "send-failed");
+        throw new Error("intent target send failed");
       }
     }
-    this.options.onTerminal?.(params, reason);
+    this.options.onTerminal?.(dispatch2, reason);
+    throw new Error(`intent target ${reason}`);
   }
 };
 function normalizeAttempts(value) {
@@ -13150,15 +13194,22 @@ function normalizeAttempts(value) {
   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 freezeRetention(params) {
+function freezeDispatch(params) {
   if (!params || typeof params.handler !== "string" || params.handler.length === 0) {
-    throw new TypeError("Intent retention requires a handler");
+    throw new TypeError("Intent dispatch requires a handler");
   }
-  const delivery = freezeValue({ ...params.delivery });
+  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,
-    delivery,
+    sender: params.sender,
+    archetype: params.archetype,
+    action: params.action,
+    convention: params.convention,
+    ...params.payload === void 0 ? {} : { payload },
     ...behavior === void 0 ? {} : { behavior }
   });
 }
@@ -13192,10 +13243,10 @@ var InstalledNappletCatalog = class {
       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,
-        ...archetype.eventKinds === void 0 ? {} : { eventKinds: [...archetype.eventKinds] }
+        convention: archetype.convention
       }))
     });
     this.records.set(record.dTag, record);
@@ -13231,13 +13282,12 @@ var InstalledNappletCatalog = class {
   }
   /** Return exact handler candidates derived only from installed manifests. */
   intentCatalog() {
-    return this.installed().map((record) => manifestToIntentCatalogEntry({
+    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,
-        ...archetype.eventKinds === void 0 ? {} : { eventKinds: [...archetype.eventKinds] }
+        convention: archetype.convention
       }))
     }));
   }
@@ -13273,10 +13323,8 @@ function copyPointer(pointer) {
 function freezeRecord(record) {
   return Object.freeze({
     ...record,
-    archetypes: Object.freeze(record.archetypes.map((archetype) => Object.freeze({
-      ...archetype,
-      ...archetype.eventKinds === void 0 ? {} : { eventKinds: Object.freeze([...archetype.eventKinds]) }
-    })))
+    requires: Object.freeze([...record.requires]),
+    archetypes: Object.freeze(record.archetypes.map((archetype) => Object.freeze({ ...archetype })))
   });
 }
 
@@ -14528,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;
@@ -14588,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);
@@ -14616,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) {
@@ -14691,6 +14789,7 @@ function createPajaRelayBackend(getSimulation, confirmRequest, livePool = new Si
       livePool.destroy();
     }
   };
+  contactListCandidateQueries.set(backend, queryContactListCandidates);
   return backend;
 }
 function toNostrEvent(value) {
@@ -14730,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) => {
@@ -14785,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);
@@ -14898,6 +15189,7 @@ function createDefaultIntentHost() {
       openOrReuse: () => null,
       waitForReady: () => void 0,
       isCurrent: () => false,
+      getWindowId: () => null,
       send: () => void 0
     })
   };
@@ -14975,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();
@@ -15012,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({
@@ -15032,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({
@@ -15056,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) {
@@ -18925,7 +19232,7 @@ function aggregateTagValue(tags) {
   return void 0;
 }
 
-// ../nip/dist/chunk-AGRSQG35.js
+// ../nip/dist/chunk-YIG2IRN2.js
 var MIB = 1024 * 1024;
 var NAPPLET_ARTIFACT_CACHE_NAME = "kehto:napplet-artifacts:v1";
 var SCHEMA_VERSION = 1;
@@ -19390,28 +19697,13 @@ function archetypesFromTags(tags) {
         "archetype slug must match the convention archetype"
       );
     }
-    const eventKinds = tag.slice(3).map((value) => {
-      const match = /^kind:(\d+)$/.exec(value);
-      if (!match) {
-        throw new NappletResolutionError(
-          "invalid-manifest",
-          "archetype trailing fields must use kind:<unsigned-integer>"
-        );
-      }
-      const kind = Number(match[1]);
-      if (!Number.isSafeInteger(kind) || kind < 0) {
-        throw new NappletResolutionError(
-          "invalid-manifest",
-          "archetype event kinds must be unsigned safe integers"
-        );
-      }
-      return kind;
-    });
-    out.push({
-      slug,
-      convention,
-      ...eventKinds.length === 0 ? {} : { eventKinds }
-    });
+    if (tag.length !== 3) {
+      throw new NappletResolutionError(
+        "invalid-manifest",
+        "archetype tags must contain exactly slug and convention"
+      );
+    }
+    out.push({ slug, convention });
   }
   return out;
 }
@@ -19427,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"),
@@ -19773,7 +20069,7 @@ function createPajaIntentTargetOptions(getState, getContext, effects = {}) {
       const current = state.tabs.find(
         (tab2) => matchesInstalledNappletRecord(record, tab2.resolvedTarget) && isCurrentRuntimeTabGeneration(state, context, tab2)
       );
-      if (current && params.behavior?.reuse !== false) {
+      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));
@@ -19810,7 +20106,12 @@ function createPajaIntentTargetOptions(getState, getContext, effects = {}) {
       }
       return true;
     },
-    send(generation, delivery) {
+    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;
@@ -19823,8 +20124,10 @@ function createPajaIntentTargetOptions(getState, getContext, effects = {}) {
         throw new Error("intent target source is no longer registered");
       }
       createPajaPostMessageProxy(source, state, tab.windowId).postMessage({
-        type: "intent.deliver",
-        delivery
+        type: "inc.event",
+        topic: params.convention,
+        sender: params.sender,
+        ...params.payload === void 0 ? {} : { payload: params.payload }
       }, "*");
     }
   };
@@ -19841,12 +20144,12 @@ function pajaPointerResolverOptions(context) {
 }
 function recordSupportsDelivery(record, params) {
   return record.archetypes.some(
-    (archetype) => archetype.slug === params.delivery.archetype && archetype.convention === params.delivery.convention
+    (archetype) => archetype.slug === params.archetype && archetype.convention === params.convention
   );
 }
 function resolvedSupportsDelivery(resolved, params) {
   return resolved.manifest.archetypes.some(
-    (archetype) => archetype.slug === params.delivery.archetype && archetype.convention === params.delivery.convention
+    (archetype) => archetype.slug === params.archetype && archetype.convention === params.convention
   );
 }
 function findRuntimeTabGeneration(state, generation) {