diff --git a/doc/api/quic.md b/doc/api/quic.md
index d36825d6943264..02815eac672e43 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -358,6 +358,29 @@ delivered out of order. The [`session.ondatagramstatus`][] callback reports
 whether each sent datagram was `'acknowledged'`, `'lost'`, or `'abandoned'`
 (never sent on the wire).
 
+#### HTTP/3 datagrams
+
+On HTTP/3 sessions, datagrams are associated with an individual request stream
+rather than with the session as a whole. Send and receive them per-stream with
+[`stream.sendDatagram()`][] and [`stream.ondatagram`][], passing and receiving
+your application payload directly; the protocol framing that binds a datagram to
+its stream is handled internally and never visible to your code. Both peers must
+set [`application.enableDatagrams`][] to `true`.
+
+The session-level datagram API does not apply to HTTP/3 sessions:
+[`session.sendDatagram()`][] throws `ERR_INVALID_STATE` and
+[`session.ondatagram`][] never fires. (Only non-HTTP/3 ALPNs use the raw,
+session-level datagrams described above.)
+
+Because datagrams are unordered with respect to stream data, a datagram is only
+delivered while its associated stream still exists on the receiver; one that
+arrives for an unknown or already-closed stream is dropped.
+
+Under the hood, each HTTP/3 datagram ([RFC 9297][]) is carried in a QUIC
+`DATAGRAM` frame prefixed with a _Quarter Stream ID_ (the request stream's id
+divided by four) that binds it to the stream. This prefix is added and stripped
+automatically; most applications never need to think about it.
+
 ### 0-RTT early data and session resumption
 
 QUIC supports 0-RTT early data, allowing a client that has previously connected
@@ -1114,7 +1137,12 @@ added: v23.8.0
 
 * Type: {quic.OnDatagramCallback}
 
-The callback to invoke when a new datagram is received from a remote peer. Read/write.
+The callback to invoke when a new raw datagram is received from a remote peer.
+Read/write.
+
+This is only used for non-HTTP/3 sessions. On HTTP/3 sessions datagrams are
+bound to a request stream and delivered via [`stream.ondatagram`][] instead;
+this callback never fires. See [Datagrams][].
 
 ### `session.ondatagramstatus`
 
@@ -1384,9 +1412,13 @@ added: v23.8.0
   **Default:** `'utf8'`.
 * Returns: {Promise} for a {bigint} datagram ID.
 
-Sends an unreliable datagram to the remote peer, returning a promise for
+Sends an unreliable raw datagram to the remote peer, returning a promise for
 the datagram ID.
 
+This method is for non-HTTP/3 sessions only. On HTTP/3 sessions datagrams are
+per-stream, so this method throws `ERR_INVALID_STATE`; use
+[`stream.sendDatagram()`][] instead. See [Datagrams][].
+
 If `datagram` is a string, it will be encoded using the specified `encoding`.
 
 If `datagram` is an `ArrayBufferView`, the bytes are copied into an
@@ -1403,12 +1435,6 @@ inherently unreliable).
 If the datagram payload is zero-length (empty string after encoding, detached
 buffer, or zero-length view), `0n` is returned and no datagram is sent.
 
-For HTTP/3 sessions, the peer must advertise `SETTINGS_H3_DATAGRAM=1`
-(via `application: { enableDatagrams: true }`) for datagrams to be sent.
-If the peer's setting is `0`, `sendDatagram()` returns `0n` (per RFC 9297
-§3, an endpoint MUST NOT send HTTP Datagrams unless the peer indicated
-support).
-
 Datagrams cannot be fragmented — each must fit within a single QUIC packet.
 The maximum datagram size is determined by the peer's
 `maxDatagramFrameSize` transport parameter (which the peer advertises during
@@ -2012,6 +2038,20 @@ continue using the still-active direction on a bidirectional stream),
 abort the other direction with [`writer.fail()`][], or tear down the
 whole stream with [`stream.destroy()`][]. Read/write.
 
+### `stream.ondatagram`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {quic.OnStreamDatagramCallback}
+
+The callback invoked when a datagram associated with this stream is received.
+It receives the datagram payload as a `Uint8Array` and a `boolean` indicating
+whether it arrived as 0-RTT early data. Read/write.
+
+Only applies to HTTP/3 sessions. See [Datagrams][].
+
 ### `stream.headers`
 
 <!-- YAML
@@ -2146,6 +2186,29 @@ the [`stream.onwanttrailers`][] callback, or set ahead of time via
 [`stream.pendingTrailers`][]. Throws `ERR_INVALID_STATE` if the session
 does not support headers.
 
+### `stream.sendDatagram(datagram[, encoding])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `datagram` {string|ArrayBufferView}
+* `encoding` {string} The encoding to use if `datagram` is a string.
+  **Default:** `'utf8'`.
+* Returns: {bigint} The datagram id, or `0n` if the datagram was not sent.
+
+Sends an unreliable datagram associated with this stream to the peer, where it
+is delivered to the corresponding stream's [`stream.ondatagram`][] callback. The
+payload is sent as-is; the framing that binds it to the stream is handled
+internally.
+
+Delivery is best-effort: datagrams may be lost, reordered, or dropped. `0n` is
+returned (and the payload silently discarded) if the datagram cannot be sent.
+The delivery status of a sent datagram is reported via the session's
+[`session.ondatagramstatus`][] callback.
+
+Only applies to HTTP/3 sessions. See [Datagrams][].
+
 ### `stream.priority`
 
 <!-- YAML
@@ -3745,6 +3808,16 @@ added: v23.8.0
 * `this` {quic.QuicStream}
 * `error` {any}
 
+### Callback: `OnStreamDatagramCallback`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `this` {quic.QuicStream}
+* `datagram` {Uint8Array} The datagram payload.
+* `early` {boolean} `true` if the datagram arrived as 0-RTT early data.
+
 ### Callback: `OnHeadersCallback`
 
 <!-- YAML
@@ -4424,6 +4497,7 @@ throughput issues caused by flow control.
 
 [Aborting a stream]: #aborting-a-stream
 [Callback error handling]: #callback-error-handling
+[Datagrams]: #datagrams
 [JSON-SEQ]: https://www.rfc-editor.org/rfc/rfc7464
 [NSS Key Log Format]: https://udn.realityripple.com/docs/Mozilla/Projects/NSS/Key_Log_Format
 [Permission Model]: permissions.md#permission-model
@@ -4504,10 +4578,12 @@ throughput issues caused by flow control.
 [`sessionOptions.token`]: #sessionoptionstoken-client-only
 [`stream.destroy()`]: #streamdestroyerror-options
 [`stream.headers`]: #streamheaders
+[`stream.ondatagram`]: #streamondatagram
 [`stream.onerror`]: #streamonerror
 [`stream.onwanttrailers`]: #streamonwanttrailers
 [`stream.pendingTrailers`]: #streampendingtrailers
 [`stream.priority`]: #streampriority
+[`stream.sendDatagram()`]: #streamsenddatagramdatagram-encoding
 [`stream.sendHeaders()`]: #streamsendheadersheaders-options
 [`stream.sendInformationalHeaders()`]: #streamsendinformationalheadersheaders
 [`stream.sendTrailers()`]: #streamsendtrailersheaders
diff --git a/lib/internal/quic/quic.js b/lib/internal/quic/quic.js
index 99eeccc3c51d23..0293c8677defeb 100644
--- a/lib/internal/quic/quic.js
+++ b/lib/internal/quic/quic.js
@@ -276,6 +276,8 @@ const {
 
 const kNilDatagramId = 0n;
 
+const kApplicationTypeHttp3 = 2;
+
 // Module-level registry of all live QuicEndpoint instances. Used by
 // connect() and listen() to find existing endpoints for reuse instead
 // of creating a new one per session.
@@ -945,6 +947,16 @@ setCallbacks({
     this[kOwner][kBlocked]();
   },
 
+  /**
+   * Called when an HTTP/3 datagram (RFC 9297) is received for this stream.
+   * @param {Uint8Array} uint8Array The datagram payload
+   * @param {boolean} early True if received as 0-RTT early data.
+   */
+  onStreamDatagram(uint8Array, early) {
+    debug('stream datagram callback', this[kOwner]);
+    this[kOwner][kDatagram](uint8Array, early);
+  },
+
   onStreamDrain() {
     // Called when the stream's outbound buffer has capacity for more data.
     debug('stream drain callback', this[kOwner]);
@@ -1571,6 +1583,7 @@ class QuicStream {
     onerror: undefined,
     onblocked: undefined,
     onreset: undefined,
+    ondatagram: undefined,
     onheaders: undefined,
     ontrailers: undefined,
     oninfo: undefined,
@@ -1776,6 +1789,29 @@ class QuicStream {
     }
   }
 
+  /**
+   * The callback invoked when an HTTP/3 datagram (RFC 9297) associated with
+   * this stream is received. Read/write.
+   * @type {OnStreamDatagramCallback}
+   */
+  get ondatagram() {
+    assertIsQuicStream(this);
+    return this.#inner.ondatagram;
+  }
+
+  set ondatagram(fn) {
+    assertIsQuicStream(this);
+    const inner = this.#inner;
+    if (fn === undefined) {
+      inner.ondatagram = undefined;
+      inner.state.wantsDatagram = false;
+    } else {
+      validateFunction(fn, 'ondatagram');
+      inner.ondatagram = FunctionPrototypeBind(fn, this);
+      inner.state.wantsDatagram = true;
+    }
+  }
+
   /** @type {OnHeadersCallback} */
   get onheaders() {
     assertIsQuicStream(this);
@@ -2429,6 +2465,48 @@ class QuicStream {
     this.#handle.resetStream(BigInt(code));
   }
 
+  /**
+   * Sends an HTTP/3 datagram (RFC 9297) associated with this stream. The
+   * payload is framed with the stream's Quarter Stream ID by the C++ layer
+   * before being queued for transmission.
+   *
+   * Datagrams are unreliable: they may be lost, reordered, or dropped if too
+   * large or if datagrams were not negotiated. In any such case `0n` is
+   * returned and the payload is silently discarded. Otherwise the underlying
+   * QUIC datagram id is returned.
+   * @param {ArrayBufferView|string} datagram The datagram payload.
+   * @param {string} [encoding] The encoding to use if datagram is a string.
+   * @returns {bigint} The datagram id, or `0n` if it was not sent.
+   */
+  sendDatagram(datagram, encoding = 'utf8') {
+    assertIsQuicStream(this);
+    if (this.destroyed || this.pending) return kNilDatagramId;
+
+    // Datagrams are gated by the session's negotiated max datagram size.
+    // A value of 0 means datagrams are disabled (transport or, for HTTP/3,
+    // the peer's SETTINGS_H3_DATAGRAM). The C++ layer enforces the exact
+    // limit including the Quarter Stream ID prefix.
+    if (getQuicSessionState(this.#inner.session).maxDatagramSize === 0) {
+      return kNilDatagramId;
+    }
+
+    if (typeof datagram === 'string') {
+      datagram = new Uint8Array(Buffer.from(datagram, encoding));
+    } else if (!isArrayBufferView(datagram)) {
+      throw new ERR_INVALID_ARG_TYPE('datagram',
+                                     ['ArrayBufferView', 'string'],
+                                     datagram);
+    }
+
+    const length = isDataView(datagram) ?
+      DataViewPrototypeGetByteLength(datagram) :
+      TypedArrayPrototypeGetByteLength(datagram);
+
+    const id = this.#handle.sendDatagram(datagram);
+    debug(`stream datagram ${id} sent with ${length} bytes`);
+    return id;
+  }
+
   /**
    * The priority of the stream. If the stream is destroyed or if
    * the session does not support priority, `null` will be
@@ -2538,6 +2616,7 @@ class QuicStream {
     inner.pendingClose.resolve = undefined;
     inner.onblocked = undefined;
     inner.onreset = undefined;
+    inner.ondatagram = undefined;
     inner.onheaders = undefined;
     inner.onerror = undefined;
     inner.ontrailers = undefined;
@@ -2591,6 +2670,14 @@ class QuicStream {
     safeCallbackInvoke(inner.onreset, this, error);
   }
 
+  [kDatagram](u8, early) {
+    const inner = this.#inner;
+    assert(typeof inner.ondatagram === 'function',
+           'Unexpected stream datagram event');
+    if (inner.session === undefined) return;
+    safeCallbackInvoke(inner.ondatagram, this, u8, early);
+  }
+
   [kHeaders](headers, kind) {
     const block = parseHeaderPairs(headers);
     const kindName = kHeadersKindName[kind] ?? kind;
@@ -3359,6 +3446,13 @@ class QuicSession {
       throw new ERR_INVALID_STATE('Session is closed');
     }
 
+    // HTTP/3 sessions must use HTTP/3 datagrams
+    if (this.#inner.state.applicationType === kApplicationTypeHttp3) {
+      throw new ERR_INVALID_STATE(
+        'Raw datagrams are not supported on HTTP/3 sessions; ' +
+        'use stream.sendDatagram() instead');
+    }
+
     const maxDatagramSize = this.#inner.state.maxDatagramSize;
 
     // The peer max datagram size is either unknown or they have explicitly
diff --git a/lib/internal/quic/state.js b/lib/internal/quic/state.js
index 22763c1df31b68..753b9b6270eab0 100644
--- a/lib/internal/quic/state.js
+++ b/lib/internal/quic/state.js
@@ -102,6 +102,7 @@ const {
   IDX_STATE_STREAM_WANTS_HEADERS,
   IDX_STATE_STREAM_WANTS_RESET,
   IDX_STATE_STREAM_WANTS_TRAILERS,
+  IDX_STATE_STREAM_WANTS_DATAGRAM,
   IDX_STATE_STREAM_RECEIVED_EARLY_DATA,
   IDX_STATE_STREAM_WRITE_DESIRED_SIZE,
   IDX_STATE_STREAM_HIGH_WATER_MARK,
@@ -143,6 +144,7 @@ assert(IDX_STATE_STREAM_WANTS_BLOCK !== undefined);
 assert(IDX_STATE_STREAM_WANTS_HEADERS !== undefined);
 assert(IDX_STATE_STREAM_WANTS_RESET !== undefined);
 assert(IDX_STATE_STREAM_WANTS_TRAILERS !== undefined);
+assert(IDX_STATE_STREAM_WANTS_DATAGRAM !== undefined);
 assert(IDX_STATE_STREAM_WRITE_DESIRED_SIZE !== undefined);
 assert(IDX_STATE_STREAM_RESET_CODE !== undefined);
 
@@ -798,6 +800,20 @@ class QuicStreamState {
     DataViewPrototypeSetUint8(handle, this.#offset + IDX_STATE_STREAM_WANTS_BLOCK, val ? 1 : 0);
   }
 
+  /** @type {boolean} */
+  get wantsDatagram() {
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_STREAM_WANTS_DATAGRAM) !== 0;
+  }
+
+  /** @type {boolean} */
+  set wantsDatagram(val) {
+    const handle = this.#handle;
+    if (handle === undefined) return;
+    DataViewPrototypeSetUint8(handle, this.#offset + IDX_STATE_STREAM_WANTS_DATAGRAM, val ? 1 : 0);
+  }
+
   /** @type {boolean} */
   get wantsHeaders() {
     const handle = this.#handle;
@@ -905,6 +921,7 @@ class QuicStreamState {
       wantsReset,
       wantsHeaders,
       wantsTrailers,
+      wantsDatagram,
       early,
       resetCode,
       writeDesiredSize,
@@ -925,6 +942,7 @@ class QuicStreamState {
       wantsReset,
       wantsHeaders,
       wantsTrailers,
+      wantsDatagram,
       early,
       resetCode,
       writeDesiredSize,
@@ -961,6 +979,7 @@ class QuicStreamState {
       wantsReset,
       wantsHeaders,
       wantsTrailers,
+      wantsDatagram,
       early,
       resetCode,
       writeDesiredSize,
@@ -981,6 +1000,7 @@ class QuicStreamState {
       wantsReset,
       wantsHeaders,
       wantsTrailers,
+      wantsDatagram,
       early,
       resetCode,
       writeDesiredSize,
diff --git a/src/quic/application.cc b/src/quic/application.cc
index ce5d5e12154d8a..cfbdcef4754901 100644
--- a/src/quic/application.cc
+++ b/src/quic/application.cc
@@ -203,6 +203,15 @@ bool Session::Application::AcknowledgeStreamData(stream_id id, size_t datalen) {
   return true;
 }
 
+void Session::Application::ReceiveDatagram(
+    const uint8_t* data,
+    size_t datalen,
+    const Session::DatagramReceivedFlags& flags) {
+  // Raw QUIC applications have no datagram framing: deliver the payload
+  // verbatim to the session-level ondatagram handler.
+  session().DeliverRawDatagram(data, datalen, flags);
+}
+
 void Session::Application::CollectSessionTicketAppData(
     SessionTicket::AppData* app_data) const {
   // By default, write just the application type byte.
diff --git a/src/quic/application.h b/src/quic/application.h
index 0df9b9f0a0e68d..9e457b33f05e00 100644
--- a/src/quic/application.h
+++ b/src/quic/application.h
@@ -214,6 +214,23 @@ class Session::Application : public MemoryRetainer {
   // do not support headers should return false (the default).
   virtual bool SupportsHeaders() const { return false; }
 
+  // Returns true if the application protocol supports a custom datagrams
+  // format, e.g. HTTP/3 datagrams bound to a request stream.
+  virtual bool SupportsDatagrams() const { return false; }
+
+  // Called when a QUIC DATAGRAM frame is received, so that custom formats
+  // can be handled by the Application.
+  virtual void ReceiveDatagram(const uint8_t* data,
+                               size_t datalen,
+                               const Session::DatagramReceivedFlags& flags);
+
+  // Sends a datagram associated with the given stream. Applications that do
+  // not support stream-bound datagrams return 0. Returns the underlying QUIC
+  // datagram id, or 0 if the datagram was not queued.
+  virtual datagram_id SendDatagram(Stream* stream, Store&& payload) {
+    return 0;
+  }
+
   // Initiates application-level graceful shutdown signaling (e.g.,
   // HTTP/3 GOAWAY). Called when Session::Close(GRACEFUL) is invoked.
   virtual void BeginShutdown() {}
diff --git a/src/quic/bindingdata.h b/src/quic/bindingdata.h
index 7879220e02b482..c71a640b611892 100644
--- a/src/quic/bindingdata.h
+++ b/src/quic/bindingdata.h
@@ -58,6 +58,7 @@ class SessionManager;
   V(stream_blocked, StreamBlocked)                                             \
   V(stream_close, StreamClose)                                                 \
   V(stream_created, StreamCreated)                                             \
+  V(stream_datagram, StreamDatagram)                                           \
   V(stream_drain, StreamDrain)                                                 \
   V(stream_headers, StreamHeaders)                                             \
   V(stream_reset, StreamReset)                                                 \
diff --git a/src/quic/http3.cc b/src/quic/http3.cc
index bc479f96990577..ea529c5ba9a232 100644
--- a/src/quic/http3.cc
+++ b/src/quic/http3.cc
@@ -145,6 +145,7 @@ class Http3ApplicationImpl final : public Session::Application {
       : Application(session, options),
         allocator_(BindingData::Get(env()).nghttp3_allocator()),
         options_(options),
+        local_datagrams_enabled_(options.enable_datagrams),
         conn_(nullptr) {
     // Build the ORIGIN frame payload from the SNI configuration before
     // creating the nghttp3 connection, since InitializeConnection needs
@@ -202,6 +203,16 @@ class Http3ApplicationImpl final : public Session::Application {
 
   bool SupportsHeaders() const override { return true; }
 
+  // HTTP/3 datagrams (RFC 9297 Section 2.1.1) MUST NOT be sent until
+  // SETTINGS_H3_DATAGRAM has been "both sent and received with a value of 1",
+  // and the transport negotiated a non-zero max_datagram_frame_size.
+  // We don't support 0RTT for datagrams here - that would require the client
+  // to persist the previous SETTINGS to know if it's allowed first.
+  bool SupportsDatagrams() const override {
+    return local_datagrams_enabled_ && peer_datagrams_enabled_ &&
+           session().max_datagram_size() > 0;
+  }
+
   bool is_started() const override { return started_; }
 
   bool Start() override {
@@ -394,6 +405,76 @@ class Http3ApplicationImpl final : public Session::Application {
     nghttp3_conn_unblock_stream(*this, stream->id());
   }
 
+  datagram_id SendDatagram(Stream* stream, Store&& payload) override {
+    if (!SupportsDatagrams()) return 0;
+
+    // HTTP/3 datagrams can only ever be associated with client-initiated
+    // bidi streams (requests). Those ids are always divisible by 4, and
+    // sent /4 in the framing itself.
+    stream_id id = stream->id();
+    if (id < 0 || id % 4 != 0) return 0;
+    uint64_t qsid = static_cast<uint64_t>(id) / 4;
+
+    size_t prefix_len = nghttp3_put_uvarintlen(qsid);
+    uv_buf_t buf = payload;
+    size_t total = prefix_len + buf.len;
+
+    // Framed datagram must fit in the peer's maximum datagram size.
+    if (total > session().max_datagram_size()) {
+      Debug(&session(),
+            "Ignoring oversized HTTP/3 datagram (%zu > %u)",
+            total,
+            session().max_datagram_size());
+      return 0;
+    }
+
+    JS_TRY_ALLOCATE_BACKING_OR_RETURN(env(), backing, total, 0);
+    uint8_t* dest = static_cast<uint8_t*>(backing->Data());
+    nghttp3_put_uvarint(dest, qsid);
+    // N.b. HTTP/3 Datagram payloads can be empty (RFC 9297).
+    if (buf.len > 0) memcpy(dest + prefix_len, buf.base, buf.len);
+    return session().SendDatagram(Store(std::move(backing), total));
+  }
+
+  void ReceiveDatagram(const uint8_t* data,
+                       size_t datalen,
+                       const Session::DatagramReceivedFlags& flags) override {
+    if (!local_datagrams_enabled_ || datalen == 0) return;
+
+    size_t qsid_len = nghttp3_get_uvarintlen(data);
+    if (qsid_len > datalen) {
+      Debug(&session(), "Dropping malformed HTTP/3 datagram");
+      return;
+    }
+    uint64_t qsid = 0;
+    nghttp3_get_uvarint(&qsid, data);
+
+    const uint8_t* body = data + qsid_len;
+    size_t bodylen = datalen - qsid_len;
+
+    static constexpr uint64_t kMaxStreamId = (1ULL << 62) - 1;
+    if (qsid > (kMaxStreamId >> 2)) {
+      Debug(&session(), "Dropping HTTP/3 datagram with out-of-range stream id");
+      return;
+    }
+    stream_id id = static_cast<stream_id>(qsid * 4);
+
+    auto stream = session().FindStream(id);
+    if (!stream) {
+      Debug(&session(),
+            "Dropping HTTP/3 datagram for unknown stream %" PRIi64,
+            id);
+      return;
+    }
+
+    session().IncrementDatagramsReceived();
+
+    // The payload may be empty (RFC 9297); a zero-length backing is fine.
+    JS_TRY_ALLOCATE_BACKING(env(), backing, bodylen);
+    if (bodylen > 0) memcpy(backing->Data(), body, bodylen);
+    stream->EmitDatagram(Store(std::move(backing), bodylen), flags.early);
+  }
+
   void CollectSessionTicketAppData(
       SessionTicket::AppData* app_data) const override {
     uint8_t buf[kSessionTicketAppDataSize];
@@ -1003,7 +1084,9 @@ class Http3ApplicationImpl final : public Session::Application {
     options_.qpack_blocked_streams = settings->qpack_blocked_streams;
     options_.qpack_max_dtable_capacity = settings->qpack_max_dtable_capacity;
 
-    // Per RFC 9297 §3, an H3 endpoint MUST NOT send HTTP Datagrams
+    peer_datagrams_enabled_ = settings->h3_datagram != 0;
+
+    // Per RFC 9297 Section 3, an H3 endpoint MUST NOT send HTTP Datagrams
     // unless the peer indicated support via SETTINGS_H3_DATAGRAM=1.
     // If the peer disabled it, set the session's max datagram size to 0
     // which blocks sends at the existing JS/C++ check.
@@ -1021,6 +1104,8 @@ class Http3ApplicationImpl final : public Session::Application {
   bool started_ = false;
   nghttp3_mem* allocator_;
   Options options_;
+  const bool local_datagrams_enabled_;
+  bool peer_datagrams_enabled_ = false;
   Http3ConnectionPointer conn_;
   stream_id control_stream_id_ = -1;
   stream_id qpack_dec_stream_id_ = -1;
diff --git a/src/quic/session.cc b/src/quic/session.cc
index 8380e477c01e80..f9724e9325a3a0 100644
--- a/src/quic/session.cc
+++ b/src/quic/session.cc
@@ -1155,6 +1155,12 @@ struct Session::Impl final : public MemoryRetainer {
       return THROW_ERR_INVALID_STATE(env, "Session is destroyed");
     }
 
+    // On HTTP/3 sessions, raw unframed session-level datagrams are invalid
+    if (session->has_application() &&
+        session->application().type() == Session::Application::Type::HTTP3) {
+      return args.GetReturnValue().Set(BigInt::New(env->isolate(), 0));
+    }
+
     DCHECK(args[0]->IsArrayBufferView());
     session->impl_->handshake_deferred_ = false;
     SendPendingDataScope send_scope(session);
@@ -3251,6 +3257,16 @@ void Session::DatagramReceived(const uint8_t* data,
                                size_t datalen,
                                DatagramReceivedFlags flag) {
   DCHECK(!is_destroyed());
+  if (datalen == 0 || !has_application()) return;
+
+  // Dispatch through the application for protocol-specific framing
+  application().ReceiveDatagram(data, datalen, flag);
+}
+
+void Session::DeliverRawDatagram(const uint8_t* data,
+                                 size_t datalen,
+                                 DatagramReceivedFlags flag) {
+  DCHECK(!is_destroyed());
   // If there is nothing watching for the datagram on the JavaScript side,
   // or if the datagram is zero-length, we just drop it on the floor.
   if (!HasListenerFlag(impl_->state()->listener_flags,
@@ -3266,6 +3282,10 @@ void Session::DatagramReceived(const uint8_t* data,
   EmitDatagram(Store(std::move(backing), datalen), flag);
 }
 
+void Session::IncrementDatagramsReceived() {
+  STAT_INCREMENT(Stats, datagrams_received);
+}
+
 void Session::GenerateNewConnectionId(ngtcp2_cid* cid,
                                       size_t len,
                                       ngtcp2_stateless_reset_token* token) {
@@ -3480,6 +3500,11 @@ void Session::set_max_datagram_size(uint16_t size) {
   }
 }
 
+uint16_t Session::max_datagram_size() const {
+  if (is_destroyed()) return 0;
+  return impl_->state()->max_datagram_size;
+}
+
 void Session::EmitGoaway(stream_id last_stream_id) {
   if (is_destroyed()) return;
   if (!env()->can_call_into_js()) return;
diff --git a/src/quic/session.h b/src/quic/session.h
index 0caeb764ba56c8..814ec892f45788 100644
--- a/src/quic/session.h
+++ b/src/quic/session.h
@@ -592,6 +592,10 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
   // Http3ApplicationImpl to block datagram sends when the peer's
   // SETTINGS_H3_DATAGRAM=0 (RFC 9297 §3).
   void set_max_datagram_size(uint16_t size);
+  // The current maximum datagram payload the peer will accept, or 0 if
+  // datagrams are not usable (transport datagrams not negotiated, or the
+  // peer disabled SETTINGS_H3_DATAGRAM).
+  uint16_t max_datagram_size() const;
   void EmitDatagram(Store&& datagram, DatagramReceivedFlags flag);
   void EmitDatagramStatus(datagram_id id, DatagramStatus status);
   void EmitHandshakeComplete();
@@ -620,6 +624,10 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
   void DatagramReceived(const uint8_t* data,
                         size_t datalen,
                         DatagramReceivedFlags flag);
+  void DeliverRawDatagram(const uint8_t* data,
+                          size_t datalen,
+                          DatagramReceivedFlags flag);
+  void IncrementDatagramsReceived();
   void GenerateNewConnectionId(ngtcp2_cid* cid,
                                size_t len,
                                ngtcp2_stateless_reset_token* token);
diff --git a/src/quic/streams.cc b/src/quic/streams.cc
index e838392361f946..4c5ca9c00f7a80 100644
--- a/src/quic/streams.cc
+++ b/src/quic/streams.cc
@@ -25,6 +25,7 @@ using v8::ArrayBufferView;
 using v8::BackingStore;
 using v8::BackingStoreInitializationMode;
 using v8::BigInt;
+using v8::Boolean;
 using v8::FunctionCallbackInfo;
 using v8::Global;
 using v8::HandleScope;
@@ -63,6 +64,8 @@ namespace quic {
   V(WANTS_RESET, wants_reset, uint8_t)                                         \
   /* Set when the stream has a trailers event handler */                       \
   V(WANTS_TRAILERS, wants_trailers, uint8_t)                                   \
+  /* Set when the stream has a datagram event handler (RFC 9297) */            \
+  V(WANTS_DATAGRAM, wants_datagram, uint8_t)                                   \
   /* True when 0-RTT early data was received */                                \
   V(RECEIVED_EARLY_DATA, received_early_data, uint8_t)                         \
   V(WRITE_DESIRED_SIZE, write_desired_size, uint32_t)                          \
@@ -104,7 +107,8 @@ namespace quic {
   V(GetReader, getReader, false)                                               \
   V(InitStreamingSource, initStreamingSource, false)                           \
   V(Write, write, false)                                                       \
-  V(EndWrite, endWrite, false)
+  V(EndWrite, endWrite, false)                                                 \
+  V(SendDatagram, sendDatagram, false)
 
 // ============================================================================
 // RecvAccumulator implementation
@@ -604,6 +608,31 @@ struct Stream::Impl {
     ASSIGN_OR_RETURN_UNWRAP(&stream, args.This());
     stream->EndWriting();
   }
+
+  // Sends an HTTP/3 datagram (RFC 9297) associated with this stream. Returns
+  // the underlying QUIC datagram id, or 0n if the datagram was not queued.
+  JS_METHOD(SendDatagram) {
+    auto env = Environment::GetCurrent(args);
+    Stream* stream;
+    ASSIGN_OR_RETURN_UNWRAP(&stream, args.This());
+    DCHECK(args[0]->IsArrayBufferView());
+
+    // A datagram can only be associated with a stream that has a real id.
+    // A pending stream has no id yet, so there is nothing to bind to.
+    if (stream->is_pending()) {
+      return args.GetReturnValue().Set(BigInt::New(env->isolate(), 0));
+    }
+
+    Store store;
+    if (!Store::From(args[0].As<ArrayBufferView>()).To(&store)) {
+      return;
+    }
+
+    Session::SendPendingDataScope send_scope(&stream->session());
+    datagram_id id =
+        stream->session().application().SendDatagram(stream, std::move(store));
+    args.GetReturnValue().Set(BigInt::New(env->isolate(), id));
+  }
 };
 
 // ============================================================================
@@ -1836,6 +1865,21 @@ void Stream::EmitBlocked() {
   MakeCallback(BindingData::Get(env()).stream_blocked_callback(), 0, nullptr);
 }
 
+void Stream::EmitDatagram(Store&& payload, bool early) {
+  // state()->wants_datagram is set from the JavaScript side when an ondatagram
+  // handler is attached to the stream. Drop datagrams without a handler.
+  if (!env()->can_call_into_js() || !state()->wants_datagram) {
+    return;
+  }
+  Debug(this, "Emitting %zu-byte datagram", payload.length());
+  CallbackScope<Stream> cb_scope(this);
+  Local<Value> argv[] = {payload.ToUint8Array(env()),
+                         Boolean::New(env()->isolate(), early)};
+  MakeCallback(BindingData::Get(env()).stream_datagram_callback(),
+               arraysize(argv),
+               argv);
+}
+
 void Stream::EmitDrain() {
   if (!env()->can_call_into_js()) return;
   CallbackScope<Stream> cb_scope(this);
diff --git a/src/quic/streams.h b/src/quic/streams.h
index 86cb36b2668985..e6776a6e2742ed 100644
--- a/src/quic/streams.h
+++ b/src/quic/streams.h
@@ -412,6 +412,8 @@ class Stream final : public AsyncWrap,
   // blocked because of flow control restriction.
   void EmitBlocked();
 
+  void EmitDatagram(Store&& payload, bool early);
+
   // Notifies the JavaScript side that the outbound buffer has capacity
   // for more data. Fires when write_desired_size transitions from 0 to > 0.
   void EmitDrain();
diff --git a/test/parallel/test-quic-h3-datagram.mjs b/test/parallel/test-quic-h3-datagram.mjs
index ea00cec42bc8f4..60bbb77e978013 100644
--- a/test/parallel/test-quic-h3-datagram.mjs
+++ b/test/parallel/test-quic-h3-datagram.mjs
@@ -1,18 +1,23 @@
 // Flags: --experimental-quic --experimental-stream-iter --no-warnings
 
-// Test: HTTP/3 datagrams with SETTINGS_H3_DATAGRAM negotiation.
-// Verifies that QUIC datagrams work correctly with H3 sessions, including
-// the SETTINGS_H3_DATAGRAM negotiation required by RFC 9297.
-// 1. Both sides enableDatagrams: true — datagrams work alongside H3 streams
-// 2. Server enableDatagrams: false — client should not be able to send
-//    datagrams (peer's SETTINGS_H3_DATAGRAM=0)
+// Test: HTTP/3 datagrams (RFC 9297) bound to a request stream.
+//
+// On HTTP/3 sessions a QUIC DATAGRAM frame carries an HTTP/3 Datagram: a
+// Quarter Stream ID varint (the request stream id divided by four) followed
+// by the payload. Datagrams are therefore sent and received per-stream via
+// stream.sendDatagram() / stream.ondatagram rather than at the session level.
+//
+// 1. Both sides enableDatagrams: true - a datagram round-trips on a stream.
+// 2. Server enableDatagrams: false - the client's stream.sendDatagram() returns
+//    0n (the peer's SETTINGS_H3_DATAGRAM=0 disables them).
+// 3. Raw session.sendDatagram() is rejected on an HTTP/3 session.
 
 import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs';
 import assert from 'node:assert';
 import * as fixtures from '../common/fixtures.mjs';
 const { readKey } = fixtures;
 
-const { ok, strictEqual } = assert;
+const { ok, strictEqual, deepStrictEqual, rejects } = assert;
 
 if (!hasQuic) {
   skip('QUIC is not enabled');
@@ -20,47 +25,41 @@ if (!hasQuic) {
 
 const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
-const { bytes } = await import('stream/iter');
-const { setTimeout: sleep } = await import('timers/promises');
 
 const key = createPrivateKey(readKey('agent1-key.pem'));
 const cert = readKey('agent1-cert.pem');
-const decoder = new TextDecoder();
 
-// Test 1: H3 datagrams with enableDatagrams: true on both sides.
-// Datagrams work alongside H3 request/response.
+// Test 1: a datagram round-trips on a request stream.
 {
   const serverGotDatagram = Promise.withResolvers();
   const clientGotDatagram = Promise.withResolvers();
   const serverDone = Promise.withResolvers();
 
   const serverEndpoint = await listen(mustCall(async (ss) => {
-    ss.onstream = mustCall(async (stream) => {
-      await stream.closed;
+    ss.onstream = mustCall((stream) => {
+      stream.ondatagram = mustCall((data, early) => {
+        ok(data instanceof Uint8Array);
+        deepStrictEqual([...data], [10, 20, 30]);
+        strictEqual(early, false);
+        // Echo a different payload back on the same stream.
+        const id = stream.sendDatagram(new Uint8Array([42, 43, 44]));
+        ok(id > 0n);
+        serverGotDatagram.resolve();
+      });
     });
     await serverGotDatagram.promise;
-    await sleep(50);
+    await clientGotDatagram.promise;
     ss.close();
     serverDone.resolve();
   }), {
     sni: { '*': { keys: [key], certs: [cert] } },
     application: { enableDatagrams: true },
     transportParams: { maxDatagramFrameSize: 100 },
-    // Server echoes received datagram back to client.
-    ondatagram: mustCall(function(data) {
-      ok(data instanceof Uint8Array);
-      strictEqual(data.byteLength, 3);
-      strictEqual(data[0], 10);
-      strictEqual(data[1], 20);
-      strictEqual(data[2], 30);
-      // Echo it back.
-      this.sendDatagram(new Uint8Array([42, 43, 44]));
-      serverGotDatagram.resolve();
-    }),
-    onheaders: mustCall(function(headers) {
+    // Raw session-level datagrams must never be delivered on an H3 session.
+    ondatagram: mustNotCall(),
+    onheaders: mustCall(function() {
+      // Reply with headers only; keep the stream open.
       this.sendHeaders({ ':status': '200' });
-      this.writer.writeSync('ok');
-      this.writer.endSync();
     }),
   });
 
@@ -69,19 +68,11 @@ const decoder = new TextDecoder();
     verifyPeer: 'manual',
     application: { enableDatagrams: true },
     transportParams: { maxDatagramFrameSize: 100 },
-    // Client receives datagram from server.
-    ondatagram: mustCall(function(data) {
-      ok(data instanceof Uint8Array);
-      strictEqual(data.byteLength, 3);
-      strictEqual(data[0], 42);
-      strictEqual(data[1], 43);
-      strictEqual(data[2], 44);
-      clientGotDatagram.resolve();
-    }),
+    ondatagram: mustNotCall(),
   });
   await clientSession.opened;
 
-  // Datagrams work alongside H3 request/response.
+  const responseHeaders = Promise.withResolvers();
   const stream = await clientSession.createBidirectionalStream({
     headers: {
       ':method': 'GET',
@@ -91,50 +82,55 @@ const decoder = new TextDecoder();
     },
     onheaders: mustCall(function(headers) {
       strictEqual(headers[':status'], '200');
+      responseHeaders.resolve();
     }),
   });
+  stream.ondatagram = mustCall((data, early) => {
+    ok(data instanceof Uint8Array);
+    deepStrictEqual([...data], [42, 43, 44]);
+    strictEqual(early, false);
+    clientGotDatagram.resolve();
+  });
 
-  // Send datagram from client.
-  await clientSession.sendDatagram(new Uint8Array([10, 20, 30]));
-
-  // H3 response body is received.
-  const body = await bytes(stream);
-  strictEqual(decoder.decode(body), 'ok');
-  await stream.closed;
+  // Wait for the response headers so the server-side stream exists to
+  // associate the datagram with, then send.
+  await responseHeaders.promise;
+  const id = stream.sendDatagram(new Uint8Array([10, 20, 30]));
+  ok(id > 0n);
 
-  // Both sides received their datagram.
   await Promise.all([serverGotDatagram.promise, clientGotDatagram.promise]);
 
+  // The client received exactly one datagram (the server's echo); the HTTP/3
+  // receive path must count it in the datagrams_received stat.
+  strictEqual(clientSession.stats.datagramsReceived, 1n);
+
+  stream.destroy();
+
   await serverDone.promise;
   await clientSession.close();
   await serverEndpoint.close();
 }
 
-// Test 2: Server has enableDatagrams: false. The peer's H3 SETTINGS
-// should indicate SETTINGS_H3_DATAGRAM=0. The client's datagram send
-// should return 0 (no datagram sent) because the peer doesn't support
-// H3 datagrams.
+// Test 2: with the server's SETTINGS_H3_DATAGRAM=0, the client's
+// stream.sendDatagram() returns 0n and the server receives nothing.
 {
   const serverDone = Promise.withResolvers();
 
   const serverEndpoint = await listen(mustCall(async (ss) => {
-    ss.onstream = mustCall(async (stream) => {
-      await stream.closed;
-      ss.close();
-      serverDone.resolve();
+    ss.onstream = mustCall((stream) => {
+      // The server must never receive an H3 datagram.
+      stream.ondatagram = mustNotCall();
     });
+    await serverDone.promise;
+    ss.close();
   }), {
     sni: { '*': { keys: [key], certs: [cert] } },
-    // Server explicitly disables H3 datagrams.
+    // The server disables H3 datagrams...
     application: { enableDatagrams: false },
-    // But transport-level datagrams ARE supported.
+    // ...even though transport-level datagrams are supported.
     transportParams: { maxDatagramFrameSize: 100 },
-    // Server should NOT receive any datagrams.
-    ondatagram: mustNotCall(),
-    onheaders: mustCall((headers, stream) => {
-      stream.sendHeaders({ ':status': '200' });
-      stream.writer.writeSync('no-dgram');
-      stream.writer.endSync();
+    onheaders: mustCall(function() {
+      this.sendHeaders({ ':status': '200' });
     }),
   });
 
@@ -146,6 +142,7 @@ const decoder = new TextDecoder();
   });
   await clientSession.opened;
 
+  const responseHeaders = Promise.withResolvers();
   const stream = await clientSession.createBidirectionalStream({
     headers: {
       ':method': 'GET',
@@ -153,23 +150,183 @@ const decoder = new TextDecoder();
       ':scheme': 'https',
       ':authority': 'localhost',
     },
-    onheaders: mustCall((headers) => {
+    onheaders: mustCall(function(headers) {
+      strictEqual(headers[':status'], '200');
+      responseHeaders.resolve();
+    }),
+  });
+
+  // After the response headers arrive the server's SETTINGS (h3_datagram=0)
+  // have been processed, so a datagram send is not possible.
+  await responseHeaders.promise;
+  strictEqual(stream.sendDatagram(new Uint8Array([1, 2, 3])), 0n);
+
+  stream.destroy();
+  serverDone.resolve();
+  await clientSession.close();
+  await serverEndpoint.close();
+}
+
+// Test 3: raw session-level datagrams are rejected on an HTTP/3 session.
+{
+  const serverDone = Promise.withResolvers();
+  const serverEndpoint = await listen(mustCall(async (ss) => {
+    // Accept the request stream so the response (and SETTINGS) flow.
+    ss.onstream = mustCall((stream) => stream);
+    await serverDone.promise;
+    ss.close();
+  }), {
+    sni: { '*': { keys: [key], certs: [cert] } },
+    application: { enableDatagrams: true },
+    transportParams: { maxDatagramFrameSize: 100 },
+    onheaders: mustCall(function() {
+      this.sendHeaders({ ':status': '200' });
+    }),
+  });
+
+  const clientSession = await connect(serverEndpoint.address, {
+    servername: 'localhost',
+    verifyPeer: 'manual',
+    application: { enableDatagrams: true },
+    transportParams: { maxDatagramFrameSize: 100 },
+  });
+  await clientSession.opened;
+
+  // Issue a request so the HTTP/3 application is fully established before
+  // exercising the (blocked) raw datagram path.
+  const responseHeaders = Promise.withResolvers();
+  const stream = await clientSession.createBidirectionalStream({
+    headers: {
+      ':method': 'GET',
+      ':path': '/',
+      ':scheme': 'https',
+      ':authority': 'localhost',
+    },
+    onheaders: mustCall(() => responseHeaders.resolve()),
+  });
+  await responseHeaders.promise;
+
+  await rejects(clientSession.sendDatagram(new Uint8Array([1, 2, 3])), {
+    code: 'ERR_INVALID_STATE',
+  });
+
+  stream.destroy();
+  serverDone.resolve();
+  await clientSession.close();
+  await serverEndpoint.close();
+}
+
+// Test 4: the SENDER must also have advertised SETTINGS_H3_DATAGRAM=1.
+// Per RFC 9297 Section 2.1.1 a datagram MUST NOT be sent until the setting
+// has been both sent and received. Here the client (sender) disabled
+// datagrams while the server enabled them, so the client cannot send even
+// though the peer accepts them.
+{
+  const serverDone = Promise.withResolvers();
+
+  const serverEndpoint = await listen(mustCall(async (ss) => {
+    ss.onstream = mustCall((stream) => {
+      stream.ondatagram = mustNotCall();
+    });
+    await serverDone.promise;
+    ss.close();
+  }), {
+    sni: { '*': { keys: [key], certs: [cert] } },
+    // The server enables H3 datagrams...
+    application: { enableDatagrams: true },
+    transportParams: { maxDatagramFrameSize: 100 },
+    onheaders: mustCall(function() {
+      this.sendHeaders({ ':status': '200' });
+    }),
+  });
+
+  const clientSession = await connect(serverEndpoint.address, {
+    servername: 'localhost',
+    verifyPeer: 'manual',
+    // ...but the client (the sender) did not advertise support.
+    application: { enableDatagrams: false },
+    transportParams: { maxDatagramFrameSize: 100 },
+  });
+  await clientSession.opened;
+
+  const responseHeaders = Promise.withResolvers();
+  const stream = await clientSession.createBidirectionalStream({
+    headers: {
+      ':method': 'GET',
+      ':path': '/no-send',
+      ':scheme': 'https',
+      ':authority': 'localhost',
+    },
+    onheaders: mustCall(function(headers) {
       strictEqual(headers[':status'], '200');
+      responseHeaders.resolve();
+    }),
+  });
+
+  await responseHeaders.promise;
+  // The peer accepts datagrams, but we never advertised, so we cannot send.
+  strictEqual(stream.sendDatagram(new Uint8Array([1, 2, 3])), 0n);
+
+  stream.destroy();
+  serverDone.resolve();
+  await clientSession.close();
+  await serverEndpoint.close();
+}
+
+// Test 5: a zero-length HTTP Datagram Payload is valid (RFC 9297, "Note that
+// this field can be empty") and must round-trip rather than be dropped.
+{
+  const serverGotDatagram = Promise.withResolvers();
+  const serverDone = Promise.withResolvers();
+
+  const serverEndpoint = await listen(mustCall(async (ss) => {
+    ss.onstream = mustCall((stream) => {
+      stream.ondatagram = mustCall((data) => {
+        ok(data instanceof Uint8Array);
+        strictEqual(data.byteLength, 0);
+        serverGotDatagram.resolve();
+      });
+    });
+    await serverGotDatagram.promise;
+    ss.close();
+    serverDone.resolve();
+  }), {
+    sni: { '*': { keys: [key], certs: [cert] } },
+    application: { enableDatagrams: true },
+    transportParams: { maxDatagramFrameSize: 100 },
+    onheaders: mustCall(function() {
+      this.sendHeaders({ ':status': '200' });
     }),
   });
 
-  // The H3 request triggers SETTINGS exchange. After the server's
-  // SETTINGS (with h3_datagram=0) arrive, the client should know
-  // the peer doesn't support H3 datagrams.
-  const body = await bytes(stream);
-  strictEqual(decoder.decode(body), 'no-dgram');
+  const clientSession = await connect(serverEndpoint.address, {
+    servername: 'localhost',
+    verifyPeer: 'manual',
+    application: { enableDatagrams: true },
+    transportParams: { maxDatagramFrameSize: 100 },
+  });
+  await clientSession.opened;
 
-  // Attempt to send a datagram. Since the peer's H3 SETTINGS
-  // indicate h3_datagram=0, this should return 0 (not sent).
-  const dgId = await clientSession.sendDatagram(new Uint8Array([1, 2, 3]));
-  strictEqual(dgId, 0n);
+  const responseHeaders = Promise.withResolvers();
+  const stream = await clientSession.createBidirectionalStream({
+    headers: {
+      ':method': 'GET',
+      ':path': '/empty-datagram',
+      ':scheme': 'https',
+      ':authority': 'localhost',
+    },
+    onheaders: mustCall(() => responseHeaders.resolve()),
+  });
 
-  await Promise.all([stream.closed, serverDone.promise]);
-  clientSession.close();
+  await responseHeaders.promise;
+  // An empty payload still produces a non-empty wire datagram (the Quarter
+  // Stream ID), so a real datagram id is returned.
+  const id = stream.sendDatagram(new Uint8Array(0));
+  ok(id > 0n);
+
+  await serverGotDatagram.promise;
+  stream.destroy();
+  await serverDone.promise;
+  await clientSession.close();
   await serverEndpoint.close();
 }
diff --git a/test/parallel/test-quic-internal-setcallbacks.mjs b/test/parallel/test-quic-internal-setcallbacks.mjs
index b485b5e9b43457..954c528538fcdf 100644
--- a/test/parallel/test-quic-internal-setcallbacks.mjs
+++ b/test/parallel/test-quic-internal-setcallbacks.mjs
@@ -30,6 +30,7 @@ const callbacks = {
   onSessionVersionNegotiation() {},
   onStreamCreated() {},
   onStreamBlocked() {},
+  onStreamDatagram() {},
   onStreamClose() {},
   onStreamDrain() {},
   onStreamReset() {},
diff --git a/typings/internalBinding/quic.d.ts b/typings/internalBinding/quic.d.ts
index 41acfba0bd438e..cb2341f9e49460 100644
--- a/typings/internalBinding/quic.d.ts
+++ b/typings/internalBinding/quic.d.ts
@@ -20,6 +20,7 @@ interface QuicCallbacks {
                                 supports: number[]) => void;
   onStreamCreated: (stream: Stream) => void;
   onStreamBlocked: () => void;
+  onStreamDatagram: (datagram: Uint8Array, early: boolean) => void;
   onStreamClose: (error: [number,bigint,string]) => void;
   onStreamReset: (error: [number,bigint,string]) => void;
   onStreamHeaders: (headers: string[], kind: number) => void;