@kehto/paja 0.3.1 → 0.3.4

package/dist/browser-host.js

@@ -1,4 +1,4 @@
-// ../acl/dist/chunk-6GH7LZSY.js
+// ../acl/dist/chunk-ZI6GTKYN.js
 var ALL_CAPABILITIES = [
   // v1.1 kept:
   "relay:read",
@@ -34,7 +34,11 @@ var ALL_CAPABILITIES = [
   // handlers introspection (and receipt of shell pushes); write = invoke (the
   // focus-stealing cross-napplet dispatch op).
   "intent:read",
-  "intent:write"
+  "intent:write",
+  // NAP-DM — runtime-mediated direct messages: read = status/conversations/
+  // messages/subscribe/unsubscribe and receive pushes; write = send.
+  "dm:read",
+  "dm:write"
 ];
 
 // ../acl/dist/index.js
@@ -224,7 +228,7 @@ function configMap(action) {
   return { senderCap: "config:read", recipientCap: null };
 }
 function resourceMap(action) {
-  if (action === "bytes.result" || action === "bytes.error" || action === "bytesMany.result" || action === "bytesMany.error") {
+  if (action === "info.result" || action === "info.error" || action === "bytes.result" || action === "bytes.error" || action === "bytesMany.result" || action === "bytesMany.error") {
     return { senderCap: null, recipientCap: "resource:fetch" };
   }
   return { senderCap: "resource:fetch", recipientCap: null };
@@ -255,6 +259,13 @@ function intentMap(action) {
   if (action === "invoke") return { senderCap: "intent:write", recipientCap: null };
   return { senderCap: "intent:read", recipientCap: null };
 }
+function dmMap(action) {
+  if (action === "message" || action.endsWith(".result") || action.endsWith(".error")) {
+    return { senderCap: null, recipientCap: "dm:read" };
+  }
+  if (action === "send") return { senderCap: "dm:write", recipientCap: null };
+  return { senderCap: "dm:read", recipientCap: null };
+}
 function themeMap(action) {
   if (action === "changed") return { senderCap: null, recipientCap: "theme:read" };
   return { senderCap: "theme:read", recipientCap: null };
@@ -298,6 +309,9 @@ function resolveCapabilitiesNap(msg) {
     case "intent":
       return intentMap(action);
     // NAP-INTENT archetype intent dispatch
+    case "dm":
+      return dmMap(action);
+    // NAP-DM runtime-mediated direct messages
     default:
       return { senderCap: null, recipientCap: null };
   }
@@ -593,7 +607,7 @@ function deserialize2(json) {
   return defaultConfig();
 }
 
-// ../../node_modules/.pnpm/@napplet+core@0.21.0/node_modules/@napplet/core/dist/index.js
+// ../../node_modules/.pnpm/@napplet+core@0.23.0/node_modules/@napplet/core/dist/index.js
 function createDispatch() {
   const handlers = /* @__PURE__ */ new Map();
   function registerNap2(domain, handler) {
@@ -734,6 +748,8 @@ var CAP_OUTBOX_WRITE2 = 1 << 19;
 var CAP_UPLOAD_WRITE2 = 1 << 20;
 var CAP_INTENT_READ2 = 1 << 21;
 var CAP_INTENT_WRITE2 = 1 << 22;
+var CAP_DM_READ2 = 1 << 23;
+var CAP_DM_WRITE2 = 1 << 24;
 var CAP_MAP = {
   "relay:read": CAP_RELAY_READ,
   "relay:write": CAP_RELAY_WRITE,
@@ -756,7 +772,9 @@ var CAP_MAP = {
   "outbox:write": CAP_OUTBOX_WRITE2,
   "upload:write": CAP_UPLOAD_WRITE2,
   "intent:read": CAP_INTENT_READ2,
-  "intent:write": CAP_INTENT_WRITE2
+  "intent:write": CAP_INTENT_WRITE2,
+  "dm:read": CAP_DM_READ2,
+  "dm:write": CAP_DM_WRITE2
 };
 var RUNTIME_CAP_ALL = Object.values(CAP_MAP).reduce((bits, bit) => bits | bit, 0);
 function capToBit(cap) {
@@ -1299,13 +1317,128 @@ function publishSignedEncrypted(context, windowId, id, signed, replyPe) {
   }
 }
 function handleRelayQuery(context, windowId, m) {
+  const { hooks, serviceRegistry, eventBuffer } = context;
   const id = m.id ?? "";
   const filters = m.filters ?? [];
-  let count = 0;
-  for (const event of context.eventBuffer.getBufferedEvents()) {
-    if (matchesAnyFilter(event, filters)) count++;
+  const seenIds = /* @__PURE__ */ new Set();
+  const events = [];
+  for (const event of eventBuffer.getBufferedEvents()) {
+    if (matchesAnyFilter(event, filters) && !seenIds.has(event.id)) {
+      seenIds.add(event.id);
+      events.push(event);
+    }
+  }
+  let settled = false;
+  let fallbackTimer;
+  function settle6() {
+    if (settled) return;
+    settled = true;
+    clearTimeout(fallbackTimer);
+    hooks.sendToNapplet(windowId, { type: "relay.query.result", id, events });
+  }
+  if (isShellKindQuery(filters)) {
+    settle6();
+    return;
+  }
+  const relayService = relayServiceFrom(context);
+  const cacheService = !serviceRegistry["relay"] ? serviceRegistry["cache"] : void 0;
+  if (relayService) {
+    let onBackendEose2 = function() {
+      openBackends--;
+      if (openBackends <= 0) {
+        const closeMsg = { type: "relay.close", id, subId };
+        svc.handleMessage(windowId, closeMsg, () => {
+        });
+        if (cacheService) {
+          cacheService.handleMessage(windowId, closeMsg, () => {
+          });
+        }
+        settle6();
+      }
+    }, makeCollector2 = function() {
+      return function collector(resp) {
+        const r = resp;
+        if (r.type === "relay.event" && r.event && !seenIds.has(r.event.id)) {
+          seenIds.add(r.event.id);
+          events.push(r.event);
+        } else if (r.type === "relay.eose") {
+          onBackendEose2();
+        }
+      };
+    };
+    var onBackendEose = onBackendEose2, makeCollector = makeCollector2;
+    const svc = relayService;
+    const subId = "__query__:" + id;
+    const subscribeMsg = {
+      type: "relay.subscribe",
+      id,
+      subId,
+      filters
+    };
+    if (typeof m.relay === "string" && m.relay.length > 0) {
+      subscribeMsg.relay = m.relay;
+    }
+    let openBackends = cacheService ? 2 : 1;
+    fallbackTimer = setTimeout(() => {
+      const closeMsg = { type: "relay.close", id, subId };
+      svc.handleMessage(windowId, closeMsg, () => {
+      });
+      if (cacheService) {
+        cacheService.handleMessage(windowId, closeMsg, () => {
+        });
+      }
+      settle6();
+    }, 15e3);
+    svc.handleMessage(windowId, subscribeMsg, makeCollector2());
+    if (cacheService) {
+      cacheService.handleMessage(windowId, subscribeMsg, makeCollector2());
+    }
+    return;
+  }
+  const cache2 = hooks.cache;
+  const pool = hooks.relayPool;
+  if (cache2?.isAvailable()) {
+    cache2.query(filters).then((cachedEvents) => {
+      for (const event of cachedEvents) {
+        if (!seenIds.has(event.id)) {
+          seenIds.add(event.id);
+          events.push(event);
+        }
+      }
+    }).catch(() => {
+    });
+  }
+  if (!pool?.isAvailable()) {
+    settle6();
+    return;
   }
-  context.hooks.sendToNapplet(windowId, { type: "relay.query.result", id, count });
+  const relayHint = typeof m.relay === "string" && m.relay.length > 0 ? m.relay : void 0;
+  const relayUrls = relayHint ? [relayHint] : pool.selectRelayTier(filters);
+  let poolSubscription;
+  fallbackTimer = setTimeout(() => {
+    poolSubscription?.unsubscribe();
+    settle6();
+  }, 15e3);
+  poolSubscription = pool.subscribe(filters, (item) => {
+    if (item === "EOSE") {
+      clearTimeout(fallbackTimer);
+      poolSubscription?.unsubscribe();
+      settle6();
+      return;
+    }
+    const event = item;
+    if (!seenIds.has(event.id)) {
+      seenIds.add(event.id);
+      events.push(event);
+    }
+    if (cache2?.isAvailable()) {
+      try {
+        cache2.store(event);
+      } catch {
+        return;
+      }
+    }
+  }, relayUrls);
 }
 function createIdentityHandler(context) {
   return function handleIdentityMessage(windowId, msg) {
@@ -1710,7 +1843,8 @@ function createRuntimeDomainHandlers(context) {
     lists: (windowId, msg) => handleServiceOnlyMessage(context, "lists", windowId, msg),
     serial: (windowId, msg) => handleServiceOnlyMessage(context, "serial", windowId, msg),
     ble: (windowId, msg) => handleServiceOnlyMessage(context, "ble", windowId, msg),
-    webrtc: (windowId, msg) => handleServiceOnlyMessage(context, "webrtc", windowId, msg)
+    webrtc: (windowId, msg) => handleServiceOnlyMessage(context, "webrtc", windowId, msg),
+    dm: (windowId, msg) => handleServiceOnlyMessage(context, "dm", windowId, msg)
   };
 }
 function handleStorageMessage(context, windowId, msg) {
@@ -1857,6 +1991,7 @@ function createNapEnvelopeDispatcher(handlers) {
   napDispatch.registerNap("serial", adapt(handlers.serial));
   napDispatch.registerNap("ble", adapt(handlers.ble));
   napDispatch.registerNap("webrtc", adapt(handlers.webrtc));
+  napDispatch.registerNap("dm", adapt(handlers.dm));
   return (windowId, envelope) => {
     currentWindowId = windowId;
     try {
@@ -2426,6 +2561,7 @@ function adaptHooks(shellHooks, deps) {
   };
 }
 var registry = /* @__PURE__ */ new Map();
+var nextRegistrationId = 0;
 var originRegistry = {
   /**
    * Register a window reference with a windowId and optional identity metadata.
@@ -2435,10 +2571,16 @@ var originRegistry = {
    * @param identity - Optional NIP-5D identity metadata (dTag and aggregateHash)
    */
   register(win, windowId, identity) {
+    for (const [registeredWin, entry] of registry.entries()) {
+      if (registeredWin === win || entry.windowId === windowId) {
+        registry.delete(registeredWin);
+      }
+    }
     registry.set(win, {
       windowId,
       dTag: identity?.dTag,
-      aggregateHash: identity?.aggregateHash
+      aggregateHash: identity?.aggregateHash,
+      registrationId: ++nextRegistrationId
     });
   },
   /**
@@ -2493,6 +2635,15 @@ var originRegistry = {
     if (!entry?.dTag || !entry?.aggregateHash) return void 0;
     return { dTag: entry.dTag, aggregateHash: entry.aggregateHash };
   },
+  /**
+   * Look up the monotonically increasing registration id for a Window.
+   *
+   * @param win - The Window reference to look up
+   * @returns The registration id, or undefined if the Window is not registered
+   */
+  getRegistrationId(win) {
+    return registry.get(win)?.registrationId;
+  },
   /** Clear all registrations. */
   clear() {
     registry.clear();
@@ -3100,6 +3251,7 @@ function buildShellCapabilities(hooks) {
   if (hooks.serial?.isAvailable()) domains.push("serial");
   if (hooks.ble?.isAvailable()) domains.push("ble");
   if (hooks.webrtc?.isAvailable()) domains.push("webrtc");
+  if (hooks.dm) domains.push("dm");
   const sandbox = [];
   domains.push(...sandbox);
   const protocols = {};
@@ -3116,6 +3268,7 @@ function buildShellCapabilities(hooks) {
   if (hooks.serial?.isAvailable()) naps.push("serial");
   if (hooks.ble?.isAvailable()) naps.push("ble");
   if (hooks.webrtc?.isAvailable()) naps.push("webrtc");
+  if (hooks.dm) naps.push("dm");
   return applyCapabilityOverrides(
     { domains, protocols, naps, sandbox },
     hooks.capabilities?.disabledDomains ?? []
@@ -3135,20 +3288,29 @@ function applyCapabilityOverrides(capabilities, disabledDomains) {
     sandbox: capabilities.sandbox
   };
 }
-var initSent = /* @__PURE__ */ new Set();
+var initSent = /* @__PURE__ */ new WeakMap();
 function handleShellReady({
   hooks,
   origin,
   runtime,
+  sourceRegistrationId,
+  sourceWindow,
   windowId
 }) {
-  registerNip5dSessionIfNeeded({ hooks, origin, runtime, windowId });
-  if (initSent.has(windowId)) {
+  registerNip5dSessionIfNeeded({
+    hooks,
+    origin,
+    runtime,
+    sourceRegistrationId,
+    sourceWindow,
+    windowId
+  });
+  if (initSent.get(sourceWindow) === sourceRegistrationId) {
     return;
   }
   const capabilities = buildShellCapabilities(hooks);
-  postShellInit(windowId, capabilities, Object.keys(hooks.services ?? {}));
-  initSent.add(windowId);
+  postShellInit(sourceWindow, capabilities, Object.keys(hooks.services ?? {}));
+  initSent.set(sourceWindow, sourceRegistrationId);
 }
 function registerNip5dSessionIfNeeded({
   hooks,
@@ -3197,14 +3359,13 @@ function resolveNip5dIdentity(hooks, windowId) {
     aggregateHash: originIdentity.aggregateHash
   };
 }
-function postShellInit(windowId, capabilities, services) {
+function postShellInit(win, capabilities, services) {
   const initMsg = {
     type: "shell.init",
     capabilities,
     services
   };
-  const win = originRegistry.getIframeWindow(windowId);
-  if (win) win.postMessage(initMsg, "*");
+  win.postMessage(initMsg, "*");
 }
 function reportUnrouted(hooks, event, reason) {
   if (!hooks.onUnroutedMessage) return;
@@ -3264,7 +3425,14 @@ function createShellBridge(hooks) {
       const msg = event.data;
       if (typeof msg !== "object" || msg === null || typeof msg.type !== "string") return;
       if (msg.type === "shell.ready") {
-        handleShellReady({ hooks, origin: event.origin, runtime, windowId });
+        handleShellReady({
+          hooks,
+          origin: event.origin,
+          runtime,
+          sourceRegistrationId: originRegistry.getRegistrationId(sourceWindow) ?? 0,
+          sourceWindow,
+          windowId
+        });
         return;
       }
       runtime.handleMessage(windowId, msg);
@@ -3946,10 +4114,10 @@ function createNotificationService(options) {
   };
 }
 var IDENTITY_SERVICE_VERSION = "1.0.0";
-function sendProviderError(send, result, fallback, err) {
+function sendProviderError(send, result, fallback, err2) {
   send({
     ...result,
-    error: err?.message ?? fallback
+    error: err2?.message ?? fallback
   });
 }
 async function getCurrentPubkey(options) {
@@ -3966,13 +4134,13 @@ function sendOptionalProviderResult(options, send, fallbackResult, errorFallback
     send(fallbackResult);
     return;
   }
-  Promise.resolve(getCurrentPubkey(options)).then((pubkey) => buildResult(pubkey)).then((result) => send(result)).catch((err) => sendProviderError(send, fallbackResult, errorFallback, err));
+  Promise.resolve(getCurrentPubkey(options)).then((pubkey) => buildResult(pubkey)).then((result) => send(result)).catch((err2) => sendProviderError(send, fallbackResult, errorFallback, err2));
 }
 function sendIdentityError(send, id, typeBase, error) {
   send({ type: `${typeBase}.error`, id, error });
 }
-function sendSignerError(send, id, typeBase, fallback, err) {
-  sendIdentityError(send, id, typeBase, err?.message ?? fallback);
+function sendSignerError(send, id, typeBase, fallback, err2) {
+  sendIdentityError(send, id, typeBase, err2?.message ?? fallback);
 }
 function handleGetPublicKey(options, id, send) {
   const signer = options.getSigner();
@@ -3992,7 +4160,7 @@ function handleGetPublicKey(options, id, send) {
       pubkey: pubkey ?? ""
     };
     send(result);
-  }).catch((err) => sendSignerError(send, id, "identity.getPublicKey", "getPublicKey failed", err));
+  }).catch((err2) => sendSignerError(send, id, "identity.getPublicKey", "getPublicKey failed", err2));
 }
 function handleGetRelays(options, id, send) {
   const signer = options.getSigner();
@@ -4007,7 +4175,7 @@ function handleGetRelays(options, id, send) {
       relays
     };
     send(result);
-  }).catch((err) => sendSignerError(send, id, "identity.getRelays", "getRelays failed", err));
+  }).catch((err2) => sendSignerError(send, id, "identity.getRelays", "getRelays failed", err2));
 }
 function handleReadProvider(options, id, message, send) {
   switch (message.type) {
@@ -4166,7 +4334,7 @@ function createRelayPoolService(options) {
           return;
         }
         const relayHint = typeof relayMessage.relay === "string" && relayMessage.relay.length > 0 ? relayMessage.relay : void 0;
-        const relayUrls = relayHint ? [relayHint] : options.selectRelayTier(filters);
+        const relayUrls2 = relayHint ? [relayHint] : options.selectRelayTier(filters);
         let eoseSent = false;
         const eoseTimer = setTimeout(() => {
           if (!eoseSent) {
@@ -4184,7 +4352,7 @@ function createRelayPoolService(options) {
             return;
           }
           send({ type: "relay.event", subId, event: item });
-        }, relayUrls);
+        }, relayUrls2);
         tracked.set(subKey, { handle, eoseTimer });
         return;
       }
@@ -4330,12 +4498,12 @@ function createKeysService(options = {}) {
                 unsubscribeHandles.set(m.action.id, unsubscribe);
                 if (!bridgeWindowActions.has(windowId)) bridgeWindowActions.set(windowId, /* @__PURE__ */ new Set());
                 bridgeWindowActions.get(windowId).add(m.action.id);
-              } catch (err) {
+              } catch (err2) {
                 const id = m.id ?? "";
                 send({
                   type: "keys.registerAction.error",
                   id,
-                  error: `bridge subscribe failed: ${err.message}`
+                  error: `bridge subscribe failed: ${err2.message}`
                 });
                 return;
               }
@@ -4477,12 +4645,12 @@ function createKeysService(options = {}) {
               });
               if (!windowActions.has(windowId)) windowActions.set(windowId, /* @__PURE__ */ new Set());
               windowActions.get(windowId).add(m.action.id);
-            } catch (err) {
+            } catch (err2) {
               const id = m.id ?? "";
               send({
                 type: "keys.registerAction.error",
                 id,
-                error: `invalid chord: ${err.message}`
+                error: `invalid chord: ${err2.message}`
               });
               return;
             }
@@ -5150,6 +5318,9 @@ function arrayBufferToBase64(buf) {
   }
   return btoa(binary);
 }
+var DEFAULT_RESOURCE_INFO = {
+  schemes: [{ scheme: "https", enabled: true }]
+};
 function assertResourceOptions(options) {
   if (typeof options?.fetch !== "function" || typeof options?.isOriginGranted !== "function" || typeof options?.getConnectGrants !== "function" || typeof options?.resolveIdentity !== "function") {
     throw new Error(
@@ -5221,6 +5392,35 @@ function requestIdFromMessage(message) {
   if (typeof message.requestId === "string" && message.requestId.length > 0) return message.requestId;
   return null;
 }
+function normalizeResourceInfo(info) {
+  return {
+    schemes: Array.isArray(info.schemes) ? info.schemes.filter((scheme) => typeof scheme?.scheme === "string").map((scheme) => ({ scheme: scheme.scheme, enabled: scheme.enabled !== false })) : [],
+    ...typeof info.maxBytes === "number" ? { maxBytes: info.maxBytes } : {},
+    ...typeof info.maxUrls === "number" ? { maxUrls: info.maxUrls } : {}
+  };
+}
+async function resolveResourceInfo(options, windowId) {
+  const configured = options.resourceInfo ?? DEFAULT_RESOURCE_INFO;
+  const info = typeof configured === "function" ? await configured({ windowId, identity: options.resolveIdentity(windowId) }) : configured;
+  return normalizeResourceInfo(info);
+}
+async function handleInfo(options, windowId, requestId, send) {
+  try {
+    const info = await resolveResourceInfo(options, windowId);
+    send({
+      type: "resource.info.result",
+      id: requestId,
+      info
+    });
+  } catch (err2) {
+    send({
+      type: "resource.info.error",
+      id: requestId,
+      error: "unavailable",
+      message: err2 instanceof Error ? err2.message : String(err2)
+    });
+  }
+}
 function resourceInvalidRequest(url, message) {
   return {
     ok: false,
@@ -5262,14 +5462,14 @@ async function fetchResourceItem(options, identity, url, init, signal) {
       headers,
       bodyBase64: arrayBufferToBase64(buffer)
     };
-  } catch (err) {
-    const isAbort = signal.aborted || err instanceof Error && (err.name === "AbortError" || err.name === "DOMException");
+  } catch (err2) {
+    const isAbort = signal.aborted || err2 instanceof Error && (err2.name === "AbortError" || err2.name === "DOMException");
     return {
       ok: false,
       url,
       error: isAbort ? "timeout" : "network-error",
       code: isAbort ? "canceled" : "network-error",
-      message: err instanceof Error ? err.message : String(err)
+      message: err2 instanceof Error ? err2.message : String(err2)
     };
   }
 }
@@ -5387,6 +5587,14 @@ function createResourceService(options) {
           });
           return;
         }
+        case "resource.info": {
+          const m = message;
+          const requestId = requestIdFromMessage(m);
+          if (!requestId) return;
+          handleInfo(options, windowId, requestId, send).catch(() => {
+          });
+          return;
+        }
         case "resource.bytesMany": {
           const m = message;
           const requestId = requestIdFromMessage(m);
@@ -5415,7 +5623,7 @@ var OUTBOX_SERVICE_VERSION = "1.0.0";
 var OUTBOX_DESCRIPTOR = {
   name: "outbox",
   version: OUTBOX_SERVICE_VERSION,
-  description: "NAP-OUTBOX outbox-aware relay routing \u2014 query/subscribe/publish/resolveRelays"
+  description: "NAP-OUTBOX outbox-aware relay routing \u2014 getEvent/query/subscribe/publish/resolveRelays"
 };
 function normalizeFilters(raw) {
   if (Array.isArray(raw)) {
@@ -5425,6 +5633,59 @@ function normalizeFilters(raw) {
   if (typeof raw === "object" && raw !== null) return [raw];
   return null;
 }
+function buildEventQuery(eventId, eventOptions) {
+  const filter = { ids: [eventId] };
+  const queryOptions = { limit: 1 };
+  if (typeof eventOptions?.author === "string" && eventOptions.author.length > 0) {
+    filter.authors = [eventOptions.author];
+    queryOptions.authors = [eventOptions.author];
+  }
+  if (Array.isArray(eventOptions?.relays)) queryOptions.relays = eventOptions.relays;
+  if (eventOptions?.strategy !== void 0) queryOptions.strategy = eventOptions.strategy;
+  if (eventOptions?.timeoutMs !== void 0) queryOptions.timeoutMs = eventOptions.timeoutMs;
+  return { filter, queryOptions };
+}
+function eventResultFromQuery(eventId, result) {
+  const event = result.events.find((candidate) => candidate.id === eventId);
+  const eventResult = {
+    relays: event ? result.relays[eventId] ?? [] : []
+  };
+  if (event) eventResult.event = event;
+  if (!event) eventResult.error = result.error ?? "not found";
+  else if (result.error !== void 0) eventResult.error = result.error;
+  if (result.incomplete !== void 0) eventResult.incomplete = result.incomplete;
+  return eventResult;
+}
+function fallbackGetEvent(router, eventId, eventOptions) {
+  const { filter, queryOptions } = buildEventQuery(eventId, eventOptions);
+  return router.query([filter], queryOptions).then((result) => eventResultFromQuery(eventId, result));
+}
+function sendEventResult(id, eventId, result, send) {
+  if (result.event && result.event.id !== eventId) {
+    send({ type: "outbox.getEvent.result", id, relays: [], error: "not found" });
+    return;
+  }
+  send({
+    type: "outbox.getEvent.result",
+    id,
+    ...result.event === void 0 ? {} : { event: result.event },
+    relays: result.relays,
+    ...result.incomplete === void 0 ? {} : { incomplete: result.incomplete },
+    ...result.error === void 0 ? {} : { error: result.error }
+  });
+}
+function handleGetEvent(router, msg, send) {
+  const m = msg;
+  const id = m.id ?? "";
+  if (typeof m.eventId !== "string" || m.eventId.length === 0) {
+    send({ type: "outbox.getEvent.result", id, relays: [], error: "invalid filter" });
+    return;
+  }
+  const getEvent = router.getEvent ?? ((eventId, eventOptions) => fallbackGetEvent(router, eventId, eventOptions));
+  void getEvent(m.eventId, m.options).then((result) => sendEventResult(id, m.eventId, result, send)).catch(
+    (err2) => send({ type: "outbox.getEvent.result", id, relays: [], error: toErrorMessage(err2) })
+  );
+}
 function createOutboxService(options) {
   if (!options || typeof options.router !== "object" || options.router === null) {
     throw new Error("createOutboxService: options.router is required");
@@ -5449,7 +5710,7 @@ function createOutboxService(options) {
         ...result.error === void 0 ? {} : { error: result.error }
       })
     ).catch(
-      (err) => send({ type: "outbox.query.result", id, events: [], relays: {}, error: toErrorMessage(err) })
+      (err2) => send({ type: "outbox.query.result", id, events: [], relays: {}, error: toErrorMessage(err2) })
     );
   }
   function handleSubscribe2(windowId, msg, send) {
@@ -5501,7 +5762,7 @@ function createOutboxService(options) {
         ...result.error === void 0 ? {} : { error: result.error }
       })
     ).catch(
-      (err) => send({ type: "outbox.publish.result", id, ok: false, error: toErrorMessage(err) })
+      (err2) => send({ type: "outbox.publish.result", id, ok: false, error: toErrorMessage(err2) })
     );
   }
   function handleResolveRelays(msg, send) {
@@ -5512,13 +5773,16 @@ function createOutboxService(options) {
       return;
     }
     void router.resolveRelays(m.target).then((plan) => send({ type: "outbox.resolveRelays.result", id, plan })).catch(
-      (err) => send({ type: "outbox.resolveRelays.result", id, error: toErrorMessage(err) })
+      (err2) => send({ type: "outbox.resolveRelays.result", id, error: toErrorMessage(err2) })
     );
   }
   return {
     descriptor: OUTBOX_DESCRIPTOR,
     handleMessage(windowId, message, send) {
       switch (message.type) {
+        case "outbox.getEvent":
+          handleGetEvent(router, message, send);
+          return;
         case "outbox.query":
           handleQuery(message, send);
           return;
@@ -5549,9 +5813,9 @@ function createOutboxService(options) {
     }
   };
 }
-function toErrorMessage(err) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
+function toErrorMessage(err2) {
+  if (err2 instanceof Error) return err2.message;
+  if (typeof err2 === "string") return err2;
   return "outbox request failed";
 }
 var UPLOAD_SERVICE_VERSION = "1.0.0";
@@ -5560,14 +5824,38 @@ var UPLOAD_DESCRIPTOR = {
   version: UPLOAD_SERVICE_VERSION,
   description: "NAP-UPLOAD shell-mediated file/blob upload \u2014 upload/status with progress pushes"
 };
+var DEFAULT_UPLOAD_INFO = {
+  rails: []
+};
 function createUploadService(options) {
   if (!options || typeof options.uploader !== "object" || options.uploader === null) {
     throw new Error("createUploadService: options.uploader is required");
   }
   const { uploader } = options;
+  const uploadInfo = options.uploadInfo ?? DEFAULT_UPLOAD_INFO;
   const generateId2 = options.generateId ?? (() => crypto.randomUUID());
   const now = options.now ?? (() => Date.now());
   const entries = /* @__PURE__ */ new Map();
+  function normalizeUploadInfo(info) {
+    return {
+      rails: Array.isArray(info.rails) ? info.rails.filter((rail) => typeof rail?.rail === "string").map((rail) => ({
+        rail: rail.rail,
+        enabled: rail.enabled !== false,
+        ...Array.isArray(rail.returns) ? { returns: rail.returns.filter((value) => typeof value === "string") } : {}
+      })) : [],
+      ...typeof info.maxBytes === "number" ? { maxBytes: info.maxBytes } : {},
+      ...Array.isArray(info.mimeTypes) ? { mimeTypes: info.mimeTypes.filter((value) => typeof value === "string") } : {}
+    };
+  }
+  function handleInfo2(windowId, msg, send) {
+    const m = msg;
+    const id = m.id ?? "";
+    void Promise.resolve().then(() => typeof uploadInfo === "function" ? uploadInfo({ windowId }) : uploadInfo).then((info) => {
+      send({ type: "upload.info.result", id, info: normalizeUploadInfo(info) });
+    }).catch((err2) => {
+      send({ type: "upload.info.result", id, error: toErrorMessage2(err2) });
+    });
+  }
   function handleUpload(windowId, msg, send) {
     const m = msg;
     const id = m.id ?? "";
@@ -5594,9 +5882,9 @@ function createUploadService(options) {
       const entry = entries.get(key);
       if (entry) entry.status = { ...stamped, updatedAt: now() };
       send({ type: "upload.upload.result", id, result: stamped });
-    }).catch((err) => {
+    }).catch((err2) => {
       entries.delete(key);
-      send({ type: "upload.upload.result", id, error: toErrorMessage2(err) });
+      send({ type: "upload.upload.result", id, error: toErrorMessage2(err2) });
     });
   }
   function handleStatus(windowId, msg, send) {
@@ -5618,7 +5906,7 @@ function createUploadService(options) {
           status ? { type: "upload.status.result", id, status } : { type: "upload.status.result", id, error: "unknown upload" }
         )
       ).catch(
-        (err) => send({ type: "upload.status.result", id, error: toErrorMessage2(err) })
+        (err2) => send({ type: "upload.status.result", id, error: toErrorMessage2(err2) })
       );
       return;
     }
@@ -5628,6 +5916,9 @@ function createUploadService(options) {
     descriptor: UPLOAD_DESCRIPTOR,
     handleMessage(windowId, message, send) {
       switch (message.type) {
+        case "upload.info":
+          handleInfo2(windowId, message, send);
+          return;
         case "upload.upload":
           handleUpload(windowId, message, send);
           return;
@@ -5649,9 +5940,9 @@ function createUploadService(options) {
     }
   };
 }
-function toErrorMessage2(err) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
+function toErrorMessage2(err2) {
+  if (err2 instanceof Error) return err2.message;
+  if (typeof err2 === "string") return err2;
   return "upload request failed";
 }
 var INTENT_SERVICE_VERSION = "1.0.0";
@@ -5660,9 +5951,9 @@ var INTENT_DESCRIPTOR = {
   version: INTENT_SERVICE_VERSION,
   description: "NAP-INTENT archetype intent dispatch \u2014 invoke/available/handlers"
 };
-function toErrorMessage4(err) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
+function toErrorMessage4(err2) {
+  if (err2 instanceof Error) return err2.message;
+  if (typeof err2 === "string") return err2;
   return "intent request failed";
 }
 function createIntentService(options) {
@@ -5680,11 +5971,11 @@ function createIntentService(options) {
     let pending;
     try {
       pending = Promise.resolve(call());
-    } catch (err) {
-      send({ type: resultType, id, error: toErrorMessage4(err) });
+    } catch (err2) {
+      send({ type: resultType, id, error: toErrorMessage4(err2) });
       return;
     }
-    pending.then((value) => send(onValue(value))).catch((err) => send({ type: resultType, id, error: toErrorMessage4(err) }));
+    pending.then((value) => send(onValue(value))).catch((err2) => send({ type: resultType, id, error: toErrorMessage4(err2) }));
   }
   function handleInvoke(windowId, msg, send) {
     const m = msg;
@@ -5793,7 +6084,7 @@ function createCvmService(options) {
     const m = msg;
     const id = m.id ?? "";
     void transport.discover(m.query).then((servers) => send({ type: "cvm.discover.result", id, servers })).catch(
-      (err) => send({ type: "cvm.discover.result", id, servers: [], error: toErrorMessage5(err) })
+      (err2) => send({ type: "cvm.discover.result", id, servers: [], error: toErrorMessage5(err2) })
     );
   }
   function handleRequest(windowId, msg, send) {
@@ -5809,7 +6100,7 @@ function createCvmService(options) {
     }
     openSession(windowId, m.server, send);
     void transport.request(m.server, m.message, m.options).then((message) => send({ type: "cvm.request.result", id, message })).catch(
-      (err) => send({ type: "cvm.request.result", id, error: toErrorMessage5(err) })
+      (err2) => send({ type: "cvm.request.result", id, error: toErrorMessage5(err2) })
     );
   }
   function handleClose(windowId, msg, send) {
@@ -5820,7 +6111,7 @@ function createCvmService(options) {
       return;
     }
     closeSession(windowId, m.server.pubkey);
-    void transport.close(m.server).then(() => send({ type: "cvm.close.result", id })).catch((err) => send({ type: "cvm.close.result", id, error: toErrorMessage5(err) }));
+    void transport.close(m.server).then(() => send({ type: "cvm.close.result", id })).catch((err2) => send({ type: "cvm.close.result", id, error: toErrorMessage5(err2) }));
   }
   return {
     descriptor: CVM_DESCRIPTOR,
@@ -5851,9 +6142,9 @@ function createCvmService(options) {
     }
   };
 }
-function toErrorMessage5(err) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
+function toErrorMessage5(err2) {
+  if (err2 instanceof Error) return err2.message;
+  if (typeof err2 === "string") return err2;
   return "cvm request failed";
 }
 var LINK_SERVICE_VERSION = "1.0.0";
@@ -5928,20 +6219,20 @@ var LISTS_DESCRIPTOR = {
   version: LISTS_SERVICE_VERSION,
   description: "NAP-LISTS reference handler for shell-mediated NIP-51 list mutations"
 };
-function errorMessage(err, fallback) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
+function errorMessage(err2, fallback) {
+  if (err2 instanceof Error) return err2.message;
+  if (typeof err2 === "string") return err2;
   return fallback;
 }
 function settle(call, send, okFalse, onValue) {
   let pending;
   try {
     pending = Promise.resolve(call());
-  } catch (err) {
-    send(okFalse(errorMessage(err, "lists request failed")));
+  } catch (err2) {
+    send(okFalse(errorMessage(err2, "lists request failed")));
     return;
   }
-  pending.then((value) => send(onValue(value))).catch((err) => send(okFalse(errorMessage(err, "lists request failed"))));
+  pending.then((value) => send(onValue(value))).catch((err2) => send(okFalse(errorMessage(err2, "lists request failed"))));
 }
 function unsupportedMutation(resultType, id) {
   return {
@@ -6008,20 +6299,20 @@ var SERIAL_DESCRIPTOR = {
   version: SERIAL_SERVICE_VERSION,
   description: "NAP-SERIAL reference handler for shell-mediated serial sessions"
 };
-function errorMessage2(err, fallback) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
+function errorMessage2(err2, fallback) {
+  if (err2 instanceof Error) return err2.message;
+  if (typeof err2 === "string") return err2;
   return fallback;
 }
 function settle2(call, send, okFalse, onValue) {
   let pending;
   try {
     pending = Promise.resolve(call());
-  } catch (err) {
-    send(okFalse(errorMessage2(err, "serial request failed")));
+  } catch (err2) {
+    send(okFalse(errorMessage2(err2, "serial request failed")));
     return;
   }
-  pending.then((value) => send(onValue(value))).catch((err) => send(okFalse(errorMessage2(err, "serial request failed"))));
+  pending.then((value) => send(onValue(value))).catch((err2) => send(okFalse(errorMessage2(err2, "serial request failed"))));
 }
 function unsupported(resultType, id) {
   return {
@@ -6095,20 +6386,20 @@ var BLE_DESCRIPTOR = {
   version: BLE_SERVICE_VERSION,
   description: "NAP-BLE reference handler for shell-mediated BLE/GATT sessions"
 };
-function errorMessage3(err, fallback) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
+function errorMessage3(err2, fallback) {
+  if (err2 instanceof Error) return err2.message;
+  if (typeof err2 === "string") return err2;
   return fallback;
 }
 function settle3(call, send, okFalse, onValue) {
   let pending;
   try {
     pending = Promise.resolve(call());
-  } catch (err) {
-    send(okFalse(errorMessage3(err, "ble request failed")));
+  } catch (err2) {
+    send(okFalse(errorMessage3(err2, "ble request failed")));
     return;
   }
-  pending.then((value) => send(onValue(value))).catch((err) => send(okFalse(errorMessage3(err, "ble request failed"))));
+  pending.then((value) => send(onValue(value))).catch((err2) => send(okFalse(errorMessage3(err2, "ble request failed"))));
 }
 function unsupported2(resultType, id) {
   return {
@@ -6117,12 +6408,20 @@ function unsupported2(resultType, id) {
     error: `${resultType.replace(".result", "")} unavailable`
   };
 }
+function createContext(windowId, send) {
+  return {
+    windowId,
+    emit(event) {
+      send({ type: "ble.event", event });
+    }
+  };
+}
 function createBleService(options = {}) {
   return {
     descriptor: BLE_DESCRIPTOR,
     handleMessage(windowId, message, send) {
       const id = message.id ?? "";
-      const context = { windowId };
+      const context = createContext(windowId, send);
       if (message.type === "ble.open") {
         if (!options.open) {
           send(unsupported2("ble.open.result", id));
@@ -6238,20 +6537,20 @@ var WEBRTC_DESCRIPTOR = {
   version: WEBRTC_SERVICE_VERSION,
   description: "NAP-WEBRTC reference handler for shell-mediated WebRTC sessions"
 };
-function errorMessage4(err, fallback) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
+function errorMessage4(err2, fallback) {
+  if (err2 instanceof Error) return err2.message;
+  if (typeof err2 === "string") return err2;
   return fallback;
 }
 function settle4(call, send, okFalse, onValue) {
   let pending;
   try {
     pending = Promise.resolve(call());
-  } catch (err) {
-    send(okFalse(errorMessage4(err, "webrtc request failed")));
+  } catch (err2) {
+    send(okFalse(errorMessage4(err2, "webrtc request failed")));
     return;
   }
-  pending.then((value) => send(onValue(value))).catch((err) => send(okFalse(errorMessage4(err, "webrtc request failed"))));
+  pending.then((value) => send(onValue(value))).catch((err2) => send(okFalse(errorMessage4(err2, "webrtc request failed"))));
 }
 function unsupported3(resultType, id) {
   return {
@@ -6260,7 +6559,7 @@ function unsupported3(resultType, id) {
     error: `${resultType.replace(".result", "")} unavailable`
   };
 }
-function createContext(windowId, send) {
+function createContext2(windowId, send) {
   return {
     windowId,
     emit(event) {
@@ -6273,7 +6572,7 @@ function createWebrtcService(options = {}) {
     descriptor: WEBRTC_DESCRIPTOR,
     handleMessage(windowId, message, send) {
       const id = message.id ?? "";
-      const context = createContext(windowId, send);
+      const context = createContext2(windowId, send);
       if (message.type === "webrtc.open") {
         if (!options.open) {
           send(unsupported3("webrtc.open.result", id));
@@ -6334,9 +6633,9 @@ var COMMON_DESCRIPTOR = {
   version: COMMON_SERVICE_VERSION,
   description: "NAP-COMMON reference handler for shell-mediated social helpers"
 };
-function errorMessage5(err, fallback) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
+function errorMessage5(err2, fallback) {
+  if (err2 instanceof Error) return err2.message;
+  if (typeof err2 === "string") return err2;
   return fallback;
 }
 function encodeNip19(input) {
@@ -6365,8 +6664,8 @@ function encodeNip19(input) {
       default:
         return { ok: false, error: "unsupported NIP-19 type" };
     }
-  } catch (err) {
-    return { ok: false, error: errorMessage5(err, "NIP-19 encode failed") };
+  } catch (err2) {
+    return { ok: false, error: errorMessage5(err2, "NIP-19 encode failed") };
   }
 }
 function decodeNip19Value(value) {
@@ -6399,9 +6698,9 @@ function decodeNip19Value(value) {
       default:
         return { ok: false, error: "unsupported NIP-19 type" };
     }
-  } catch (err) {
+  } catch (err2) {
     if (value.startsWith("nrelay1")) return decodeNrelay(value);
-    return { ok: false, error: errorMessage5(err, "NIP-19 decode failed") };
+    return { ok: false, error: errorMessage5(err2, "NIP-19 decode failed") };
   }
 }
 function decodeNrelay(value) {
@@ -6417,8 +6716,8 @@ function decodeNrelay(value) {
     const payloadWords = words.slice(0, -6);
     const bytes = convertBits(payloadWords, 5, 8, false);
     return { ok: true, nip19Type: "nrelay", relay: new TextDecoder().decode(Uint8Array.from(bytes)) };
-  } catch (err) {
-    return { ok: false, error: errorMessage5(err, "invalid nrelay value") };
+  } catch (err2) {
+    return { ok: false, error: errorMessage5(err2, "invalid nrelay value") };
   }
 }
 function convertBits(data, fromBits, toBits, pad) {
@@ -6447,11 +6746,11 @@ function settle5(call, send, okFalse, onValue) {
   let pending;
   try {
     pending = Promise.resolve(call());
-  } catch (err) {
-    send(okFalse(errorMessage5(err, "common request failed")));
+  } catch (err2) {
+    send(okFalse(errorMessage5(err2, "common request failed")));
     return;
   }
-  pending.then((value) => send(onValue(value))).catch((err) => send(okFalse(errorMessage5(err, "common request failed"))));
+  pending.then((value) => send(onValue(value))).catch((err2) => send(okFalse(errorMessage5(err2, "common request failed"))));
 }
 function createCommonService(options = {}) {
   return {