@kehto/services 0.14.1 → 0.15.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ServiceHandler, Signer } from '@kehto/runtime';
+import { ServiceHandler, Signer, RelayEventResult } from '@kehto/runtime';
 import { IdentityGetProfileMessage, IdentityGetProfileResultMessage, IdentityGetFollowsMessage, IdentityGetFollowsResultMessage, IdentityGetListMessage, IdentityGetListResultMessage, IdentityGetZapsMessage, IdentityGetZapsResultMessage, IdentityGetMutesMessage, IdentityGetMutesResultMessage, IdentityGetBlockedMessage, IdentityGetBlockedResultMessage, IdentityGetBadgesMessage, IdentityGetBadgesResultMessage } from '@napplet/nap/identity/types';
 import { NostrFilter, NostrEvent, EventTemplate, LinkOpenOptions, LinkOpenResult, ListSupport, ListRef, ListItem, ListOptions, ListMutationResult, SerialOpenRequest, SerialOpenResult, BleEvent, BleOpenRequest, BleOpenResult, BleService, BleAttribute, BleWriteOptions, WebrtcEvent, WebrtcOpenRequest, WebrtcOpenResult, CommonProfileTarget, CommonProfileResult, CommonFollowsResult, CommonActionResult, CommonReaction, CommonReportTarget, CommonReportReason } from '@napplet/core';
 import { MediaMetadata, MediaAction } from '@napplet/nap/media/types';
@@ -1635,7 +1635,7 @@ declare function createResourceService(options: ResourceServiceOptions): Resourc
  *   Inbound:  outbox.getEvent, outbox.query, outbox.subscribe, outbox.close,
  *             outbox.publish, outbox.resolveRelays
  *   Outbound: outbox.getEvent.result, outbox.query.result, outbox.event,
- *             outbox.eose, outbox.closed, outbox.publish.result,
+ *             outbox.closed, outbox.publish.result,
  *             outbox.resolveRelays.result
  *
  * The shell owns relay discovery, routing, fallback, deduplication, signature
@@ -1720,10 +1720,8 @@ interface OutboxRelayPlan {
 }
 /** Outcome of a single-event outbox lookup. */
 interface OutboxEventResult {
-    /** The signature-validated event matching the requested event id, when found. */
-    event?: NostrEvent;
-    /** Relay URLs where the shell observed the event. */
-    relays: string[];
+    /** The signature-validated event result matching the requested event id, when found. */
+    result?: RelayEventResult;
     /** True when some relay lists or connections failed and the lookup was partial. */
     incomplete?: boolean;
     /** Error reason when the lookup could not complete or did not find the event. */
@@ -1731,10 +1729,8 @@ interface OutboxEventResult {
 }
 /** Outcome of an outbox query, as returned by the {@link OutboxRouter}. */
 interface OutboxResult {
-    /** Deduplicated, signature-validated events. */
-    events: NostrEvent[];
-    /** Map of event id -> relay URLs where the shell observed the event. */
-    relays: Record<string, string[]>;
+    /** Deduplicated, signature-validated event results. */
+    events: RelayEventResult[];
     /** True when some relay lists or connections failed and results are partial. */
     incomplete?: boolean;
     /** Error reason when the query could not complete. */
@@ -1755,10 +1751,8 @@ interface OutboxPublishResult {
 }
 /** Sink an {@link OutboxRouter} streams subscription lifecycle through. */
 interface OutboxSubscriptionSink {
-    /** Deliver a matching event; `relay` is the relay it was observed on, when known. */
-    event(event: NostrEvent, relay?: string): void;
-    /** Signal end-of-stored-events. */
-    eose(): void;
+    /** Deliver a matching event result. */
+    event(result: RelayEventResult): void;
     /** Signal that the subscription was closed upstream; `reason` is optional. */
     closed(reason?: string): void;
 }

package/dist/index.js

@@ -426,6 +426,7 @@ function createIdentityService(options) {
 }
 
 // src/relay-pool-service.ts
+import { createRelayEventResultWithHints } from "@kehto/runtime";
 var EOSE_FALLBACK_MS = 15e3;
 function createRelayPoolService(options) {
   const tracked = /* @__PURE__ */ new Map();
@@ -470,7 +471,7 @@ function createRelayPoolService(options) {
             }
             return;
           }
-          send({ type: "relay.event", subId, event: item });
+          send({ type: "relay.event", subId, result: createRelayEventResultWithHints(item, relayUrls2) });
         }, relayUrls2);
         tracked.set(subKey, { handle, eoseTimer });
         return;
@@ -516,6 +517,7 @@ function createRelayPoolService(options) {
 }
 
 // src/cache-service.ts
+import { createRelayEventResult } from "@kehto/runtime";
 function createCacheService(options) {
   return {
     descriptor: {
@@ -535,7 +537,7 @@ function createCacheService(options) {
         }
         options.query(filters).then((events) => {
           for (const event of events) {
-            send({ type: "relay.event", subId, event });
+            send({ type: "relay.event", subId, result: createRelayEventResult(event) });
           }
           send({ type: "relay.eose", subId });
         }).catch(() => {
@@ -647,6 +649,7 @@ function isPlainObject(value) {
 }
 
 // src/coordinated-relay.ts
+import { createRelayEventResult as createRelayEventResult2, createRelayEventResultWithHints as createRelayEventResultWithHints2 } from "@kehto/runtime";
 var DEFAULT_EOSE_TIMEOUT_MS = 15e3;
 function createCoordinatedRelay(options) {
   const timeoutMs = options.eoseTimeoutMs ?? DEFAULT_EOSE_TIMEOUT_MS;
@@ -669,10 +672,13 @@ function createCoordinatedRelay(options) {
     handleMessage(windowId, message, send) {
       const relayMessage = message;
       if (message.type === "relay.subscribe") {
-        let deliver2 = function(event) {
+        let deliver2 = function(event, relayHints) {
           if (tracked.seenIds.has(event.id)) return;
           tracked.seenIds.add(event.id);
-          if (subs.has(subKey)) send({ type: "relay.event", subId, event });
+          if (subs.has(subKey)) {
+            const result2 = relayHints ? createRelayEventResultWithHints2(event, relayHints) : createRelayEventResult2(event);
+            send({ type: "relay.event", subId, result: result2 });
+          }
         };
         var deliver = deliver2;
         const subId = relayMessage.subId;
@@ -728,7 +734,7 @@ function createCoordinatedRelay(options) {
               maybeSendEose(subKey, subId, send);
               return;
             }
-            deliver2(item);
+            deliver2(item, relayUrls2);
             if (cacheAvailable) {
               try {
                 options.cache.store(item);
@@ -2045,12 +2051,10 @@ function buildEventQuery(eventId, eventOptions) {
   return { filter, queryOptions };
 }
 function eventResultFromQuery(eventId, result2) {
-  const event = result2.events.find((candidate) => candidate.id === eventId);
-  const eventResult = {
-    relays: event ? result2.relays[eventId] ?? [] : []
-  };
-  if (event) eventResult.event = event;
-  if (!event) eventResult.error = result2.error ?? "not found";
+  const relayResult = result2.events.find((candidate) => candidate.event.id === eventId);
+  const eventResult = {};
+  if (relayResult) eventResult.result = relayResult;
+  if (!relayResult) eventResult.error = result2.error ?? "not found";
   else if (result2.error !== void 0) eventResult.error = result2.error;
   if (result2.incomplete !== void 0) eventResult.incomplete = result2.incomplete;
   return eventResult;
@@ -2060,15 +2064,14 @@ function fallbackGetEvent(router, eventId, eventOptions) {
   return router.query([filter], queryOptions).then((result2) => eventResultFromQuery(eventId, result2));
 }
 function sendEventResult(id, eventId, result2, send) {
-  if (result2.event && result2.event.id !== eventId) {
-    send({ type: "outbox.getEvent.result", id, relays: [], error: "not found" });
+  if (result2.result && result2.result.event.id !== eventId) {
+    send({ type: "outbox.getEvent.result", id, error: "not found" });
     return;
   }
   send({
     type: "outbox.getEvent.result",
     id,
-    ...result2.event === void 0 ? {} : { event: result2.event },
-    relays: result2.relays,
+    ...result2.result === void 0 ? {} : { result: result2.result },
     ...result2.incomplete === void 0 ? {} : { incomplete: result2.incomplete },
     ...result2.error === void 0 ? {} : { error: result2.error }
   });
@@ -2077,12 +2080,12 @@ 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" });
+    send({ type: "outbox.getEvent.result", id, error: "invalid filter" });
     return;
   }
   const getEvent = router.getEvent ?? ((eventId, eventOptions) => fallbackGetEvent(router, eventId, eventOptions));
   void getEvent(m.eventId, m.options).then((result2) => sendEventResult(id, m.eventId, result2, send)).catch(
-    (err2) => send({ type: "outbox.getEvent.result", id, relays: [], error: toErrorMessage(err2) })
+    (err2) => send({ type: "outbox.getEvent.result", id, error: toErrorMessage(err2) })
   );
 }
 function createOutboxService(options) {
@@ -2096,7 +2099,7 @@ function createOutboxService(options) {
     const id = m.id ?? "";
     const filters = normalizeFilters(m.filters);
     if (!filters) {
-      send({ type: "outbox.query.result", id, events: [], relays: {}, error: "invalid filter" });
+      send({ type: "outbox.query.result", id, events: [], error: "invalid filter" });
       return;
     }
     void router.query(filters, m.options).then(
@@ -2104,12 +2107,11 @@ function createOutboxService(options) {
         type: "outbox.query.result",
         id,
         events: result2.events,
-        relays: result2.relays,
         ...result2.incomplete === void 0 ? {} : { incomplete: result2.incomplete },
         ...result2.error === void 0 ? {} : { error: result2.error }
       })
     ).catch(
-      (err2) => send({ type: "outbox.query.result", id, events: [], relays: {}, error: toErrorMessage(err2) })
+      (err2) => send({ type: "outbox.query.result", id, events: [], error: toErrorMessage(err2) })
     );
   }
   function handleSubscribe(windowId, msg, send) {
@@ -2125,8 +2127,7 @@ function createOutboxService(options) {
       return;
     }
     const sink = {
-      event: (event, relay) => send({ type: "outbox.event", subId, event, ...relay === void 0 ? {} : { relay } }),
-      eose: () => send({ type: "outbox.eose", subId }),
+      event: (result2) => send({ type: "outbox.event", subId, result: result2 }),
       closed: (reason) => {
         subscriptions.delete(subKey);
         send({ type: "outbox.closed", subId, ...reason === void 0 ? {} : { reason } });
@@ -2219,6 +2220,7 @@ function toErrorMessage(err2) {
 }
 
 // src/relay-pool-outbox-router.ts
+import { createRelayEventResultWithHints as createRelayEventResultWithHints3 } from "@kehto/runtime";
 var DEFAULT_QUERY_TIMEOUT_MS = 4e3;
 function defaultRelayAllowed(url) {
   return typeof url === "string" && (url.startsWith("wss://") || url.startsWith("ws://"));
@@ -2292,10 +2294,10 @@ function admitEvent(ctx, collector, event) {
   );
 }
 function buildCollectResult(collector, timedOut) {
-  const events = [...collector.seen.values()];
-  const relayObj = {};
-  for (const event of events) relayObj[event.id] = [...collector.relayMap.get(event.id) ?? []];
-  return { events, relayMap: relayObj, incomplete: timedOut };
+  const events = [...collector.seen.values()].map(
+    (event) => createRelayEventResultWithHints3(event, [...collector.relayMap.get(event.id) ?? []])
+  );
+  return { events, incomplete: timedOut };
 }
 function collectFromRelays(ctx, filters, relayUrls2, timeoutMs) {
   return new Promise((resolve) => {
@@ -2340,28 +2342,28 @@ function relayPoolSubscribe(ctx, filters, relayUrl, cb) {
 }
 async function queryImpl(ctx, filters, options) {
   if (!ctx.relayPool.isAvailable()) {
-    return { events: [], relays: {}, incomplete: true, error: "relay list unavailable" };
+    return { events: [], incomplete: true, error: "relay list unavailable" };
   }
   const strategy = options?.strategy ?? "auto";
   const authors = deriveAuthors(filters, options?.authors);
   const plan = await resolvePlan(ctx, authors, "read", strategy, options?.relays);
   if (plan.relays.length === 0) {
-    return { events: [], relays: {}, incomplete: true, error: "relay list unavailable" };
+    return { events: [], incomplete: true, error: "relay list unavailable" };
   }
   const timeoutMs = options?.timeoutMs ?? ctx.defaultTimeoutMs;
   const collected = await collectFromRelays(ctx, filters, plan.relays, timeoutMs);
   const incomplete = collected.incomplete || (plan.missingAuthors?.length ?? 0) > 0;
   let events = collected.events;
   if (options?.limit !== void 0 && events.length > options.limit) {
-    events = [...events].sort((a, b) => b.created_at - a.created_at).slice(0, options.limit);
+    events = [...events].sort((a, b) => b.event.created_at - a.event.created_at).slice(0, options.limit);
   }
-  const result2 = { events, relays: collected.relayMap };
+  const result2 = { events };
   if (incomplete) result2.incomplete = true;
   return result2;
 }
 async function getEventImpl(ctx, eventId, options) {
   if (typeof eventId !== "string" || eventId.length === 0) {
-    return { relays: [], error: "invalid filter" };
+    return { error: "invalid filter" };
   }
   const filter = { ids: [eventId] };
   const queryOptions = { limit: 1 };
@@ -2373,12 +2375,10 @@ async function getEventImpl(ctx, eventId, options) {
   if (options?.strategy !== void 0) queryOptions.strategy = options.strategy;
   if (options?.timeoutMs !== void 0) queryOptions.timeoutMs = options.timeoutMs;
   const queryResult = await queryImpl(ctx, [filter], queryOptions);
-  const event = queryResult.events.find((candidate) => candidate.id === eventId);
-  const result2 = {
-    relays: event ? queryResult.relays[eventId] ?? [] : []
-  };
-  if (event) result2.event = event;
-  if (!event) result2.error = queryResult.error ?? "not found";
+  const eventResult = queryResult.events.find((candidate) => candidate.event.id === eventId);
+  const result2 = {};
+  if (eventResult) result2.result = eventResult;
+  if (!eventResult) result2.error = queryResult.error ?? "not found";
   else if (queryResult.error !== void 0) result2.error = queryResult.error;
   if (queryResult.incomplete !== void 0) result2.incomplete = queryResult.incomplete;
   return result2;
@@ -2399,7 +2399,6 @@ function attachLiveRelay(ctx, sub, filters, relayUrl, live, sink) {
       sub.eoseCount += 1;
       if (!sub.eoseSent && sub.eoseCount >= sub.relayCount) {
         sub.eoseSent = true;
-        sink.eose();
         if (!live) {
           sub.closed = true;
           closeLiveSub(sub);
@@ -2412,7 +2411,7 @@ function attachLiveRelay(ctx, sub, filters, relayUrl, live, sink) {
     void ctx.verify(item).then((ok) => {
       if (!ok || sub.closed || sub.seen.has(item.id)) return;
       sub.seen.add(item.id);
-      sink.event(item, relayUrl);
+      sink.event(createRelayEventResultWithHints3(item, [relayUrl]));
     });
   }));
 }