@kehto/services 0.21.2 → 0.22.1

package/README.md

@@ -73,7 +73,10 @@ do not select a handler.
 `ok: true` means the selected target was ready and the convention was dispatched.
 The result includes `handled`, `handler`, `windowId`, and `convention`. The
 target receives the convention and opaque payload through one runtime-attested
-`inc.event`; there is no separate `intent.deliver` lifecycle.
+`intent.deliver` envelope with a nested `delivery` object. The host-owned
+`intent.onDelivery` binding buffers arrivals until a handler registers; INC is
+not required. Invocation and result semantics remain on the existing package
+contract pending the separate upstream NAP migration.
 
 Paja currently exposes only an exact-contract development simulator, and the
 playground currently exposes only a verified-manifest catalog builder. Phase
@@ -637,3 +640,13 @@ Generated API module: `docs/api/modules/_kehto_services.html` (run `pnpm docs:ap
 ## License
 
 MIT
+
+## NIP-5D event compatibility
+
+Current manifests use a direct artifact `x` hash, plain-text `content`, independent
+`z`/`i` routing declarations, and required `R` / optional `O` domains. Kehto also
+accepts legacy aggregate events through an isolated compatibility adapter.
+Existing `aggregateHash` host/cache/ACL fields carry the verified artifact hash
+for current events; legacy identities keep their original aggregate. Both paths
+verify signatures and bytes before runtime injection and `srcdoc` execution.
+For the schema and removal boundary, see [event migration](https://kehto.github.io/web/docs/migrations/NIP-5D-EVENT-SCHEMA.html).

package/dist/cvm-nostr-transport.d.ts

@@ -14,6 +14,8 @@ import '@kehto/runtime';
  *    random key, `p`-tagged to the server. Responses arrive the same way,
  *    `p`-tagged to the client, and are correlated by the inner JSON-RPC `id`.
  *  - Discovery reads kind-11316 (server) + kind-11317 (tools) announcements.
+ *  - CEP-22 oversized transfers and CEP-41 open streams ride
+ *    `notifications/progress` frames addressed by the request progressToken.
  *
  * Shipped on a separate entry (`@kehto/services/cvm-nostr-transport`) so the
  * `nostr-tools` dependency stays out of the core `@kehto/services` bundle.
@@ -84,6 +86,10 @@ interface NostrCvmTransportOptions {
         name: string;
         version: string;
     };
+    /** CEP-41: per-stream idle timeout before a keepalive ping is sent. */
+    streamIdleTimeoutMs?: number;
+    /** CEP-41: probe deadline waiting for a pong after a keepalive ping. */
+    streamProbeTimeoutMs?: number;
 }
 /**
  * Create a Nostr-backed ContextVM transport.

package/dist/cvm-nostr-transport.js

@@ -7,15 +7,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;
@@ -23,6 +43,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) {
@@ -47,11 +80,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) {
@@ -113,23 +149,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 i = 0; i < totalChunks; i++) {
+        if (!transfer.chunks.has(first + i)) 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 i = 0; i < totalChunks; i++) {
+      payload += transfer.chunks.get(firstProgress + i);
+    }
+    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 = [
+      ...encrypt2 ? [[SUPPORT_ENCRYPTION]] : [],
+      ...encrypt2 && 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 (!encrypt2) {
@@ -153,17 +545,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, reject) => {
-      const timer = setTimeout(() => {
-        pending.delete(correlationId);
-        reject(new Error("relay timeout"));
-      }, timeout);
-      pending.set(correlationId, { resolve, reject, timer, originalId, serverPubkey: server.pubkey });
+      const entry = {
+        resolve,
+        reject,
+        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((err) => {
-        pending.delete(correlationId);
-        clearTimeout(timer);
-        reject(err instanceof Error ? err : new Error("publish failed"));
+        const settled = settlePending(correlationId);
+        settled?.reject(err instanceof Error ? err : new Error("publish failed"));
       });
     });
   }
@@ -261,6 +688,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);
@@ -275,9 +706,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();