@trevrpc/trevrpc-js 1.1.0 → 1.3.0

package/src/call.js

@@ -1,8 +1,16 @@
+import {
+  encodeMessage,
+  receivedMessage,
+  sessionCompression,
+  transportCompression,
+} from "./compression.js";
+import { transportConnectionMetadata } from "./connection-metadata.js";
 import { datagramEndpoint, messageFrameSize } from "./datagram.js";
 import {
   DefaultMaxFrameSize,
   FrameReader,
-  encodeMessageFrame,
+  FrameType,
+  encodeOutgoingFrame,
   encodeRequestFrame,
 } from "./framing.js";
 import { normalizeMetadata, validateMetadata } from "./metadata.js";
@@ -12,10 +20,12 @@ import {
   cancelled,
   deadlineExceeded,
   failedPrecondition,
+  internal,
   invalidArgument,
   statusError,
   statusFromTransportError,
 } from "./status.js";
+import { CallStreams, ReplayCopies, streamBudget } from "./stream-compression.js";
 
 /** Longest delay setTimeout can represent; it fires immediately beyond this. */
 const MaxTimerDelayMs = 2_147_483_647;
@@ -106,6 +116,9 @@ class CallScope {
  * call's cancellation scope. Transport failures surface as TrevRpcError, and once the call is
  * aborted every operation fails with the abort reason.
  */
+/** Why sends fail once the server completed the call with OK before the upload ended. */
+export const EarlyOk = "the server completed the call before the request stream ended";
+
 export class Call {
   #scope;
   #writer;
@@ -128,66 +141,272 @@ export class Call {
   #flow;
   /** Whether request messages are sent as datagrams when they fit. */
   #sendDatagrams = false;
+  /** The compression state of the session that carries the call, or undefined without one. */
+  #compression;
+  /** The connection metadata state of the session that carries the call, or undefined without. */
+  #connectionMetadata;
+  /** The ID of the connection metadata set the REQUEST offered, or zero. */
+  #offeredMetadata = 0;
+  /** The full protobuf type name of the request messages. */
+  #requestType;
+  /**
+   * What the call accepts on its response messages: a Map from dictionary ID to dictionary, 0 for
+   * compression without one; undefined without compression.
+   */
+  #accept;
+  /** Whether request messages may be compressed without a dictionary. */
+  #plainRequests = false;
+  /** Whether the REQUEST queried the server's dictionaries, so its ANSWER answers the query. */
+  #queried = false;
+  /** The call's stream compression, or undefined if its method or transport has none. */
+  #streams;
   /** Request messages of a call that uses datagrams, queued for the flush loop, in order. */
   #unsent = [];
   /** Settles when the flush loop has sent everything queued so far. */
   #sendTail = Promise.resolve();
   #flushing = false;
+  /**
+   * What the call needs to open itself again, for the replay of a refused optimistic call:
+   * `{ transport, request, rpc, deadline }`, where `deadline` is the `performance.now()` time the
+   * call's timeout ends, or undefined.
+   */
+  #setup;
+  /**
+   * The requests an optimistic call has sent, kept until the server accepts or refuses it;
+   * undefined once it decided, and on calls that are not optimistic.
+   */
+  #copies;
+  /** Whether the call was optimistic, so its sends and close go through #ordered. */
+  #optimistic = false;
+  /** Settles once the previous send or close of an optimistic call has written, in call order. */
+  #ordered = Promise.resolve();
+  /** The replay of a refused optimistic call, once it started. */
+  #replaying;
 
   /**
    * Opens a stream on the transport and sends the REQUEST frame. The request carries the
    * method path and kind; metadata and the wire timeout come from the options. The request
-   * message of a unary or server-streaming call goes out in the same write.
+   * message of a unary or server-streaming call, a marshalled body, goes out in the same write.
    *
-   * `datagrams` is `{ send, receive }` for a method that marks a direction unreliable: the call
-   * gets a datagram flow if the session that carries it has datagrams, which is only known once
-   * its stream is open, so the REQUEST is encoded after that. `send` makes it send request
-   * messages as datagrams, `receive` makes it accept response datagrams.
+   * `rpc` describes the method. `rpc.types` holds the full names of its request and response
+   * message types, which pick the dictionaries when the transport has compression. `rpc.datagrams`
+   * is `{ send, receive }` for a method that marks a direction unreliable: the call gets a
+   * datagram flow if the session that carries it has datagrams. Both depend on that session, which
+   * is only known once the stream is open, so then the REQUEST is encoded after that. `send` makes
+   * the call send request messages as datagrams, `receive` makes it accept response datagrams.
+   * `rpc.compressStream` is `{ requests, responses }`, the directions the call may
+   * stream-compress when the transport has compression, and `rpc.compress` the same for
+   * compression without a dictionary.
    */
-  static async open(transport, request, message, options, datagrams) {
+  static async open(transport, request, message, options, rpc = {}) {
     const fields = { ...request, metadata: options.metadata, ...timeoutField(options) };
-    const header =
-      datagrams === undefined ? encodeRequestFrame(fields, message, options.maxFrameSize) : null;
+    const compression = transportCompression(transport);
+    // The REQUEST depends on the session that carries the call if it negotiates compression, opens
+    // a datagram flow or carries connection metadata.
+    const perSession =
+      rpc.datagrams !== undefined ||
+      compression !== undefined ||
+      transportConnectionMetadata(transport)?.current !== undefined;
+    const header = perSession
+      ? null
+      : encodeRequestFrame(fields, outgoing(message), options.maxFrameSize);
     const scope = new CallScope(options);
     let call;
     try {
-      const session = datagrams === undefined ? undefined : {};
+      const session = perSession ? {} : undefined;
       const stream = await openStream(transport, scope.signal, session);
       call = new Call(stream, scope, options.maxFrameSize);
-      await call.#write(header ?? call.#requestWithFlow(fields, message, session, datagrams));
+      call.#setup = {
+        transport,
+        request: { ...request, metadata: options.metadata },
+        rpc,
+        deadline: options.timeoutMs == null ? undefined : performance.now() + options.timeoutMs,
+      };
+      await call.#write(
+        header ?? call.#requestOnSession(fields, message, session, compression, transport, rpc),
+      );
       return call;
     } catch (error) {
       if (call !== undefined) {
-        call.#releaseFlow();
+        call.#releaseSessionState();
       }
       throw scope.abort(failureStatus(error));
     }
   }
 
-  /** Opens the call's flow on its session, if it has datagrams, and encodes the REQUEST. */
-  #requestWithFlow(fields, message, session, { send, receive }) {
-    this.#flow = datagramEndpoint(session.datagrams)?.openFlow({ receive });
-    this.#sendDatagrams = this.#flow !== undefined && send;
+  /**
+   * Sets the call up on the session that carries it, negotiating compression and opening its
+   * datagram flow as the method needs, and encodes the REQUEST. A call whose requests may be
+   * stream-compressed offers optimistically while the session allows it, unless `replay` says this
+   * is the replay of a refused call or the call has a datagram flow, which a replay would need to
+   * open again.
+   */
+  #requestOnSession(fields, message, session, compression, transport, rpc, replay = false) {
+    const { types, datagrams, compressStream, compress } = rpc;
+    const request = { ...fields };
+    if (datagrams !== undefined) {
+      this.#flow = datagramEndpoint(session.datagrams)?.openFlow({
+        receive: datagrams.receive,
+        inflate: (frame) => this.receivedMessage(frame),
+      });
+      this.#sendDatagrams = this.#flow !== undefined && datagrams.send;
+      if (this.#flow !== undefined) {
+        request.datagramFlow = this.#flow.id;
+      }
+    }
+    if (compression !== undefined) {
+      this.#compression = sessionCompression(compression, session.key);
+      this.#requestType = types.request;
+      const negotiation = this.#compression.prepare(types.response, Boolean(compress?.responses));
+      Object.assign(request, negotiation.fields);
+      this.#accept = negotiation.accept;
+      this.#plainRequests = Boolean(compress?.requests);
+      this.#queried = negotiation.queried;
+      if (compressStream?.requests || compressStream?.responses) {
+        const budget = streamBudget(transport);
+        this.#streams = new CallStreams(compression, budget, compressStream, {
+          session: this.#compression,
+          requestType: types.request,
+          accept: negotiation.accept,
+        });
+        const optimistic =
+          !replay && this.#flow === undefined && this.#compression.optimisticStreams;
+        if (this.#streams.offer(request, optimistic)) {
+          this.#copies = new ReplayCopies(budget);
+          this.#optimistic = true;
+        }
+      }
+    }
+    this.#connectionMetadata = transportConnectionMetadata(transport)?.session(session.key);
+    if (this.#connectionMetadata !== undefined) {
+      const { field, offered } = this.#connectionMetadata.prepare();
+      this.#offeredMetadata = offered;
+      if (field !== undefined) {
+        request.connectionMetadata = field;
+      }
+    }
     return encodeRequestFrame(
-      this.#flow === undefined ? fields : { ...fields, datagramFlow: this.#flow.id },
-      message,
+      request,
+      message === undefined ? undefined : this.#encode(message),
       this.#maxFrameSize,
     );
   }
 
+  /**
+   * Encodes a request message for sending: through the call's stream context once that exists,
+   * and otherwise compressed when the session's shared set has the dictionary of the request type,
+   * or compression without a dictionary where the method allows it. Both are checked per message,
+   * so a request stream starts compressing as soon as the server's answer arrives.
+   */
+  #encode(body) {
+    if (body.byteLength > this.#maxFrameSize) {
+      return encodeMessage(body);
+    }
+    const dictionary = this.#compression?.requestCompressor(this.#requestType, this.#plainRequests);
+    return this.#streams === undefined
+      ? encodeMessage(body, dictionary)
+      : this.#streams.encode(body, dictionary);
+  }
+
+  /**
+   * The message of a received MESSAGE, ZSTD_MESSAGE or ZSTD_STREAM_MESSAGE frame,
+   * `{ type, payload }`. A compressed message must use what the call negotiated and fit
+   * `maxFrameSize`; it fails with Internal or ResourceExhausted otherwise.
+   */
+  receivedMessage(frame) {
+    if (frame.type === FrameType.ZstdStreamMessage) {
+      if (this.#streams === undefined) {
+        throw internal("stream-compressed message where stream compression is not enabled");
+      }
+      return this.#streams.receive(frame.payload, this.#maxFrameSize);
+    }
+    return receivedMessage(frame, this.#accept, this.#maxFrameSize);
+  }
+
+  /**
+   * Records the server's ANSWER to what the REQUEST asked. It answers a dictionary query whole,
+   * and must accept an optimistic call; a `stream_compression` answer also lets the session's
+   * calls be optimistic again after a refusal. A `connection_metadata` answer confirms the set the
+   * REQUEST offered, so the session's calls refer to it from now on.
+   */
+  learnAnswers(answer) {
+    if (this.#copies !== undefined && !answer.streamCompression) {
+      throw internal("ANSWER of an optimistic call did not accept stream compression");
+    }
+    this.#connectionMetadata?.learn(this.#offeredMetadata, answer);
+    if (this.#queried) {
+      this.#compression.learn(answer.dictionaries);
+    }
+    if (answer.streamCompression) {
+      this.#streams?.accept();
+      if (this.#compression !== undefined) {
+        this.#compression.optimisticStreams = true;
+      }
+    }
+    this.#settleCopies("accepted");
+  }
+
+  /**
+   * Whether the server has yet to accept or refuse the call's optimistic stream compression, so a
+   * refusing STATUS can still be replayed.
+   */
+  get replayable() {
+    return this.#copies !== undefined;
+  }
+
+  /**
+   * Replays a call the server refused: opens a new stream for it with the same REQUEST, not
+   * optimistic and with the time left before its deadline, and sends the kept requests and, if the
+   * caller closed the request side, its end. Sends waiting meanwhile continue on the new stream.
+   * The session stops being optimistic until a call is answered. Resolves once the replay was
+   * written; the response is read from the new stream after that.
+   */
+  replay() {
+    const copies = this.#copies;
+    this.#copies = undefined;
+    this.#compression.optimisticStreams = false;
+    this.#replaying = this.#reopen(copies.settle("refused"));
+    this.#replaying.catch(() => {});
+    return this.#replaying;
+  }
+
+  async #reopen(bodies) {
+    const { transport, request, rpc, deadline } = this.#setup;
+    // The old stream's failures belong to the refused call, not to this one.
+    this.#writer.abort(cancelled("RPC replayed")).catch(() => {});
+    this.#cancelReader(cancelled("RPC replayed")).catch(() => {});
+    this.#releaseSessionState();
+    const session = {};
+    const stream = await openStream(transport, this.signal, session);
+    this.#attach(stream);
+    this.#uploadFailure = undefined;
+    const timeoutMs =
+      deadline === undefined ? undefined : Math.max(0, deadline - performance.now());
+    const fields = { ...request, ...timeoutField({ timeoutMs }) };
+    const compression = transportCompression(transport);
+    await this.#write(
+      this.#requestOnSession(fields, undefined, session, compression, transport, rpc, true),
+    );
+    for (const body of bodies) {
+      await this.#write(encodeOutgoingFrame(this.#encode(body), this.#maxFrameSize));
+    }
+    if (this.#sendClosed && this.#uploadEnded === undefined) {
+      await this.#upload(this.#writer.close());
+      this.#closeCompleted = true;
+    }
+  }
+
+  /** Ends an optimistic call's wait for the server's decision with `outcome`. */
+  #settleCopies(outcome) {
+    const copies = this.#copies;
+    this.#copies = undefined;
+    copies?.settle(outcome);
+  }
+
   constructor(stream, scope, maxFrameSize) {
-    const reader = stream.readable.getReader();
     this.#scope = scope;
-    this.#writer = stream.writable.getWriter();
-    this.#cancelReader = (reason) => reader.cancel(reason);
-    this.#frames = new FrameReader(reader);
     this.#maxFrameSize = maxFrameSize;
-    // The transport errors the request side as soon as the server stops reading it.
-    this.#writer.closed.catch((error) => {
-      if (this.#uploadEnded === undefined) {
-        this.#uploadFailure ??= statusFromTransportError(error);
-      }
-    });
+    this.#attach(stream);
     scope.signal.addEventListener("abort", () => this.#teardown(), { once: true });
     if (scope.signal.aborted) {
       this.#teardown();
@@ -207,6 +426,21 @@ export class Call {
     return this.#uploadFailure;
   }
 
+  /** Makes `stream` the one the call writes and reads. */
+  #attach(stream) {
+    const reader = stream.readable.getReader();
+    const writer = stream.writable.getWriter();
+    this.#writer = writer;
+    this.#cancelReader = (reason) => reader.cancel(reason);
+    this.#frames = new FrameReader(reader);
+    // The transport errors the request side as soon as the server stops reading it.
+    writer.closed.catch((error) => {
+      if (this.#writer === writer && this.#uploadEnded === undefined) {
+        this.#uploadFailure ??= statusFromTransportError(error);
+      }
+    });
+  }
+
   /** Whether the request side can still be written: not ended, not closed. */
   get uploadOpen() {
     return this.#uploadEnded === undefined && !this.#closeCompleted;
@@ -235,10 +469,14 @@ export class Call {
     if (this.#sendClosed) {
       return Promise.reject(failedPrecondition("request stream is closed"));
     }
+    if (this.#optimistic) {
+      return this.#inOrder((issued) => this.#sendOptimistic(body, issued));
+    }
+    const message = this.#encode(body);
     if (this.#sendDatagrams) {
       return this.#upload(
         new Promise((resolve, reject) => {
-          this.#unsent.push({ body, resolve, reject });
+          this.#unsent.push({ message, resolve, reject });
           if (!this.#flushing) {
             this.#flushing = true;
             // Messages sent in the same turn are packed together; nothing waits for a timer.
@@ -247,7 +485,7 @@ export class Call {
         }),
       );
     }
-    return this.#write(encodeMessageFrame(body, this.#maxFrameSize));
+    return this.#write(encodeOutgoingFrame(message, this.#maxFrameSize));
   }
 
   /**
@@ -264,11 +502,14 @@ export class Call {
           throw this.#uploadEnded;
         }
         inFlight = this.#takeBatch();
-        if (inFlight.length === 0 || !(await this.#flow.send(inFlight.map(bodyOf), this.signal))) {
+        if (
+          inFlight.length === 0 ||
+          !(await this.#flow.send(inFlight.map(messageOf), this.signal))
+        ) {
           // Not a datagram: a head message that never fits, or a datagram that failed to send.
           inFlight = inFlight.length > 0 ? inFlight : [this.#unsent.shift()];
-          for (const { body } of inFlight) {
-            await this.#writer.write(encodeMessageFrame(body, this.#maxFrameSize));
+          for (const { message } of inFlight) {
+            await this.#writer.write(encodeOutgoingFrame(message, this.#maxFrameSize));
           }
         }
         for (const item of inFlight) {
@@ -293,9 +534,9 @@ export class Call {
     let room = this.#flow.frameRoom;
     let count = 0;
     while (count < this.#unsent.length) {
-      const { body } = this.#unsent[count];
-      const size = messageFrameSize(body);
-      if (body.byteLength > this.#maxFrameSize || size > room) {
+      const { message } = this.#unsent[count];
+      const size = messageFrameSize(message);
+      if (message.size > this.#maxFrameSize || size > room) {
         break;
       }
       room -= size;
@@ -304,12 +545,89 @@ export class Call {
     return this.#unsent.splice(0, count);
   }
 
+  /**
+   * Runs `operation(issued)` after the previous send or close of an optimistic call has written,
+   * so they reach the stream in call order even when one waits; `operation` calls `issued` once
+   * it has written.
+   */
+  #inOrder(operation) {
+    const previous = this.#ordered;
+    let issued;
+    this.#ordered = new Promise((resolve) => {
+      issued = resolve;
+    });
+    return previous.then(() => operation(issued)).finally(issued);
+  }
+
+  /**
+   * Sends a request of an optimistic call. Until the server decides, the request is kept for a
+   * replay; one that does not fit waits for the decision. A request written to a stream the
+   * server then refused does not fail: the replay sends it again.
+   */
+  async #sendOptimistic(body, issued) {
+    let copies;
+    for (;;) {
+      if (this.#uploadEnded !== undefined) {
+        throw this.#uploadEnded;
+      }
+      if (this.#replaying !== undefined) {
+        await this.#replaying;
+      }
+      if (this.#copies === undefined) {
+        break;
+      }
+      if (this.#copies.keep(body)) {
+        copies = this.#copies;
+        break;
+      }
+      await this.#copies.decided;
+    }
+    const writing = this.#write(encodeOutgoingFrame(this.#encode(body), this.#maxFrameSize));
+    issued();
+    await this.#survivingRefusal(writing, copies);
+  }
+
+  /**
+   * Waits for a write of an optimistic call. If it fails while the server's decision was pending
+   * and the server then refused the call, the replay covers it: this waits for the replay instead.
+   */
+  async #survivingRefusal(writing, copies) {
+    try {
+      return await writing;
+    } catch (error) {
+      if (copies !== undefined && (await copies.decided) === "refused") {
+        await this.#replaying;
+        return undefined;
+      }
+      throw error;
+    }
+  }
+
   /** Finishes the request stream gracefully. */
   closeSend() {
     if (this.#sendClosed) {
       return Promise.resolve();
     }
     this.#sendClosed = true;
+    if (this.#optimistic) {
+      return this.#inOrder(async (issued) => {
+        if (this.#replaying !== undefined) {
+          // A replay in progress ends the new stream itself; after one, the stream is ended here.
+          issued();
+          await this.#replaying;
+          if (!this.#closeCompleted) {
+            await this.#upload(this.#writer.close());
+            this.#closeCompleted = true;
+          }
+          return;
+        }
+        const copies = this.#copies;
+        const closing = this.#upload(this.#writer.close());
+        issued();
+        await this.#survivingRefusal(closing, copies);
+        this.#closeCompleted = true;
+      });
+    }
     // Datagram sends in flight go first, so the stream does not end before them.
     const closing = this.#sendDatagrams
       ? this.#sendTail.then(() => this.#writer.close())
@@ -328,15 +646,21 @@ export class Call {
   }
 
   /**
-   * Ends the call after its final status was received. The request side stops: pending and later
-   * sends fail with `uploadError`, and an unfinished upload is reset. The rest of the response
-   * stream is drained in the background: unknown frames are skipped, and a known frame after
-   * STATUS cancels the stream without changing the outcome.
+   * Ends the call after its final status was received: `error` for a failed call, undefined for
+   * an OK one. An unfinished upload stops: pending and later sends fail with `error`, or with a
+   * Cancelled status saying the server completed the call early, and the request side is reset.
+   * A request side the caller already closed is left to finish, since the server either read all
+   * of it or stops it after its STATUS (see the wire format): resetting it would only cost the
+   * transport, and a browser's WebTransport a round trip to its network service, on every call.
+   * The rest of the response stream is drained in the background: unknown frames are skipped,
+   * and a known frame after STATUS cancels the stream without changing the outcome.
    */
-  finish(uploadError) {
+  finish(error) {
     this.#scope.settle();
-    this.#releaseFlow();
-    this.#endUpload(uploadError, cancelled("RPC completed"));
+    this.#releaseSessionState();
+    if (!this.#sendClosed || this.#uploadEnded !== undefined) {
+      this.#endUpload(error ?? cancelled(EarlyOk), cancelled("RPC completed"));
+    }
     this.#frames.expectEnd(this.#maxFrameSize).catch(() => this.#cancelReader().catch(() => {}));
   }
 
@@ -359,6 +683,7 @@ export class Call {
    * transport blocked on flow control does not act on an abort while the write is in flight.
    */
   #upload(operation) {
+    const writer = this.#writer;
     return new Promise((resolve, reject) => {
       this.#pendingUploads.add(reject);
       operation.then(
@@ -372,20 +697,26 @@ export class Call {
         },
         (error) => {
           this.#pendingUploads.delete(reject);
-          reject(this.#uploadError(error));
+          reject(this.#uploadError(error, writer));
         },
       );
     });
   }
 
-  /** Maps a failed request-side operation to the call's error. */
-  #uploadError(error) {
+  /**
+   * Maps a failed request-side operation on `writer` to the call's error. Only the stream the call
+   * still writes records the upload failure; a replayed call's old stream does not.
+   */
+  #uploadError(error, writer) {
     if (this.signal.aborted) {
       return this.signal.reason;
     }
     if (error === this.#uploadEnded) {
       return error;
     }
+    if (writer !== this.#writer) {
+      return statusFromTransportError(error);
+    }
     this.#uploadFailure ??= statusFromTransportError(error);
     return this.#uploadFailure;
   }
@@ -417,13 +748,18 @@ export class Call {
     return result;
   }
 
-  /** Ends the datagram flow, if any; every way a call ends gets here. */
-  #releaseFlow() {
+  /**
+   * Ends the datagram flow and frees the stream compression contexts, if any; every way a call
+   * ends gets here.
+   */
+  #releaseSessionState() {
     this.#flow?.release();
+    this.#streams?.close();
+    this.#settleCopies("ended");
   }
 
   #teardown() {
-    this.#releaseFlow();
+    this.#releaseSessionState();
     const reason = this.signal.reason;
     this.#endUpload(reason);
     this.#cancelReader(reason).catch(() => {});
@@ -431,9 +767,9 @@ export class Call {
 }
 
 /**
- * Opens a bidirectional stream. A call that may use datagrams passes `session`, which receives the
- * datagram object of the session that opened the stream, so the flow belongs to the connection
- * that carries the call and not to one a reconnect swapped in later.
+ * Opens a bidirectional stream. A call whose setup depends on its session passes `session`, which
+ * receives that session's `key` and `datagrams` object, so the compression state and datagram flow
+ * belong to the connection that carries the call and not to one a reconnect swapped in later.
  */
 function openStream(transport, signal, session) {
   return new Promise((resolve, reject) => {
@@ -469,21 +805,28 @@ function openStream(transport, signal, session) {
   });
 }
 
-function bodyOf(item) {
-  return item.body;
+function messageOf(item) {
+  return item.message;
+}
+
+/** A request message body as an uncompressed outgoing message, or undefined. */
+function outgoing(body) {
+  return body === undefined ? undefined : encodeMessage(body);
 }
 
 function startStream(transport, session) {
   if (session === undefined) {
     return transport.createBidirectionalStream();
   }
-  if (typeof transport.createBidirectionalStreamWithDatagrams === "function") {
-    return transport.createBidirectionalStreamWithDatagrams().then(({ stream, datagrams }) => {
-      session.datagrams = datagrams;
+  if (typeof transport.createBidirectionalStreamWithSession === "function") {
+    return transport.createBidirectionalStreamWithSession().then(({ stream, session: opened }) => {
+      session.key = opened;
+      session.datagrams = opened.datagrams;
       return stream;
     });
   }
-  // A WebTransport session used directly: its datagrams belong to the stream opened right now.
+  // A WebTransport session used directly: the stream opened right now belongs to it.
+  session.key = transport;
   session.datagrams = transport.datagrams;
   return transport.createBidirectionalStream();
 }