@kehto/services 0.16.1 → 0.16.5

package/dist/index.js

@@ -785,8 +785,7 @@ function createCoordinatedRelay(options) {
   };
 }
 
-// src/keys-service.ts
-var KEYS_SERVICE_VERSION = "1.2.0";
+// src/keys-service-internals.ts
 var MODIFIER_ALIASES = {
   ctrl: "ctrl",
   control: "ctrl",
@@ -815,127 +814,242 @@ function parseChord(chord) {
   out.key = keyTok.length === 1 ? keyTok.toUpperCase() : keyTok;
   return out;
 }
+function formatChord(spec) {
+  const parts = [];
+  if (spec.alt) parts.push("Alt");
+  if (spec.ctrl) parts.push("Ctrl");
+  if (spec.shift) parts.push("Shift");
+  if (spec.meta) parts.push("Meta");
+  parts.push(spec.key);
+  return parts.join("+");
+}
+var BROWSER_RESERVED_CTRL_KEYS = /* @__PURE__ */ new Set(["L", "N", "R", "T", "W"]);
+function isReservedKeyChord(spec) {
+  if (spec.key === "Tab" || spec.key === "Escape") return true;
+  if ((spec.ctrl || spec.meta) && !spec.alt && BROWSER_RESERVED_CTRL_KEYS.has(spec.key)) return true;
+  if (spec.alt && !spec.ctrl && !spec.meta && (spec.key === "ArrowLeft" || spec.key === "ArrowRight")) {
+    return true;
+  }
+  return false;
+}
+function chordSpecKey(spec) {
+  return `${spec.ctrl}|${spec.alt}|${spec.shift}|${spec.meta}|${spec.key}`;
+}
+function forwardPayload(m) {
+  return {
+    key: m.key,
+    code: m.code,
+    ctrlKey: m.ctrl,
+    altKey: m.alt,
+    shiftKey: m.shift,
+    metaKey: m.meta
+  };
+}
+function eventKey(ev) {
+  const k = ev.key.length === 1 ? ev.key.toUpperCase() : ev.key;
+  return `${ev.ctrlKey}|${ev.altKey}|${ev.shiftKey}|${ev.metaKey}|${k}`;
+}
+function bindingsForWindow(windowId, registry, windowIndex) {
+  const actionIds = windowIndex.get(windowId);
+  if (!actionIds) return [];
+  const bindings = [];
+  for (const actionId of actionIds) {
+    const entry = registry.get(actionId);
+    if (!entry || entry.windowId !== windowId) continue;
+    bindings.push({ actionId, key: entry.chordString });
+  }
+  return bindings;
+}
+function pushBindings(windowId, registry, windowIndex, send) {
+  const payload = {
+    type: "keys.bindings",
+    bindings: bindingsForWindow(windowId, registry, windowIndex)
+  };
+  send(payload);
+}
+function removeActionFromWindowIndex(actionId, windowIndex) {
+  for (const [wid, set] of windowIndex.entries()) {
+    if (set.delete(actionId) && set.size === 0) windowIndex.delete(wid);
+  }
+}
+
+// src/keys-service.ts
+var KEYS_SERVICE_VERSION = "1.3.0";
+function rememberActionForWindow(windowIndex, windowId, actionId) {
+  if (!windowIndex.has(windowId)) windowIndex.set(windowId, /* @__PURE__ */ new Set());
+  windowIndex.get(windowId).add(actionId);
+}
+function bindActionEntry(registry, windowIndex, actionId, windowId, chord, chordString) {
+  registry.set(actionId, { chord, chordString, windowId });
+  rememberActionForWindow(windowIndex, windowId, actionId);
+}
+function bindActionAndMarkChanged(registry, windowIndex, changedWindowIds, actionId, windowId, chord, chordString) {
+  bindActionEntry(registry, windowIndex, actionId, windowId, chord, chordString);
+  changedWindowIds.add(windowId);
+  return chordString;
+}
+function handleForwardMessage(message, onForward) {
+  onForward?.(forwardPayload(message));
+}
+function sendUnknownKeysMethod(send, message) {
+  const id = message.id ?? "";
+  send({
+    type: `${message.type}.error`,
+    id,
+    error: `Unknown keys method: ${message.type}`
+  });
+}
+function createKeysMessageHandler(options) {
+  return (windowId, message, send) => {
+    switch (message.type) {
+      case "keys.forward":
+        handleForwardMessage(message, options.onForward);
+        return;
+      case "keys.registerAction":
+        options.onRegisterAction(windowId, message, send);
+        return;
+      case "keys.unregisterAction":
+        options.onUnregisterAction(windowId, message, send);
+        return;
+      default:
+        sendUnknownKeysMethod(send, message);
+    }
+  };
+}
+function sendRegisterActionResult(send, message, binding, error) {
+  const result2 = {
+    type: "keys.registerAction.result",
+    id: message.id,
+    actionId: message.action.id,
+    ...binding ? { binding } : {},
+    ...error ? { error } : {}
+  };
+  send(result2);
+}
+function pushChangedBindings(changedWindowIds, registry, windowIndex, sendHandles, fallbackSend) {
+  for (const changedWindowId of changedWindowIds) {
+    const ownerSend = sendHandles.get(changedWindowId) ?? fallbackSend;
+    pushBindings(changedWindowId, registry, windowIndex, ownerSend);
+    if (!windowIndex.has(changedWindowId)) sendHandles.delete(changedWindowId);
+  }
+}
 function createKeysService(options = {}) {
   const descriptor = {
     name: "keys",
     version: KEYS_SERVICE_VERSION,
     description: options.hostBridge ? "NIP-5D keys NAP reference handler (host-bridge delegated)" : "NIP-5D keys NAP reference handler (document-level chord listener)"
   };
-  function chordSpecKey(spec) {
-    return `${spec.ctrl}|${spec.alt}|${spec.shift}|${spec.meta}|${spec.key}`;
-  }
   const reservedChordKeys = /* @__PURE__ */ new Set();
   if (options.reservedChords) {
     for (const chordStr of options.reservedChords) {
       reservedChordKeys.add(chordSpecKey(parseChord(chordStr)));
     }
   }
-  function forwardKey(m) {
-    const k = m.key.length === 1 ? m.key.toUpperCase() : m.key;
-    return `${m.ctrl}|${m.alt}|${m.shift}|${m.meta}|${k}`;
-  }
-  function forwardPayload(m) {
-    return {
-      key: m.key,
-      code: m.code,
-      ctrlKey: m.ctrl,
-      altKey: m.alt,
-      shiftKey: m.shift,
-      metaKey: m.meta
-    };
-  }
-  function eventKey(ev) {
-    const k = ev.key.length === 1 ? ev.key.toUpperCase() : ev.key;
-    return `${ev.ctrlKey}|${ev.altKey}|${ev.shiftKey}|${ev.metaKey}|${k}`;
-  }
+  const isUnavailableBinding = (chord) => reservedChordKeys.has(chordSpecKey(chord)) || isReservedKeyChord(chord);
   if (options.hostBridge) {
     const bridge = options.hostBridge;
     const bridgeWindowActions = /* @__PURE__ */ new Map();
+    const bridgeActionRegistry = /* @__PURE__ */ new Map();
+    const bridgeSendHandles = /* @__PURE__ */ new Map();
     const unsubscribeHandles = /* @__PURE__ */ new Map();
-    return {
-      descriptor,
-      handleMessage(windowId, message, send) {
-        switch (message.type) {
-          case "keys.forward": {
-            const m = message;
-            const reserved = reservedChordKeys.has(forwardKey(m));
-            options.onForward?.(forwardPayload(m));
-            if (reserved) {
-              return;
-            }
-            return;
-          }
-          case "keys.registerAction": {
-            const m = message;
-            if (m.action.defaultKey) {
-              try {
-                const unsubscribe = bridge.subscribe(m.action.defaultKey, (ev) => {
-                  const e = ev;
-                  if ("repeat" in e && e.repeat) return;
-                  options.onForward?.({
-                    key: e.key,
-                    code: e.code,
-                    ctrlKey: e.ctrlKey,
-                    altKey: e.altKey,
-                    shiftKey: e.shiftKey,
-                    metaKey: e.metaKey
-                  });
-                  const payload = {
-                    type: "keys.action",
-                    actionId: m.action.id
-                  };
-                  send(payload);
-                });
-                unsubscribeHandles.set(m.action.id, unsubscribe);
-                if (!bridgeWindowActions.has(windowId)) bridgeWindowActions.set(windowId, /* @__PURE__ */ new Set());
-                bridgeWindowActions.get(windowId).add(m.action.id);
-              } catch (err2) {
-                const id = m.id ?? "";
-                send({
-                  type: "keys.registerAction.error",
-                  id,
-                  error: `bridge subscribe failed: ${err2.message}`
-                });
-                return;
-              }
-            }
-            const result2 = {
-              type: "keys.registerAction.result",
-              id: m.id,
-              actionId: m.action.id,
-              ...m.action.defaultKey ? { binding: m.action.defaultKey } : {}
-            };
-            send(result2);
-            return;
+    const handleBridgeRegisterAction = (windowId, m, send) => {
+      bridgeSendHandles.set(windowId, send);
+      let binding;
+      const changedWindowIds = /* @__PURE__ */ new Set();
+      if (m.action.defaultKey) {
+        try {
+          const chord = parseChord(m.action.defaultKey);
+          const normalizedChord = formatChord(chord);
+          const existingEntry = bridgeActionRegistry.get(m.action.id);
+          const existing = unsubscribeHandles.get(m.action.id);
+          let nextUnsubscribe;
+          if (!isUnavailableBinding(chord)) {
+            nextUnsubscribe = bridge.subscribe(normalizedChord, (ev) => {
+              const e = ev;
+              if ("repeat" in e && e.repeat) return;
+              options.onForward?.({
+                key: e.key,
+                code: e.code,
+                ctrlKey: e.ctrlKey,
+                altKey: e.altKey,
+                shiftKey: e.shiftKey,
+                metaKey: e.metaKey
+              });
+              const payload = {
+                type: "keys.action",
+                actionId: m.action.id
+              };
+              send(payload);
+            });
           }
-          case "keys.unregisterAction": {
-            const m = message;
-            if (m.actionId) {
-              const unsubscribe = unsubscribeHandles.get(m.actionId);
-              if (unsubscribe) {
-                try {
-                  unsubscribe();
-                } catch {
-                }
-                unsubscribeHandles.delete(m.actionId);
-                for (const [wid, set] of bridgeWindowActions.entries()) {
-                  if (set.delete(m.actionId) && set.size === 0) bridgeWindowActions.delete(wid);
-                }
-              }
+          if (existing) {
+            try {
+              existing();
+            } catch {
             }
-            return;
+            unsubscribeHandles.delete(m.action.id);
           }
-          default: {
-            const id = message.id ?? "";
-            send({
-              type: `${message.type}.error`,
-              id,
-              error: `Unknown keys method: ${message.type}`
-            });
-            return;
+          if (existingEntry) changedWindowIds.add(existingEntry.windowId);
+          removeActionFromWindowIndex(m.action.id, bridgeWindowActions);
+          bridgeActionRegistry.delete(m.action.id);
+          if (nextUnsubscribe) {
+            unsubscribeHandles.set(m.action.id, nextUnsubscribe);
+            binding = bindActionAndMarkChanged(
+              bridgeActionRegistry,
+              bridgeWindowActions,
+              changedWindowIds,
+              m.action.id,
+              windowId,
+              chord,
+              normalizedChord
+            );
           }
+        } catch (err2) {
+          sendRegisterActionResult(
+            send,
+            m,
+            void 0,
+            `bridge subscribe failed: ${err2.message}`
+          );
+          return;
         }
-      },
+      }
+      sendRegisterActionResult(send, m, binding);
+      pushChangedBindings(
+        changedWindowIds,
+        bridgeActionRegistry,
+        bridgeWindowActions,
+        bridgeSendHandles,
+        send
+      );
+    };
+    const handleBridgeUnregisterAction = (_windowId, m, send) => {
+      if (!m.actionId) return;
+      const unsubscribe = unsubscribeHandles.get(m.actionId);
+      const entry = bridgeActionRegistry.get(m.actionId);
+      if (!unsubscribe) return;
+      try {
+        unsubscribe();
+      } catch {
+      }
+      unsubscribeHandles.delete(m.actionId);
+      bridgeActionRegistry.delete(m.actionId);
+      removeActionFromWindowIndex(m.actionId, bridgeWindowActions);
+      if (entry) {
+        const ownerSend = bridgeSendHandles.get(entry.windowId) ?? send;
+        pushBindings(entry.windowId, bridgeActionRegistry, bridgeWindowActions, ownerSend);
+        if (!bridgeWindowActions.has(entry.windowId)) {
+          bridgeSendHandles.delete(entry.windowId);
+        }
+      }
+    };
+    return {
+      descriptor,
+      handleMessage: createKeysMessageHandler({
+        onForward: options.onForward,
+        onRegisterAction: handleBridgeRegisterAction,
+        onUnregisterAction: handleBridgeUnregisterAction
+      }),
       onWindowDestroyed(windowId) {
         const actions = bridgeWindowActions.get(windowId);
         if (!actions) return;
@@ -948,8 +1062,10 @@ function createKeysService(options = {}) {
             }
           }
           unsubscribeHandles.delete(actionId);
+          bridgeActionRegistry.delete(actionId);
         }
         bridgeWindowActions.delete(windowId);
+        bridgeSendHandles.delete(windowId);
       },
       destroy() {
         for (const unsubscribe of unsubscribeHandles.values()) {
@@ -959,7 +1075,9 @@ function createKeysService(options = {}) {
           }
         }
         unsubscribeHandles.clear();
+        bridgeActionRegistry.clear();
         bridgeWindowActions.clear();
+        bridgeSendHandles.clear();
       }
     };
   }
@@ -1003,8 +1121,7 @@ function createKeysService(options = {}) {
         if (send) {
           const payload = {
             type: "keys.action",
-            actionId,
-            chord: entry.chord
+            actionId
           };
           send(payload);
         }
@@ -1012,76 +1129,56 @@ function createKeysService(options = {}) {
     }
   };
   target.addEventListener("keydown", listener);
-  return {
-    descriptor,
-    handleMessage(windowId, message, send) {
-      switch (message.type) {
-        case "keys.forward": {
-          const m = message;
-          const reserved = reservedChordKeys.has(forwardKey(m));
-          options.onForward?.(forwardPayload(m));
-          if (reserved) return;
-          return;
-        }
-        case "keys.registerAction": {
-          const m = message;
-          sendHandles.set(windowId, send);
-          if (m.action.defaultKey) {
-            try {
-              const chord = parseChord(m.action.defaultKey);
-              actionRegistry.set(m.action.id, {
-                chord,
-                chordString: m.action.defaultKey,
-                windowId
-              });
-              if (!windowActions.has(windowId)) windowActions.set(windowId, /* @__PURE__ */ new Set());
-              windowActions.get(windowId).add(m.action.id);
-            } catch (err2) {
-              const id = m.id ?? "";
-              send({
-                type: "keys.registerAction.error",
-                id,
-                error: `invalid chord: ${err2.message}`
-              });
-              return;
-            }
-          }
-          const result2 = {
-            type: "keys.registerAction.result",
-            id: m.id,
-            actionId: m.action.id,
-            ...m.action.defaultKey ? { binding: m.action.defaultKey } : {}
-          };
-          send(result2);
-          return;
-        }
-        case "keys.unregisterAction": {
-          const m = message;
-          if (m.actionId && actionRegistry.has(m.actionId)) {
-            const entry = actionRegistry.get(m.actionId);
-            actionRegistry.delete(m.actionId);
-            const set = windowActions.get(entry.windowId);
-            if (set) {
-              set.delete(m.actionId);
-              if (set.size === 0) {
-                windowActions.delete(entry.windowId);
-                sendHandles.delete(entry.windowId);
-              }
-            }
-          }
-          return;
+  const handleDocumentRegisterAction = (windowId, m, send) => {
+    sendHandles.set(windowId, send);
+    let binding;
+    const changedWindowIds = /* @__PURE__ */ new Set();
+    if (m.action.defaultKey) {
+      try {
+        const chord = parseChord(m.action.defaultKey);
+        const normalizedChord = formatChord(chord);
+        const existing = actionRegistry.get(m.action.id);
+        if (existing) {
+          changedWindowIds.add(existing.windowId);
+          removeActionFromWindowIndex(m.action.id, windowActions);
+          actionRegistry.delete(m.action.id);
         }
-        default: {
-          const id = message.id ?? "";
-          send({
-            type: `${message.type}.error`,
-            id,
-            error: `Unknown keys method: ${message.type}`
-          });
-          return;
+        if (!isUnavailableBinding(chord)) {
+          binding = bindActionAndMarkChanged(actionRegistry, windowActions, changedWindowIds, m.action.id, windowId, chord, normalizedChord);
         }
+      } catch (err2) {
+        sendRegisterActionResult(
+          send,
+          m,
+          void 0,
+          `invalid chord: ${err2.message}`
+        );
+        return;
       }
-    },
+    }
+    sendRegisterActionResult(send, m, binding);
+    pushChangedBindings(changedWindowIds, actionRegistry, windowActions, sendHandles, send);
+  };
+  const handleDocumentUnregisterAction = (_windowId, m, send) => {
+    if (!m.actionId || !actionRegistry.has(m.actionId)) return;
+    const entry = actionRegistry.get(m.actionId);
+    actionRegistry.delete(m.actionId);
+    const set = windowActions.get(entry.windowId);
+    if (set) {
+      set.delete(m.actionId);
+      if (set.size === 0) windowActions.delete(entry.windowId);
+    }
+    const ownerSend = sendHandles.get(entry.windowId) ?? send;
+    pushBindings(entry.windowId, actionRegistry, windowActions, ownerSend);
+    if (!windowActions.has(entry.windowId)) sendHandles.delete(entry.windowId);
+  };
+  return {
+    descriptor,
+    handleMessage: createKeysMessageHandler({
+      onForward: options.onForward,
+      onRegisterAction: handleDocumentRegisterAction,
+      onUnregisterAction: handleDocumentUnregisterAction
+    }),
     onWindowDestroyed(windowId) {
       const actions = windowActions.get(windowId);
       if (actions) {
@@ -2070,8 +2167,9 @@ function sanitizePublishOptions(raw) {
   const out = {};
   const relays = stringArray(raw.relays);
   if (relays) out.relays = relays;
-  const targetAuthors = stringArray(raw.targetAuthors);
-  if (targetAuthors) out.targetAuthors = targetAuthors;
+  if (typeof raw.toOutbox === "boolean") out.toOutbox = raw.toOutbox;
+  const toInboxes = stringArray(raw.toInboxes);
+  if (toInboxes) out.toInboxes = toInboxes;
   return Object.keys(out).length > 0 ? out : void 0;
 }
 function sanitizeTarget(raw) {
@@ -2293,9 +2391,33 @@ function allowed(ctx, urls) {
   }
   return [...out];
 }
+async function resolveRequiredRelays(ctx, pubkeys, direction) {
+  const useWrite = direction === "read";
+  const relays = /* @__PURE__ */ new Set();
+  const missingAuthors = [];
+  const deniedAuthors = [];
+  const uniquePubkeys = [...new Set(pubkeys)];
+  if (uniquePubkeys.length === 0) return { relays: [], missingAuthors, deniedAuthors };
+  const lists = await ctx.loadRelayLists(uniquePubkeys);
+  for (const pubkey of uniquePubkeys) {
+    const entry = lists.get(pubkey);
+    const candidateRelays = entry ? useWrite ? entry.write : entry.read : void 0;
+    if (!candidateRelays || candidateRelays.length === 0) {
+      missingAuthors.push(pubkey);
+      continue;
+    }
+    const allowedRelays = allowed(ctx, candidateRelays);
+    if (allowedRelays.length === 0) {
+      deniedAuthors.push(pubkey);
+      continue;
+    }
+    for (const url of allowedRelays) relays.add(url);
+  }
+  return { relays: [...relays], missingAuthors, deniedAuthors };
+}
 async function resolvePlan(ctx, pubkeys, direction, relayHints) {
   const useWrite = direction === "read";
-  const collected = /* @__PURE__ */ new Set();
+  const discovered = /* @__PURE__ */ new Set();
   const missingAuthors = [];
   let sawNip65 = false;
   if (pubkeys.length > 0) {
@@ -2305,25 +2427,46 @@ async function resolvePlan(ctx, pubkeys, direction, relayHints) {
       const relays2 = entry ? useWrite ? entry.write : entry.read : void 0;
       if (relays2 && relays2.length > 0) {
         sawNip65 = true;
-        for (const url of relays2) collected.add(url);
+        for (const url of relays2) discovered.add(url);
       } else {
         missingAuthors.push(pubkey);
       }
     }
   }
-  for (const url of relayHints ?? []) collected.add(url);
-  let relays = allowed(ctx, collected);
+  const hintRelays = allowed(ctx, relayHints ?? []);
+  let relays = allowed(ctx, discovered);
   let source;
-  if (relays.length === 0) {
-    relays = allowed(ctx, ctx.fallbackRelays);
-    source = "fallback";
-  } else {
+  if (relays.length > 0) {
     source = sawNip65 ? "nip65" : "policy";
+  } else {
+    relays = allowed(ctx, ctx.fallbackRelays);
+    source = relays.length > 0 ? "fallback" : "policy";
+  }
+  for (const url of hintRelays) {
+    if (!relays.includes(url)) relays.push(url);
   }
+  if (relays.length === 0) source = "fallback";
   const plan = { relays, source };
   if (missingAuthors.length > 0) plan.missingAuthors = missingAuthors;
   return plan;
 }
+function discoveredReadRelays(ctx, authors, lists) {
+  const relays = /* @__PURE__ */ new Set();
+  const missingAuthors = [];
+  for (const author of new Set(authors)) {
+    const writeRelays = lists.get(author)?.write;
+    if (!writeRelays || writeRelays.length === 0) {
+      missingAuthors.push(author);
+      continue;
+    }
+    for (const url of allowed(ctx, writeRelays)) relays.add(url);
+  }
+  return { relays: [...relays], missingAuthors };
+}
+function immediateReadRelays(ctx, relayHints) {
+  const hints = allowed(ctx, relayHints ?? []);
+  return hints.length > 0 ? hints : allowed(ctx, ctx.fallbackRelays);
+}
 function recordRelay(collector, id, relayUrl) {
   let set = collector.relayMap.get(id);
   if (!set) {
@@ -2332,81 +2475,166 @@ function recordRelay(collector, id, relayUrl) {
   }
   set.add(relayUrl);
 }
-function admitEvent(ctx, collector, event) {
-  if (collector.seen.has(event.id)) return;
-  collector.verifications.push(
-    ctx.verify(event).then((ok) => {
-      if (ok && !collector.seen.has(event.id)) collector.seen.set(event.id, event);
-      else if (!ok) collector.relayMap.delete(event.id);
-    })
-  );
-}
-function buildCollectResult(collector, 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) => {
-    const collector = { seen: /* @__PURE__ */ new Map(), relayMap: /* @__PURE__ */ new Map(), verifications: [] };
-    const handles = [];
-    let eoseCount = 0;
-    let finished = false;
-    let timedOut = false;
-    function finalize() {
-      if (finished) return;
-      finished = true;
-      clearTimeout(timer);
-      for (const handle of handles) {
-        try {
-          handle.unsubscribe();
-        } catch {
-        }
-      }
-      void Promise.all(collector.verifications).then(() => resolve(buildCollectResult(collector, timedOut)));
+function collectedEventResult(collector, event) {
+  return createRelayEventResultWithHints3(event, [...collector.relayMap.get(event.id) ?? []]);
+}
+function admitEvent(ctx, collector, event, sink, isOpen, onSettled) {
+  if (collector.admitted.has(event.id)) return;
+  collector.admitted.add(event.id);
+  collector.pendingVerifications += 1;
+  void ctx.verify(event).then((ok) => {
+    if (!isOpen()) return;
+    if (!ok) {
+      collector.relayMap.delete(event.id);
+      return;
     }
-    const timer = setTimeout(() => {
-      timedOut = true;
-      finalize();
-    }, timeoutMs);
-    for (const relayUrl of relayUrls2) {
-      handles.push(relayPoolSubscribe(ctx, filters, relayUrl, (item) => {
-        if (finished) return;
-        if (item === "EOSE") {
-          eoseCount += 1;
-          if (eoseCount >= relayUrls2.length) finalize();
-          return;
-        }
-        recordRelay(collector, item.id, relayUrl);
-        admitEvent(ctx, collector, item);
-      }));
+    collector.seen.set(event.id, event);
+    try {
+      sink.event(collectedEventResult(collector, event));
+    } catch {
     }
-    if (relayUrls2.length === 0) finalize();
+  }).finally(() => {
+    collector.pendingVerifications -= 1;
+    onSettled();
   });
 }
+function buildQueryResult(collector, options, incomplete, subscribedAny) {
+  let events = [...collector.seen.values()].map((event) => collectedEventResult(collector, event));
+  if (options?.limit !== void 0 && events.length > options.limit) {
+    events = [...events].sort((a, b) => b.event.created_at - a.event.created_at).slice(0, options.limit);
+  }
+  const result2 = { events };
+  if (incomplete || !subscribedAny) result2.incomplete = true;
+  if (!subscribedAny) result2.error = "relay list unavailable";
+  return result2;
+}
 function relayPoolSubscribe(ctx, filters, relayUrl, cb) {
   return ctx.relayPool.subscribe(filters, [relayUrl], cb);
 }
-async function queryImpl(ctx, filters, options) {
+function startQueryImpl(ctx, filters, options, sink) {
   if (!ctx.relayPool.isAvailable()) {
-    return { events: [], incomplete: true, error: "relay list unavailable" };
+    return {
+      result: Promise.resolve({ events: [], incomplete: true, error: "relay list unavailable" }),
+      close() {
+      }
+    };
   }
   const authors = deriveAuthors(filters, options?.authors);
-  const plan = await resolvePlan(ctx, authors, "read", options?.relays);
-  if (plan.relays.length === 0) {
-    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.event.created_at - a.event.created_at).slice(0, options.limit);
+  const collector = {
+    seen: /* @__PURE__ */ new Map(),
+    admitted: /* @__PURE__ */ new Set(),
+    relayMap: /* @__PURE__ */ new Map(),
+    pendingVerifications: 0
+  };
+  const handles = /* @__PURE__ */ new Map();
+  const activeRelays = /* @__PURE__ */ new Set();
+  const eoseRelays = /* @__PURE__ */ new Set();
+  let discoveryPending = authors.length > 0;
+  let incomplete = false;
+  let subscribedAny = false;
+  let finished = false;
+  let resolveResult;
+  const result2 = new Promise((resolve) => {
+    resolveResult = resolve;
+  });
+  let timer;
+  function closeHandles() {
+    for (const handle of handles.values()) {
+      try {
+        handle.unsubscribe();
+      } catch {
+      }
+    }
+    handles.clear();
+  }
+  function finalize(forceIncomplete = false) {
+    if (finished) return;
+    finished = true;
+    incomplete ||= forceIncomplete;
+    clearTimeout(timer);
+    closeHandles();
+    resolveResult(buildQueryResult(collector, options, incomplete, subscribedAny));
+  }
+  function maybeFinalize() {
+    if (finished || discoveryPending || collector.pendingVerifications > 0) return;
+    if (activeRelays.size === 0 || eoseRelays.size >= activeRelays.size) finalize();
+  }
+  function attachRelay(relayUrl) {
+    if (finished || activeRelays.has(relayUrl)) return;
+    activeRelays.add(relayUrl);
+    try {
+      const handle = relayPoolSubscribe(ctx, filters, relayUrl, (item) => {
+        if (finished) return;
+        if (item === "EOSE") {
+          eoseRelays.add(relayUrl);
+          maybeFinalize();
+          return;
+        }
+        recordRelay(collector, item.id, relayUrl);
+        admitEvent(ctx, collector, item, sink, () => !finished, maybeFinalize);
+      });
+      subscribedAny = true;
+      if (finished) {
+        try {
+          handle.unsubscribe();
+        } catch {
+        }
+      } else {
+        handles.set(relayUrl, handle);
+      }
+    } catch {
+      activeRelays.delete(relayUrl);
+      incomplete = true;
+    }
   }
-  const result2 = { events };
-  if (incomplete) result2.incomplete = true;
-  return result2;
+  function attachMany(relayUrls2) {
+    for (const relayUrl of relayUrls2) attachRelay(relayUrl);
+  }
+  timer = setTimeout(() => finalize(true), options?.timeoutMs ?? ctx.defaultTimeoutMs);
+  if (authors.length === 0) {
+    discoveryPending = false;
+    attachMany(allowed(ctx, [...ctx.fallbackRelays, ...options?.relays ?? []]));
+    maybeFinalize();
+  } else {
+    let loaded;
+    try {
+      loaded = ctx.loadRelayLists(authors);
+    } catch {
+      discoveryPending = false;
+      incomplete = true;
+      attachMany(immediateReadRelays(ctx, options?.relays));
+      maybeFinalize();
+      return { result: result2, close: () => finalize(true) };
+    }
+    if (loaded instanceof Map) {
+      const discovery = discoveredReadRelays(ctx, authors, loaded);
+      discoveryPending = false;
+      incomplete ||= discovery.missingAuthors.length > 0;
+      const initial = allowed(ctx, [...options?.relays ?? [], ...discovery.relays]);
+      attachMany(initial.length > 0 ? initial : allowed(ctx, ctx.fallbackRelays));
+      maybeFinalize();
+    } else {
+      attachMany(immediateReadRelays(ctx, options?.relays));
+      void Promise.resolve(loaded).then((lists) => {
+        if (finished) return;
+        const discovery = discoveredReadRelays(ctx, authors, lists);
+        discoveryPending = false;
+        incomplete ||= discovery.missingAuthors.length > 0;
+        attachMany(discovery.relays);
+        maybeFinalize();
+      }).catch(() => {
+        if (finished) return;
+        discoveryPending = false;
+        incomplete = true;
+        maybeFinalize();
+      });
+    }
+  }
+  return { result: result2, close: () => finalize(true) };
+}
+function queryImpl(ctx, filters, options) {
+  return startQueryImpl(ctx, filters, options, { event: () => {
+  } }).result;
 }
 async function getEventImpl(ctx, eventId, options) {
   if (typeof eventId !== "string" || eventId.length === 0) {
@@ -2430,57 +2658,138 @@ async function getEventImpl(ctx, eventId, options) {
   return result2;
 }
 function closeLiveSub(sub) {
-  for (const handle of sub.handles) {
+  for (const handle of sub.handles.values()) {
     try {
       handle.unsubscribe();
     } catch {
     }
   }
-  sub.handles.length = 0;
+  sub.handles.clear();
 }
 function attachLiveRelay(ctx, sub, filters, relayUrl, sink) {
-  sub.handles.push(relayPoolSubscribe(ctx, filters, relayUrl, (item) => {
-    if (sub.closed) return;
-    if (item === "EOSE") return;
-    if (sub.seen.has(item.id)) return;
-    void ctx.verify(item).then((ok) => {
-      if (!ok || sub.closed || sub.seen.has(item.id)) return;
-      sub.seen.add(item.id);
-      sink.event(createRelayEventResultWithHints3(item, [relayUrl]));
+  if (sub.closed || sub.relays.has(relayUrl)) return false;
+  sub.relays.add(relayUrl);
+  try {
+    const handle = relayPoolSubscribe(ctx, filters, relayUrl, (item) => {
+      if (sub.closed || item === "EOSE" || sub.admitted.has(item.id)) return;
+      sub.admitted.add(item.id);
+      void ctx.verify(item).then((ok) => {
+        if (!ok || sub.closed || sub.seen.has(item.id)) return;
+        sub.seen.add(item.id);
+        sink.event(createRelayEventResultWithHints3(item, [relayUrl]));
+      });
     });
-  }));
+    if (sub.closed) {
+      try {
+        handle.unsubscribe();
+      } catch {
+      }
+    } else {
+      sub.handles.set(relayUrl, handle);
+    }
+    return true;
+  } catch {
+    sub.relays.delete(relayUrl);
+    return false;
+  }
 }
 function startSubscription(ctx, filters, options, sink) {
   const authors = deriveAuthors(filters, options?.authors);
-  const sub = { handles: [], seen: /* @__PURE__ */ new Set(), closed: false };
-  void resolvePlan(ctx, authors, "read", options?.relays).then((plan) => {
-    if (sub.closed) return;
-    if (plan.relays.length === 0) {
-      sink.closed("relay list unavailable");
-      return;
+  const sub = {
+    handles: /* @__PURE__ */ new Map(),
+    relays: /* @__PURE__ */ new Set(),
+    admitted: /* @__PURE__ */ new Set(),
+    seen: /* @__PURE__ */ new Set(),
+    closed: false
+  };
+  let discoveryOpen = authors.length > 0;
+  let discoveryTimer;
+  function attachMany(relayUrls2) {
+    for (const relayUrl of relayUrls2) attachLiveRelay(ctx, sub, filters, relayUrl, sink);
+  }
+  function closeUnavailable() {
+    if (sub.closed || sub.handles.size > 0) return;
+    sub.closed = true;
+    sink.closed("relay list unavailable");
+  }
+  if (!ctx.relayPool.isAvailable()) {
+    closeUnavailable();
+  } else if (authors.length === 0) {
+    discoveryOpen = false;
+    attachMany(immediateReadRelays(ctx, options?.relays));
+    closeUnavailable();
+  } else {
+    let loaded;
+    try {
+      loaded = ctx.loadRelayLists(authors);
+    } catch {
+      discoveryOpen = false;
+      attachMany(immediateReadRelays(ctx, options?.relays));
+      closeUnavailable();
+      loaded = /* @__PURE__ */ new Map();
     }
-    for (const relayUrl of plan.relays) attachLiveRelay(ctx, sub, filters, relayUrl, sink);
-  }).catch((err2) => {
-    if (!sub.closed) sink.closed(err2 instanceof Error ? err2.message : "subscribe failed");
-  });
+    if (discoveryOpen && loaded instanceof Map) {
+      const discovery = discoveredReadRelays(ctx, authors, loaded);
+      discoveryOpen = false;
+      const initial = allowed(ctx, [...options?.relays ?? [], ...discovery.relays]);
+      attachMany(initial.length > 0 ? initial : allowed(ctx, ctx.fallbackRelays));
+      closeUnavailable();
+    } else if (discoveryOpen) {
+      attachMany(immediateReadRelays(ctx, options?.relays));
+      discoveryTimer = setTimeout(() => {
+        discoveryOpen = false;
+        closeUnavailable();
+      }, options?.timeoutMs ?? ctx.defaultTimeoutMs);
+      void Promise.resolve(loaded).then((lists) => {
+        if (!discoveryOpen || sub.closed) return;
+        discoveryOpen = false;
+        clearTimeout(discoveryTimer);
+        attachMany(discoveredReadRelays(ctx, authors, lists).relays);
+        closeUnavailable();
+      }).catch(() => {
+        if (!discoveryOpen || sub.closed) return;
+        discoveryOpen = false;
+        clearTimeout(discoveryTimer);
+        closeUnavailable();
+      });
+    }
+  }
   return {
     close() {
       if (sub.closed) return;
       sub.closed = true;
+      discoveryOpen = false;
+      clearTimeout(discoveryTimer);
       closeLiveSub(sub);
     }
   };
 }
 async function resolvePublishTargets(ctx, signed, options) {
   const targets = /* @__PURE__ */ new Set();
-  const authorPlan = await resolvePlan(ctx, [signed.pubkey], "read");
-  for (const url of authorPlan.relays) targets.add(url);
-  if (options?.targetAuthors && options.targetAuthors.length > 0) {
-    const inboxPlan = await resolvePlan(ctx, options.targetAuthors, "write");
-    for (const url of inboxPlan.relays) targets.add(url);
+  const requiredTargets = /* @__PURE__ */ new Set();
+  if (options?.toOutbox !== false) {
+    const outboxPlan = await resolveRequiredRelays(ctx, [signed.pubkey], "read");
+    if (outboxPlan.missingAuthors.length > 0) return { relayUrls: [], requiredRelayUrls: [], error: "relay list unavailable" };
+    if (outboxPlan.deniedAuthors.length > 0) return { relayUrls: [], requiredRelayUrls: [], error: "policy denied" };
+    for (const url of outboxPlan.relays) {
+      targets.add(url);
+      requiredTargets.add(url);
+    }
+  }
+  if (options?.toInboxes && options.toInboxes.length > 0) {
+    const inboxPlan = await resolveRequiredRelays(ctx, options.toInboxes, "write");
+    if (inboxPlan.missingAuthors.length > 0) return { relayUrls: [], requiredRelayUrls: [], error: "relay list unavailable" };
+    if (inboxPlan.deniedAuthors.length > 0) return { relayUrls: [], requiredRelayUrls: [], error: "policy denied" };
+    for (const url of inboxPlan.relays) {
+      targets.add(url);
+      requiredTargets.add(url);
+    }
   }
   for (const url of options?.relays ?? []) targets.add(url);
-  return allowed(ctx, targets);
+  return {
+    relayUrls: allowed(ctx, targets),
+    requiredRelayUrls: allowed(ctx, requiredTargets)
+  };
 }
 async function publishImpl(ctx, template, options) {
   if (!ctx.signEvent) return { ok: false, error: "publish denied" };
@@ -2491,7 +2800,11 @@ async function publishImpl(ctx, template, options) {
   } catch (err2) {
     return { ok: false, error: err2 instanceof Error ? err2.message : "sign failed" };
   }
-  const relayUrls2 = await resolvePublishTargets(ctx, signed, options);
+  const publishTargets = await resolvePublishTargets(ctx, signed, options);
+  if (publishTargets.error) {
+    return { ok: false, event: signed, eventId: signed.id, error: publishTargets.error };
+  }
+  const relayUrls2 = publishTargets.relayUrls;
   if (relayUrls2.length === 0) return { ok: false, event: signed, eventId: signed.id, error: "relay list unavailable" };
   let relays;
   try {
@@ -2499,7 +2812,7 @@ async function publishImpl(ctx, template, options) {
   } catch (err2) {
     return { ok: false, event: signed, eventId: signed.id, error: err2 instanceof Error ? err2.message : "publish failed" };
   }
-  const ok = Object.values(relays).some(Boolean);
+  const ok = publishTargets.requiredRelayUrls.length > 0 ? publishTargets.requiredRelayUrls.every((url) => relays[url] === true) : Object.values(relays).some(Boolean);
   const result2 = { ok, event: signed, eventId: signed.id, relays };
   if (!ok) result2.error = "publish denied";
   return result2;
@@ -2534,6 +2847,7 @@ function createRelayPoolOutboxRouter(options) {
   return {
     getEvent: (eventId, eventOptions) => getEventImpl(ctx, eventId, eventOptions),
     query: (filters, queryOptions) => queryImpl(ctx, filters, queryOptions),
+    queryStream: (filters, queryOptions, sink) => startQueryImpl(ctx, filters, queryOptions, sink),
     subscribe: (filters, subscribeOptions, sink) => startSubscription(ctx, filters, subscribeOptions, sink),
     publish: (template, publishOptions) => publishImpl(ctx, template, publishOptions),
     resolveRelays: (target) => {
@@ -2695,6 +3009,7 @@ function createHttpUploader(options) {
   const digest = options.digestSha256 ?? defaultDigestSha256;
   const nowS = options.now ?? (() => Math.floor(Date.now() / 1e3));
   const defaultRail = options.defaultRail ?? firstConfiguredRail(rails);
+  const inFlight = /* @__PURE__ */ new Map();
   async function upload(request, ctx) {
     const rail = request.rail ?? defaultRail;
     const config = rail === "nip96" ? rails.nip96 : rail === "blossom" ? rails.blossom : void 0;
@@ -2705,18 +3020,32 @@ function createHttpUploader(options) {
     if (!server) {
       return failed(ctx.uploadId, rail, "no server configured");
     }
-    const bytes = await toBytes(request.data);
-    const sha256 = await digest(bytes);
+    const controller = new AbortController();
+    inFlight.set(ctx.uploadId, controller);
+    let sha256;
     try {
-      return rail === "nip96" ? await uploadNip96({ request, ctx, server, bytes, sha256, signEvent, fetchFn, nowS }) : await uploadBlossom({ request, ctx, server, bytes, sha256, signEvent, fetchFn, nowS });
+      const bytes = await toBytes(request.data);
+      sha256 = await digest(bytes);
+      if (controller.signal.aborted) {
+        return cancelled(ctx.uploadId, rail, sha256);
+      }
+      return rail === "nip96" ? await uploadNip96({ request, ctx, server, bytes, sha256, signEvent, fetchFn, nowS, controller }) : await uploadBlossom({ request, ctx, server, bytes, sha256, signEvent, fetchFn, nowS, controller });
     } catch (err2) {
+      if (controller.signal.aborted) {
+        return cancelled(ctx.uploadId, rail, sha256);
+      }
       return failed(ctx.uploadId, rail, toErrorMessage3(err2), sha256);
+    } finally {
+      inFlight.delete(ctx.uploadId);
     }
   }
-  return { upload };
+  function cancel(uploadId) {
+    inFlight.get(uploadId)?.abort();
+  }
+  return { upload, cancel };
 }
 async function uploadNip96(args) {
-  const { request, ctx, server, bytes, sha256, signEvent, fetchFn, nowS } = args;
+  const { request, ctx, server, bytes, sha256, signEvent, fetchFn, nowS, controller } = args;
   const auth = await signEvent({
     kind: KIND_NIP98,
     created_at: nowS(),
@@ -2732,10 +3061,12 @@ async function uploadNip96(args) {
   if (request.caption !== void 0) form.append("caption", request.caption);
   if (request.mimeType !== void 0) form.append("content_type", request.mimeType);
   if (request.noTransform) form.append("no_transform", "true");
+  emitUploading(ctx, "nip96", bytes.byteLength, nowS);
   const res = await fetchFn(server, {
     method: "POST",
     headers: { Authorization: nostrAuthHeader(auth) },
-    body: form
+    body: form,
+    signal: controller.signal
   });
   if (!res.ok) {
     return failed(ctx.uploadId, "nip96", `server rejected (HTTP ${res.status})`, sha256);
@@ -2773,7 +3104,7 @@ function fromNip94Tags(uploadId, rail, tags, fallbackSize, fallbackSha) {
   return result2;
 }
 async function uploadBlossom(args) {
-  const { request, ctx, server, bytes, sha256, signEvent, fetchFn, nowS } = args;
+  const { request, ctx, server, bytes, sha256, signEvent, fetchFn, nowS, controller } = args;
   const auth = await signEvent({
     kind: KIND_BLOSSOM_AUTH,
     created_at: nowS(),
@@ -2787,33 +3118,65 @@ async function uploadBlossom(args) {
   const endpoint = `${trimTrailingSlash(server)}/upload`;
   const headers = { Authorization: nostrAuthHeader(auth) };
   if (request.mimeType) headers["Content-Type"] = request.mimeType;
+  emitUploading(ctx, "blossom", bytes.byteLength, nowS);
   const res = await fetchFn(endpoint, {
     method: "PUT",
     headers,
-    body: bytesToArrayBuffer(bytes)
+    body: bytesToArrayBuffer(bytes),
+    signal: controller.signal
   });
   if (!res.ok) {
     return failed(ctx.uploadId, "blossom", `server rejected (HTTP ${res.status})`, sha256);
   }
   const blob = await res.json();
-  if (!blob.url) {
+  if (typeof blob.url !== "string" || blob.url.length === 0) {
     return failed(ctx.uploadId, "blossom", "server returned no url", sha256);
   }
+  if (typeof blob.sha256 !== "string" || blob.sha256.length === 0) {
+    return failed(ctx.uploadId, "blossom", "server returned no sha256", sha256);
+  }
+  if (blob.sha256 !== sha256) {
+    return failed(ctx.uploadId, "blossom", "server returned mismatched sha256", sha256);
+  }
+  if (!Number.isSafeInteger(blob.size) || (blob.size ?? -1) < 0) {
+    return failed(ctx.uploadId, "blossom", "server returned invalid size", sha256);
+  }
+  if (blob.size !== bytes.byteLength) {
+    return failed(ctx.uploadId, "blossom", "server returned mismatched size", sha256);
+  }
+  const mimeType = blob.type ?? request.mimeType;
+  const nip94 = [["url", blob.url]];
+  if (mimeType) nip94.push(["m", mimeType]);
+  nip94.push(["x", sha256], ["size", String(bytes.byteLength)]);
   const result2 = {
     ok: true,
     uploadId: ctx.uploadId,
     status: "complete",
     rail: "blossom",
     url: blob.url,
-    sha256: blob.sha256 ?? sha256,
-    size: blob.size ?? bytes.byteLength
+    sha256,
+    size: bytes.byteLength,
+    nip94
   };
-  if (blob.type) result2.mimeType = blob.type;
+  if (mimeType) result2.mimeType = mimeType;
   return result2;
 }
 function failed(uploadId, rail, error, sha256) {
   return { ok: false, uploadId, status: "failed", rail, error, ...sha256 ? { sha256 } : {} };
 }
+function cancelled(uploadId, rail, sha256) {
+  return { ok: false, uploadId, status: "cancelled", rail, error: "user cancelled", ...sha256 ? { sha256 } : {} };
+}
+function emitUploading(ctx, rail, bytesTotal, nowS) {
+  ctx.onStatus({
+    ok: true,
+    uploadId: ctx.uploadId,
+    status: "uploading",
+    rail,
+    bytesTotal,
+    updatedAt: nowS() * 1e3
+  });
+}
 function firstConfiguredRail(rails) {
   if (rails.nip96?.servers?.length) return "nip96";
   if (rails.blossom?.servers?.length) return "blossom";