@kehto/paja 0.16.3 → 0.16.5

package/dist/browser-host.js

@@ -702,7 +702,7 @@ function createNapEnforceGate(config) {
 function formatDenialReason(capability) {
   return `denied: ${capability}`;
 }
-function createSessionRegistry(notifier) {
+function createSessionRegistry(notifier, onRegister) {
   const byWindowId2 = /* @__PURE__ */ new Map();
   const byPubkey2 = /* @__PURE__ */ new Map();
   const byWindowIdEntry = /* @__PURE__ */ new Map();
@@ -712,6 +712,7 @@ function createSessionRegistry(notifier) {
       byWindowId2.set(windowId, entry.pubkey);
       byPubkey2.set(entry.pubkey, entry);
       byWindowIdEntry.set(windowId, entry);
+      onRegister?.(windowId);
     },
     unregister(windowId) {
       const pubkey2 = byWindowId2.get(windowId);
@@ -931,6 +932,12 @@ function createFirewallState(persistence) {
       counters = result2.newState;
       return result2;
     },
+    resetInitBudget(initKey) {
+      if (!Object.hasOwn(counters.bursts, initKey)) return;
+      const bursts = { ...counters.bursts };
+      delete bursts[initKey];
+      counters = { ...counters, bursts };
+    },
     setPolicy(napplet, policy) {
       config = setPolicy(config, napplet, policy);
     },
@@ -2416,8 +2423,8 @@ function buildObservation(envelope, windowId, senderCap, sessionRegistry2, getFo
     size,
     initElapsedMs,
     // `windowId` comes from the host's source-bound session lookup, never the
-    // napplet message envelope. It scopes startup burst accounting to this
-    // registered realm while rate limits remain dTag-wide.
+    // napplet message envelope. Trusted register() calls retire this key's
+    // previous startup budget; ordinary messages cannot reset it.
     initKey: windowId,
     focused: focus.focused,
     msSinceFocusGain: focus.msSinceFocusGain,
@@ -2664,7 +2671,10 @@ function createRuntime(hooks) {
   const subscriptions = /* @__PURE__ */ new Map();
   const serviceRegistry = { ...hooks.services };
   const registeredServices = createRegisteredServices(serviceRegistry);
-  const sessionRegistry2 = createSessionRegistry(hooks.onPendingUpdate);
+  const firewallState = createFirewallState(hooks.firewallPersistence);
+  const sessionRegistry2 = createSessionRegistry(hooks.onPendingUpdate, (windowId) => {
+    firewallState.resetInitBudget(windowId);
+  });
   let incRuntime = null;
   const aclState = createAclState(hooks.aclPersistence, "permissive", (mutation) => {
     if (mutation.type === "revoke" && mutation.capability !== "relay:read") return;
@@ -2674,7 +2684,6 @@ function createRuntime(hooks) {
       }
     }
   });
-  const firewallState = createFirewallState(hooks.firewallPersistence);
   const manifestCache2 = createManifestCache(hooks.manifestPersistence);
   const replayDetector = createReplayDetector(
     hooks.getConfigOverrides ? () => hooks.getConfigOverrides().replayWindowSeconds : void 0
@@ -4033,16 +4042,29 @@ function nappletNamespacePrelude(domains) {
   function request(message, resultType, map, options = {}) {
     const requestId = message.id ?? id();
     const outbound = { ...message, id: requestId };
+    const timeoutMs = options.timeoutMs === void 0 ? requestTimeoutMs : options.timeoutMs;
+    if (options.signal?.aborted) return Promise.reject(new DOMException("Aborted", "AbortError"));
     return new Promise((resolve, reject2) => {
-      const off = listen((event) => {
+      let timer;
+      let off;
+      const cleanup = () => {
+        off?.();
+        if (timer !== void 0) clearTimeout(timer);
+        options.signal?.removeEventListener("abort", abort);
+      };
+      const abort = () => {
+        cleanup();
+        if (options.cancelOnAbort) post({ type: "resource.cancel", id: requestId });
+        reject2(new DOMException("Aborted", "AbortError"));
+      };
+      off = listen((event) => {
         if (!isParentMessage(event)) return;
         const incoming = event.data;
         if (typeof incoming !== "object" || incoming === null) return;
         const msg = incoming;
         if (msg.type !== resultType && msg.type !== `${message.type}.error`) return;
         if (msg.id !== requestId) return;
-        off();
-        clearTimeout(timer);
+        cleanup();
         const error = typeof msg.error === "string" ? msg.error : "";
         if (error && options.rejectOnError !== false) {
           reject2(new Error(error));
@@ -4054,10 +4076,13 @@ function nappletNamespacePrelude(domains) {
           reject2(err2);
         }
       });
-      const timer = setTimeout(() => {
-        off();
-        reject2(new Error(`${message.type} timed out`));
-      }, requestTimeoutMs);
+      if (timeoutMs !== null) {
+        timer = setTimeout(() => {
+          cleanup();
+          reject2(new Error(`${message.type} timed out`));
+        }, timeoutMs);
+      }
+      options.signal?.addEventListener("abort", abort, { once: true });
       post(outbound);
     });
   }
@@ -4806,17 +4831,25 @@ function nappletNamespacePrelude(domains) {
       type: "resource.bytes",
       url,
       ...Array.isArray(options?.servers) ? { servers: Array.from(options.servers) } : {}
-    }, "resource.bytes.result", (msg) => msg.blob);
+    }, "resource.bytes.result", (msg) => msg.blob, {
+      timeoutMs: null,
+      signal: options?.signal,
+      cancelOnAbort: true
+    });
     return {
       info: () => request({ type: "resource.info" }, "resource.info.result", (msg) => msg.info),
       bytes,
-      bytesMany: (requests) => request({
+      bytesMany: (requests, options) => request({
         type: "resource.bytesMany",
         requests: Array.from(requests || [], (entry) => ({
           url: entry.url,
           ...Array.isArray(entry.servers) ? { servers: Array.from(entry.servers) } : {}
         }))
-      }, "resource.bytesMany.result", (msg) => Array.isArray(msg.items) ? msg.items : []),
+      }, "resource.bytesMany.result", (msg) => Array.isArray(msg.items) ? msg.items : [], {
+        timeoutMs: null,
+        signal: options?.signal,
+        cancelOnAbort: true
+      }),
       bytesAsObjectURL(url) {
         let objectUrl = "";
         const handle = {
@@ -9572,6 +9605,9 @@ function isValidFilterArray2(value) {
 function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function actionRegistryKey(windowId, actionId) {
+  return JSON.stringify([windowId, actionId]);
+}
 var MODIFIER_ALIASES = {
   ctrl: "ctrl",
   control: "ctrl",
@@ -9640,7 +9676,7 @@ function bindingsForWindow(windowId, registry2, windowIndex) {
   if (!actionIds) return [];
   const bindings = [];
   for (const actionId of actionIds) {
-    const entry = registry2.get(actionId);
+    const entry = registry2.get(actionRegistryKey(windowId, actionId));
     if (!entry || entry.windowId !== windowId) continue;
     bindings.push({ actionId, key: entry.chordString });
   }
@@ -9653,10 +9689,9 @@ function pushBindings(windowId, registry2, windowIndex, send) {
   };
   send(payload);
 }
-function removeActionFromWindowIndex(actionId, windowIndex) {
-  for (const [wid, set] of windowIndex.entries()) {
-    if (set.delete(actionId) && set.size === 0) windowIndex.delete(wid);
-  }
+function removeActionFromWindowIndex(windowId, actionId, windowIndex) {
+  const actions = windowIndex.get(windowId);
+  if (actions?.delete(actionId) && actions.size === 0) windowIndex.delete(windowId);
 }
 var KEYS_SERVICE_VERSION = "1.3.0";
 function rememberActionForWindow(windowIndex, windowId, actionId) {
@@ -9664,7 +9699,7 @@ function rememberActionForWindow(windowIndex, windowId, actionId) {
   windowIndex.get(windowId).add(actionId);
 }
 function bindActionEntry(registry2, windowIndex, actionId, windowId, chord, chordString) {
-  registry2.set(actionId, { chord, chordString, windowId });
+  registry2.set(actionRegistryKey(windowId, actionId), { actionId, chord, chordString, windowId });
   rememberActionForWindow(windowIndex, windowId, actionId);
 }
 function bindActionAndMarkChanged(registry2, windowIndex, changedWindowIds, actionId, windowId, chord, chordString) {
@@ -9737,6 +9772,7 @@ function createKeysService(options = {}) {
     const bridgeSendHandles = /* @__PURE__ */ new Map();
     const unsubscribeHandles = /* @__PURE__ */ new Map();
     const handleBridgeRegisterAction = (windowId, m, send) => {
+      const registryKey = actionRegistryKey(windowId, m.action.id);
       bridgeSendHandles.set(windowId, send);
       let binding;
       const changedWindowIds = /* @__PURE__ */ new Set();
@@ -9744,8 +9780,8 @@ function createKeysService(options = {}) {
         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);
+          const existingEntry = bridgeActionRegistry.get(registryKey);
+          const existing = unsubscribeHandles.get(registryKey);
           let nextUnsubscribe;
           if (!isUnavailableBinding(chord)) {
             nextUnsubscribe = bridge.subscribe(normalizedChord, (ev) => {
@@ -9771,13 +9807,13 @@ function createKeysService(options = {}) {
               existing();
             } catch {
             }
-            unsubscribeHandles.delete(m.action.id);
+            unsubscribeHandles.delete(registryKey);
           }
           if (existingEntry) changedWindowIds.add(existingEntry.windowId);
-          removeActionFromWindowIndex(m.action.id, bridgeWindowActions);
-          bridgeActionRegistry.delete(m.action.id);
+          removeActionFromWindowIndex(windowId, m.action.id, bridgeWindowActions);
+          bridgeActionRegistry.delete(registryKey);
           if (nextUnsubscribe) {
-            unsubscribeHandles.set(m.action.id, nextUnsubscribe);
+            unsubscribeHandles.set(registryKey, nextUnsubscribe);
             binding = bindActionAndMarkChanged(
               bridgeActionRegistry,
               bridgeWindowActions,
@@ -9807,18 +9843,19 @@ function createKeysService(options = {}) {
         send
       );
     };
-    const handleBridgeUnregisterAction = (_windowId, m, send) => {
+    const handleBridgeUnregisterAction = (windowId, m, send) => {
       if (!m.actionId) return;
-      const unsubscribe = unsubscribeHandles.get(m.actionId);
-      const entry = bridgeActionRegistry.get(m.actionId);
+      const registryKey = actionRegistryKey(windowId, m.actionId);
+      const unsubscribe = unsubscribeHandles.get(registryKey);
+      const entry = bridgeActionRegistry.get(registryKey);
       if (!unsubscribe) return;
       try {
         unsubscribe();
       } catch {
       }
-      unsubscribeHandles.delete(m.actionId);
-      bridgeActionRegistry.delete(m.actionId);
-      removeActionFromWindowIndex(m.actionId, bridgeWindowActions);
+      unsubscribeHandles.delete(registryKey);
+      bridgeActionRegistry.delete(registryKey);
+      removeActionFromWindowIndex(windowId, m.actionId, bridgeWindowActions);
       if (entry) {
         const ownerSend = bridgeSendHandles.get(entry.windowId) ?? send;
         pushBindings(entry.windowId, bridgeActionRegistry, bridgeWindowActions, ownerSend);
@@ -9838,15 +9875,16 @@ function createKeysService(options = {}) {
         const actions = bridgeWindowActions.get(windowId);
         if (!actions) return;
         for (const actionId of actions) {
-          const unsubscribe = unsubscribeHandles.get(actionId);
+          const registryKey = actionRegistryKey(windowId, actionId);
+          const unsubscribe = unsubscribeHandles.get(registryKey);
           if (unsubscribe) {
             try {
               unsubscribe();
             } catch {
             }
           }
-          unsubscribeHandles.delete(actionId);
-          bridgeActionRegistry.delete(actionId);
+          unsubscribeHandles.delete(registryKey);
+          bridgeActionRegistry.delete(registryKey);
         }
         bridgeWindowActions.delete(windowId);
         bridgeSendHandles.delete(windowId);
@@ -9899,13 +9937,13 @@ function createKeysService(options = {}) {
       });
     }
     if (isReserved) return;
-    for (const [actionId, entry] of actionRegistry.entries()) {
+    for (const entry of actionRegistry.values()) {
       if (chordMatches(entry.chord, ev)) {
         const send = sendHandles.get(entry.windowId);
         if (send) {
           const payload = {
             type: "keys.action",
-            actionId
+            actionId: entry.actionId
           };
           send(payload);
         }
@@ -9914,6 +9952,7 @@ function createKeysService(options = {}) {
   };
   target.addEventListener("keydown", listener);
   const handleDocumentRegisterAction = (windowId, m, send) => {
+    const registryKey = actionRegistryKey(windowId, m.action.id);
     sendHandles.set(windowId, send);
     let binding;
     const changedWindowIds = /* @__PURE__ */ new Set();
@@ -9921,11 +9960,11 @@ function createKeysService(options = {}) {
       try {
         const chord = parseChord(m.action.defaultKey);
         const normalizedChord = formatChord(chord);
-        const existing = actionRegistry.get(m.action.id);
+        const existing = actionRegistry.get(registryKey);
         if (existing) {
           changedWindowIds.add(existing.windowId);
-          removeActionFromWindowIndex(m.action.id, windowActions);
-          actionRegistry.delete(m.action.id);
+          removeActionFromWindowIndex(windowId, m.action.id, windowActions);
+          actionRegistry.delete(registryKey);
         }
         if (!isUnavailableBinding(chord)) {
           binding = bindActionAndMarkChanged(actionRegistry, windowActions, changedWindowIds, m.action.id, windowId, chord, normalizedChord);
@@ -9943,10 +9982,12 @@ function createKeysService(options = {}) {
     sendRegisterActionResult2(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 handleDocumentUnregisterAction = (windowId, m, send) => {
+    if (!m.actionId) return;
+    const registryKey = actionRegistryKey(windowId, m.actionId);
+    const entry = actionRegistry.get(registryKey);
+    if (!entry) return;
+    actionRegistry.delete(registryKey);
     const set = windowActions.get(entry.windowId);
     if (set) {
       set.delete(m.actionId);
@@ -9966,7 +10007,7 @@ function createKeysService(options = {}) {
     onWindowDestroyed(windowId) {
       const actions = windowActions.get(windowId);
       if (actions) {
-        for (const actionId of actions) actionRegistry.delete(actionId);
+        for (const actionId of actions) actionRegistry.delete(actionRegistryKey(windowId, actionId));
         windowActions.delete(windowId);
       }
       sendHandles.delete(windowId);
@@ -15214,15 +15255,35 @@ var KIND_GIFT_WRAP_EPHEMERAL = 21059;
 var KIND_GIFT_WRAP_REGULAR = 1059;
 var KIND_ANNOUNCE_SERVER = 11316;
 var KIND_ANNOUNCE_TOOLS = 11317;
+var SUPPORT_ENCRYPTION = "support_encryption";
+var SUPPORT_ENCRYPTION_EPHEMERAL = "support_encryption_ephemeral";
+var SUPPORT_OVERSIZED_TRANSFER = "support_oversized_transfer";
+var SUPPORT_OPEN_STREAM = "support_open_stream";
 var DEFAULT_TIMEOUT_MS = 3e4;
 var DEFAULT_DISCOVER_TIMEOUT_MS = 6e3;
 var MCP_PROTOCOL_VERSION = "2025-11-25";
 var SEEN_WRAP_LIMIT = 512;
+var DIGEST_PREFIX = "sha256:";
+var MAX_TRANSFER_CHUNKS = 1e4;
+var MAX_TRANSFER_BYTES = 100 * 1024 * 1024;
+var MAX_ACTIVE_TRANSFERS = 8;
+var MAX_TRANSFER_LIFETIME_MS = 12e4;
+var COMPLETION_MODE_RENDER = "render";
+var DEFAULT_STREAM_IDLE_TIMEOUT_MS = 3e4;
+var DEFAULT_STREAM_PROBE_TIMEOUT_MS = 1e4;
+var MAX_STREAM_BUFFERED_CHUNKS = 256;
+var MAX_STREAM_BUFFERED_CODE_UNITS = 8 * 1024 * 1024;
+var MAX_PING_NONCE_BYTES = 64;
 var correlationCounter = 0;
 function nextCorrelationId() {
   correlationCounter += 1;
   return `cvm-${correlationCounter}-${getPublicKey(generateSecretKey()).slice(0, 8)}`;
 }
+var streamNonceCounter = 0;
+function nextStreamNonce() {
+  streamNonceCounter += 1;
+  return `cvm-ping-${streamNonceCounter}-${getPublicKey(generateSecretKey()).slice(0, 8)}`;
+}
 function randomizedPastTimestamp() {
   const jitter = Math.floor(Math.random() * 172800);
   return Math.floor(Date.now() / 1e3) - jitter;
@@ -15230,6 +15291,19 @@ function randomizedPastTimestamp() {
 function tagValue(tags, name) {
   return tags.find((tag) => tag[0] === name)?.[1];
 }
+function progressTokenKey(token) {
+  if (typeof token === "string") return token.length > 0 ? `s:${token}` : null;
+  if (typeof token === "number" && Number.isFinite(token)) return `n:${token}`;
+  return null;
+}
+function isBoundedInteger(value, min, max) {
+  return typeof value === "number" && Number.isInteger(value) && value >= min && value <= max;
+}
+async function sha256Hex(text) {
+  const bytes = new TextEncoder().encode(text);
+  const buf = await crypto.subtle.digest("SHA-256", bytes);
+  return [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
 function simplePoolAdapter(sp) {
   return {
     subscribe(relays, filter, params) {
@@ -15254,11 +15328,14 @@ function createNostrCvmTransport(options = {}) {
   const clientSecretKey = options.clientSecretKey ?? generateSecretKey();
   const clientPubkey = getPublicKey(clientSecretKey);
   const clientInfo = options.clientInfo ?? { name: "kehto-cvm", version: "1.0.0" };
+  const streamIdleTimeoutMs = options.streamIdleTimeoutMs ?? DEFAULT_STREAM_IDLE_TIMEOUT_MS;
+  const streamProbeTimeoutMs = options.streamProbeTimeoutMs ?? DEFAULT_STREAM_PROBE_TIMEOUT_MS;
   const sessions = /* @__PURE__ */ new Map();
   const pending = /* @__PURE__ */ new Map();
   const eventHandlers = /* @__PURE__ */ new Set();
   const relayRefcount = /* @__PURE__ */ new Map();
   const seenWraps = /* @__PURE__ */ new Set();
+  const issuedTokens = /* @__PURE__ */ new Map();
   let inbound = null;
   let subscribedRelays = "";
   function resolveRelays(server) {
@@ -15320,23 +15397,379 @@ function createNostrCvmTransport(options = {}) {
     } catch {
       return;
     }
+    if (mcp.method === "notifications/progress") {
+      const params = mcp.params ?? {};
+      const cvm = params.cvm;
+      if (cvm && typeof cvm.type === "string") {
+        if (cvm.type === "oversized-transfer") {
+          void handleOversizedFrame(serverPubkey, params, cvm);
+          return;
+        }
+        if (cvm.type === "open-stream") {
+          const entry = admitFrame(serverPubkey, params.progressToken);
+          if (!entry) return;
+          handleOpenStreamFrame(serverPubkey, entry, params, cvm, mcp);
+          return;
+        }
+      }
+    }
+    routeMessage(serverPubkey, mcp);
+  }
+  async function publishStreamFrame(entry, stream, frame) {
+    const session = sessions.get(entry.serverPubkey);
+    if (!session) return;
+    stream.localProgress += 1;
+    await publishMcp(
+      { pubkey: entry.serverPubkey },
+      session.relays,
+      {
+        jsonrpc: "2.0",
+        method: "notifications/progress",
+        params: {
+          progressToken: stream.token,
+          progress: stream.localProgress,
+          cvm: { type: "open-stream", ...frame }
+        }
+      }
+    );
+  }
+  function admitFrame(serverPubkey, token) {
+    const tokenKey = progressTokenKey(token);
+    if (!tokenKey) return null;
+    const correlationId = issuedTokens.get(`${serverPubkey}:${tokenKey}`);
+    if (!correlationId) return null;
+    const entry = pending.get(correlationId);
+    if (!entry || entry.serverPubkey !== serverPubkey) return null;
+    return entry;
+  }
+  function releaseTransfer(entry) {
+    if (!entry.oversized) return;
+    clearTimeout(entry.oversized.expiryTimer);
+    entry.oversized = void 0;
+  }
+  function releaseStream(entry) {
+    if (!entry.stream) return;
+    clearTimeout(entry.stream.idleTimer);
+    if (entry.stream.probeTimer) clearTimeout(entry.stream.probeTimer);
+    entry.stream = void 0;
+  }
+  function endStream(entry) {
+    releaseStream(entry);
+    entry.streamEnded = true;
+  }
+  function failStream(entry, reason) {
+    const stream = entry.stream;
+    if (!stream || entry.streamEnded) return;
+    endStream(entry);
+    void publishStreamFrame(entry, stream, { frameType: "abort", reason }).catch(() => {
+    });
+  }
+  function resetStreamIdleTimer(entry, stream) {
+    clearTimeout(stream.idleTimer);
+    stream.idleTimer = setTimeout(() => onStreamIdle(entry), streamIdleTimeoutMs);
+  }
+  function onStreamIdle(entry) {
+    const stream = entry.stream;
+    if (!stream || entry.streamEnded) return;
+    if (stream.pendingNonce !== null) return;
+    const session = sessions.get(entry.serverPubkey);
+    if (!session) {
+      failStream(entry, "session closed");
+      return;
+    }
+    stream.pendingNonce = nextStreamNonce();
+    stream.probeTimer = setTimeout(() => failStream(entry, "probe timeout"), streamProbeTimeoutMs);
+    void publishStreamFrame(entry, stream, { frameType: "ping", nonce: stream.pendingNonce }).catch(() => failStream(entry, "ping publication failed"));
+  }
+  function releaseFrameState(entry) {
+    releaseTransfer(entry);
+    releaseStream(entry);
+    if (entry.tokenKey && issuedTokens.get(entry.tokenKey) === entry.correlationId) {
+      issuedTokens.delete(entry.tokenKey);
+    }
+    entry.tokenKey = void 0;
+  }
+  function settlePending(correlationId) {
+    const entry = pending.get(correlationId);
+    if (!entry) return null;
+    clearTimeout(entry.timer);
+    pending.delete(correlationId);
+    releaseFrameState(entry);
+    return entry;
+  }
+  function countActiveTransfers() {
+    let active = 0;
+    for (const entry of pending.values()) {
+      if (entry.oversized) active += 1;
+    }
+    return active;
+  }
+  async function handleOversizedFrame(serverPubkey, params, cvm) {
+    const entry = admitFrame(serverPubkey, params.progressToken);
+    if (!entry) return;
+    const progress = Number(params.progress ?? NaN);
+    if (!Number.isSafeInteger(progress) || progress < 0) return;
+    if (cvm.frameType === "start") {
+      const digest = typeof cvm.digest === "string" ? cvm.digest : "";
+      const { totalBytes, totalChunks } = cvm;
+      if (cvm.completionMode !== COMPLETION_MODE_RENDER) return;
+      if (digest === "") return;
+      if (!isBoundedInteger(totalChunks, 1, MAX_TRANSFER_CHUNKS)) return;
+      if (!isBoundedInteger(totalBytes, 1, MAX_TRANSFER_BYTES)) return;
+      if (progress > Number.MAX_SAFE_INTEGER - totalChunks - 1) return;
+      if (!entry.oversized && countActiveTransfers() >= MAX_ACTIVE_TRANSFERS) return;
+      releaseTransfer(entry);
+      entry.oversized = {
+        digest,
+        totalBytes,
+        totalChunks,
+        startProgress: progress,
+        acceptProgress: null,
+        chunks: /* @__PURE__ */ new Map(),
+        codeUnitsReceived: 0,
+        // Hard expiry: progress frames extend the request deadline but never
+        // how long buffers may be held.
+        expiryTimer: setTimeout(() => releaseTransfer(entry), MAX_TRANSFER_LIFETIME_MS)
+      };
+      refreshPendingTimeout(entry);
+      return;
+    }
+    const transfer = entry.oversized;
+    if (!transfer) return;
+    if (cvm.frameType === "accept") {
+      if (progress !== transfer.startProgress + 1) {
+        releaseTransfer(entry);
+        return;
+      }
+      transfer.acceptProgress = progress;
+      refreshPendingTimeout(entry);
+      return;
+    }
+    if (cvm.frameType === "chunk") {
+      if (typeof cvm.data !== "string" || progress <= transfer.startProgress) return;
+      if (transfer.chunks.has(progress)) return;
+      if (transfer.chunks.size >= transfer.totalChunks) {
+        releaseTransfer(entry);
+        return;
+      }
+      transfer.codeUnitsReceived += cvm.data.length;
+      if (transfer.codeUnitsReceived > MAX_TRANSFER_BYTES) {
+        releaseTransfer(entry);
+        return;
+      }
+      transfer.chunks.set(progress, cvm.data);
+      refreshPendingTimeout(entry);
+      return;
+    }
+    if (cvm.frameType === "abort") {
+      releaseTransfer(entry);
+      return;
+    }
+    if (cvm.frameType === "end") {
+      const message = await assembleTransfer(transfer, progress);
+      releaseTransfer(entry);
+      if (message) routeMessage(serverPubkey, message);
+      return;
+    }
+  }
+  async function assembleTransfer(transfer, endProgress) {
+    const { startProgress, acceptProgress, totalChunks } = transfer;
+    const hasCompleteRange = (first) => {
+      for (let i4 = 0; i4 < totalChunks; i4++) {
+        if (!transfer.chunks.has(first + i4)) return false;
+      }
+      return true;
+    };
+    const directStart = startProgress + 1;
+    const acceptGatedStart = startProgress + 2;
+    const firstProgress = hasCompleteRange(directStart) && endProgress === directStart + totalChunks ? directStart : acceptProgress === startProgress + 1 && hasCompleteRange(acceptGatedStart) && endProgress === acceptGatedStart + totalChunks ? acceptGatedStart : null;
+    if (firstProgress === null) return null;
+    let payload = "";
+    for (let i4 = 0; i4 < totalChunks; i4++) {
+      payload += transfer.chunks.get(firstProgress + i4);
+    }
+    if (new TextEncoder().encode(payload).byteLength !== transfer.totalBytes) return null;
+    const expected = transfer.digest.startsWith(DIGEST_PREFIX) ? transfer.digest.slice(DIGEST_PREFIX.length) : transfer.digest;
+    if (await sha256Hex(payload) !== expected) return null;
+    try {
+      return JSON.parse(payload);
+    } catch {
+      return null;
+    }
+  }
+  function handleOpenStreamFrame(serverPubkey, entry, params, cvm, mcp) {
+    const progress = Number(params.progress ?? NaN);
+    if (!Number.isSafeInteger(progress) || progress < 0) return;
+    if (entry.streamEnded) return;
+    const stream = entry.stream;
+    if (!stream) {
+      if (cvm.frameType !== "start") return;
+      entry.stream = {
+        token: params.progressToken,
+        lastProgress: progress,
+        localProgress: 0,
+        nextChunkIndex: 0,
+        outOfOrder: /* @__PURE__ */ new Map(),
+        outOfOrderCodeUnits: 0,
+        pendingNonce: null,
+        idleTimer: setTimeout(() => onStreamIdle(entry), streamIdleTimeoutMs),
+        probeTimer: null
+      };
+      refreshPendingTimeout(entry);
+      routeEvent(serverPubkey, mcp);
+      return;
+    }
+    const admitOrderedActivity = () => {
+      if (progress <= stream.lastProgress) {
+        failStream(entry, "non-monotonic progress");
+        return false;
+      }
+      stream.lastProgress = progress;
+      resetStreamIdleTimer(entry, stream);
+      refreshPendingTimeout(entry);
+      return true;
+    };
+    switch (cvm.frameType) {
+      case "start":
+        failStream(entry, "duplicate start");
+        return;
+      case "accept":
+        if (!admitOrderedActivity()) return;
+        routeEvent(serverPubkey, mcp);
+        return;
+      case "chunk": {
+        if (typeof cvm.data !== "string" || !isBoundedInteger(cvm.chunkIndex, 0, Number.MAX_SAFE_INTEGER)) {
+          failStream(entry, "malformed chunk");
+          return;
+        }
+        const index = cvm.chunkIndex;
+        if (index < stream.nextChunkIndex) return;
+        if (index > stream.nextChunkIndex) {
+          const existing = stream.outOfOrder.get(index);
+          if (existing) {
+            if (existing.progress !== progress || JSON.stringify(existing.message) !== JSON.stringify(mcp)) {
+              failStream(entry, "conflicting duplicate chunk");
+            }
+            return;
+          }
+          if (progress <= stream.lastProgress || stream.outOfOrder.size >= MAX_STREAM_BUFFERED_CHUNKS || stream.outOfOrderCodeUnits + cvm.data.length > MAX_STREAM_BUFFERED_CODE_UNITS) {
+            failStream(entry, progress <= stream.lastProgress ? "non-monotonic progress" : "gap buffer exhausted");
+            return;
+          }
+          stream.outOfOrder.set(index, { message: mcp, progress, codeUnits: cvm.data.length });
+          stream.outOfOrderCodeUnits += cvm.data.length;
+          resetStreamIdleTimer(entry, stream);
+          refreshPendingTimeout(entry);
+          return;
+        }
+        const ready = [
+          { message: mcp, progress, codeUnits: 0 }
+        ];
+        let nextIndex = index + 1;
+        while (stream.outOfOrder.has(nextIndex)) {
+          ready.push(stream.outOfOrder.get(nextIndex));
+          nextIndex += 1;
+        }
+        let previousProgress = stream.lastProgress;
+        for (const item of ready) {
+          if (item.progress <= previousProgress) {
+            failStream(entry, "non-monotonic chunk order");
+            return;
+          }
+          previousProgress = item.progress;
+        }
+        for (let bufferedIndex = index + 1; bufferedIndex < nextIndex; bufferedIndex++) {
+          const buffered = stream.outOfOrder.get(bufferedIndex);
+          stream.outOfOrder.delete(bufferedIndex);
+          stream.outOfOrderCodeUnits -= buffered.codeUnits;
+        }
+        for (const item of ready) {
+          routeEvent(serverPubkey, item.message);
+          stream.nextChunkIndex += 1;
+        }
+        stream.lastProgress = previousProgress;
+        resetStreamIdleTimer(entry, stream);
+        refreshPendingTimeout(entry);
+        return;
+      }
+      case "ping": {
+        if (typeof cvm.nonce !== "string") return;
+        if (new TextEncoder().encode(cvm.nonce).byteLength > MAX_PING_NONCE_BYTES) return;
+        if (!admitOrderedActivity()) return;
+        void publishStreamFrame(entry, stream, { frameType: "pong", nonce: cvm.nonce }).catch(() => {
+          failStream(entry, "pong publication failed");
+        });
+        return;
+      }
+      case "pong": {
+        if (stream.pendingNonce === null || cvm.nonce !== stream.pendingNonce) return;
+        if (!admitOrderedActivity()) return;
+        stream.pendingNonce = null;
+        if (stream.probeTimer) clearTimeout(stream.probeTimer);
+        stream.probeTimer = null;
+        return;
+      }
+      case "close": {
+        if (cvm.lastChunkIndex !== void 0) {
+          const bound = cvm.lastChunkIndex;
+          const complete = isBoundedInteger(bound, 0, Number.MAX_SAFE_INTEGER) && stream.nextChunkIndex === bound + 1 && stream.outOfOrder.size === 0;
+          if (!complete) {
+            failStream(entry, "close with unresolved chunk gaps");
+            return;
+          }
+        }
+        if (!admitOrderedActivity()) return;
+        routeEvent(serverPubkey, mcp);
+        endStream(entry);
+        return;
+      }
+      case "abort":
+        if (!admitOrderedActivity()) return;
+        routeEvent(serverPubkey, mcp);
+        endStream(entry);
+        return;
+      default:
+        return;
+    }
+  }
+  function refreshPendingTimeout(entry) {
+    clearTimeout(entry.timer);
+    entry.timer = setTimeout(() => {
+      const settled = settlePending(entry.correlationId);
+      settled?.reject(new Error("relay timeout"));
+    }, entry.timeoutMs);
+  }
+  function routeMessage(serverPubkey, mcp) {
     const id = mcp.id;
     if (id != null && pending.has(String(id))) {
       const entry = pending.get(String(id));
       if (entry.serverPubkey !== serverPubkey) return;
-      pending.delete(String(id));
-      clearTimeout(entry.timer);
-      entry.resolve({ ...mcp, id: entry.originalId });
+      const settled = settlePending(String(id));
+      settled?.resolve({ ...mcp, id: entry.originalId });
       return;
     }
+    routeEvent(serverPubkey, mcp);
+  }
+  function routeEvent(serverPubkey, mcp) {
     if (mcp.method !== void 0 && sessions.has(serverPubkey)) {
       const server = { pubkey: serverPubkey };
       for (const handler of eventHandlers) handler(server, mcp);
     }
   }
   async function publishMcp(server, relays, message) {
+    const capabilityTags = [
+      ...encrypt22 ? [[SUPPORT_ENCRYPTION]] : [],
+      ...encrypt22 && wrapKind === KIND_GIFT_WRAP_EPHEMERAL ? [[SUPPORT_ENCRYPTION_EPHEMERAL]] : [],
+      [SUPPORT_OVERSIZED_TRANSFER],
+      [SUPPORT_OPEN_STREAM]
+    ];
     const inner = finalizeEvent(
-      { kind: KIND_CVM, created_at: Math.floor(Date.now() / 1e3), tags: [["p", server.pubkey]], content: JSON.stringify(message) },
+      {
+        kind: KIND_CVM,
+        created_at: Math.floor(Date.now() / 1e3),
+        tags: [["p", server.pubkey], ...capabilityTags],
+        content: JSON.stringify(message)
+      },
       clientSecretKey
     );
     if (!encrypt22) {
@@ -15360,17 +15793,52 @@ function createNostrCvmTransport(options = {}) {
   function sendCorrelated(server, relays, message, timeout) {
     const correlationId = nextCorrelationId();
     const originalId = message.id;
-    const outgoing = { ...message, id: correlationId };
+    let outgoing = { ...message, id: correlationId };
+    let issuedToken;
+    const params = message.params && typeof message.params === "object" ? message.params : void 0;
+    const meta = params?._meta && typeof params._meta === "object" ? params._meta : void 0;
+    const explicit = meta?.progressToken;
+    if (message.method === "tools/call") {
+      issuedToken = typeof explicit === "string" || typeof explicit === "number" ? explicit : correlationId;
+      outgoing = {
+        ...outgoing,
+        params: {
+          ...params,
+          _meta: {
+            ...meta,
+            progressToken: issuedToken
+          }
+        }
+      };
+    } else if (typeof explicit === "string" || typeof explicit === "number") {
+      issuedToken = explicit;
+    }
+    const tokenKey = progressTokenKey(issuedToken);
+    const issuedKey = tokenKey ? `${server.pubkey}:${tokenKey}` : null;
+    if (issuedKey && issuedTokens.has(issuedKey)) {
+      return Promise.reject(new Error("duplicate progress token"));
+    }
     return new Promise((resolve, reject2) => {
-      const timer = setTimeout(() => {
-        pending.delete(correlationId);
-        reject2(new Error("relay timeout"));
-      }, timeout);
-      pending.set(correlationId, { resolve, reject: reject2, timer, originalId, serverPubkey: server.pubkey });
+      const entry = {
+        resolve,
+        reject: reject2,
+        timer: setTimeout(() => {
+          const settled = settlePending(correlationId);
+          settled?.reject(new Error("relay timeout"));
+        }, timeout),
+        timeoutMs: timeout,
+        originalId,
+        serverPubkey: server.pubkey,
+        correlationId
+      };
+      if (issuedKey) {
+        entry.tokenKey = issuedKey;
+        issuedTokens.set(issuedKey, correlationId);
+      }
+      pending.set(correlationId, entry);
       void publishMcp(server, relays, outgoing).catch((err2) => {
-        pending.delete(correlationId);
-        clearTimeout(timer);
-        reject2(err2 instanceof Error ? err2 : new Error("publish failed"));
+        const settled = settlePending(correlationId);
+        settled?.reject(err2 instanceof Error ? err2 : new Error("publish failed"));
       });
     });
   }
@@ -15468,6 +15936,10 @@ function createNostrCvmTransport(options = {}) {
       if (!session) return;
       sessions.delete(server.pubkey);
       releaseRelays(session.relays);
+      for (const [correlationId, entry] of pending) {
+        if (entry.serverPubkey !== server.pubkey) continue;
+        settlePending(correlationId)?.reject(new Error("server closed"));
+      }
     },
     onEvent(handler) {
       eventHandlers.add(handler);
@@ -15482,9 +15954,12 @@ function createNostrCvmTransport(options = {}) {
       inbound = null;
       for (const entry of pending.values()) {
         clearTimeout(entry.timer);
+        releaseTransfer(entry);
+        releaseStream(entry);
         entry.reject(new Error("transport disposed"));
       }
       pending.clear();
+      issuedTokens.clear();
       sessions.clear();
       relayRefcount.clear();
       eventHandlers.clear();
@@ -16389,14 +16864,14 @@ var CacheStorageNappletArtifactCache = class {
     this.softCeilingBytes = options.softCeilingBytes ?? DEFAULT_SOFT_CEILING_BYTES;
     this.hardCeilingBytes = options.hardCeilingBytes ?? DEFAULT_HARD_CEILING_BYTES;
   }
-  async readBlob(sha256Hex) {
+  async readBlob(sha256Hex2) {
     try {
       const cache2 = await this.open();
-      const response = await cache2.match(this.blobUrl(sha256Hex));
+      const response = await cache2.match(this.blobUrl(sha256Hex2));
       if (!response) return void 0;
       const bytes = await responseBytes(response);
       const index = await this.readIndex(cache2);
-      const entry = index.blobs[sha256Hex];
+      const entry = index.blobs[sha256Hex2];
       if (entry) {
         entry.lastAccessed = this.now();
         index.updatedAt = entry.lastAccessed;
@@ -16404,20 +16879,20 @@ var CacheStorageNappletArtifactCache = class {
       }
       return bytes;
     } catch (cause) {
-      this.diagnostic({ type: "cache-read-failed", message: `failed to read blob ${sha256Hex}`, cause });
+      this.diagnostic({ type: "cache-read-failed", message: `failed to read blob ${sha256Hex2}`, cause });
       return void 0;
     }
   }
-  async deleteBlob(sha256Hex) {
+  async deleteBlob(sha256Hex2) {
     try {
       const cache2 = await this.open();
-      await cache2.delete(this.blobUrl(sha256Hex));
+      await cache2.delete(this.blobUrl(sha256Hex2));
       const index = await this.readIndex(cache2);
-      delete index.blobs[sha256Hex];
+      delete index.blobs[sha256Hex2];
       index.updatedAt = this.now();
       await this.writeIndex(cache2, index);
     } catch (cause) {
-      this.diagnostic({ type: "cache-delete-failed", message: `failed to delete blob ${sha256Hex}`, cause });
+      this.diagnostic({ type: "cache-delete-failed", message: `failed to delete blob ${sha256Hex2}`, cause });
     }
   }
   async writeVerifiedResolution(input) {
@@ -16798,22 +17273,22 @@ function verifyManifestSignature(event) {
     return false;
   }
 }
-function verifyBlobHash(bytes, sha256Hex) {
-  return bytesToHex2(sha256(bytes)) === sha256Hex;
+function verifyBlobHash(bytes, sha256Hex2) {
+  return bytesToHex2(sha256(bytes)) === sha256Hex2;
 }
 function stripTrailingSlash(url) {
   return url.endsWith("/") ? url.slice(0, -1) : url;
 }
-async function fetchBlob(servers, sha256Hex, fetchBytes) {
+async function fetchBlob(servers, sha256Hex2, fetchBytes) {
   for (const server of servers) {
-    const url = `${stripTrailingSlash(server)}/${sha256Hex}`;
+    const url = `${stripTrailingSlash(server)}/${sha256Hex2}`;
     try {
       const bytes = await fetchBytes(url);
-      if (verifyBlobHash(bytes, sha256Hex)) return bytes;
+      if (verifyBlobHash(bytes, sha256Hex2)) return bytes;
     } catch {
     }
   }
-  throw new NappletResolutionError("blob-unavailable", `no server served blob ${sha256Hex}`);
+  throw new NappletResolutionError("blob-unavailable", `no server served blob ${sha256Hex2}`);
 }
 var INDEX_PATHS = ["/index.html", "index.html", "/"];
 function defaultDecode(bytes) {
@@ -20425,7 +20900,7 @@ async function resolvePajaPointer(value, options = {}) {
     const resolved = await resolveNapplet({
       event,
       cache: await openNappletArtifactCache({ requireStorageEstimate: false }),
-      fetchBlob: (sha256Hex, servers) => fetchBlob([...servers, ...blossomServers], sha256Hex, async (url) => {
+      fetchBlob: (sha256Hex2, servers) => fetchBlob([...servers, ...blossomServers], sha256Hex2, async (url) => {
         const response = await (options.fetcher ?? fetch)(url);
         if (!response.ok) throw new Error(`[paja-runtime] blob ${url}: ${response.status}`);
         return new Uint8Array(await response.arrayBuffer());