From d5c2d526e4f5d4d347cdaa37bb84068f7152bc01 Mon Sep 17 00:00:00 2001
From: Tim Perry <pimterry@gmail.com>
Date: Fri, 11 Sep 2026 17:01:53 +0200
Subject: [PATCH 1/9] quic: add Http3Session, so you can explicitly pick the
 app protocol

Previously, ALPN decided automatically which application protocol
implementation was used. QuicSession was used everywhere, but its
actual behaviour and API changes implicitly based on the wire traffic
involved.

Now, QuicSession is used for pure QUIC only, and Http3Session is used
for HTTP/3 sessions only. To do HTTP/3 on a connection, you enable it
explicitly by wrapping a QUIC session in Http3Session. Doing so
attaches the internal protocol application handling so everything is
HTTP/3 on that session from that point onwards.

For now, this only changes the application selection process and the
top-level APIs involved, but none of the details. In a future PR, we
can introduce Http3Stream and migrate other HTTP/3 specific
functionality (e.g. SETTINGS & GOAWAY handling) out of the QUIC API.

Signed-off-by: Tim Perry <pimterry@gmail.com>
---
 benchmark/quic/h3-request.js                  |  18 +-
 benchmark/quic/handshake.js                   |  15 +-
 doc/api/quic.md                               | 251 ++++++++++++----
 lib/internal/quic/http3.js                    | 269 ++++++++++++++++++
 lib/internal/quic/quic.js                     |  53 +++-
 lib/internal/quic/state.js                    |  43 ++-
 lib/internal/quic/symbols.js                  |   2 +
 lib/quic.js                                   |   5 +
 src/node_builtins.cc                          |   4 +-
 src/quic/README.md                            |  45 ++-
 src/quic/application.cc                       |   3 -
 src/quic/application.h                        |  21 +-
 src/quic/bindingdata.cc                       |  12 +
 src/quic/bindingdata.h                        |   3 +
 src/quic/endpoint.cc                          |   6 +-
 src/quic/http3.cc                             |  50 +++-
 src/quic/http3.h                              |  18 +-
 src/quic/quic.cc                              |   3 +
 src/quic/session.cc                           | 177 ++++++------
 src/quic/session.h                            |  37 +--
 src/quic/tlscontext.cc                        |   4 -
 src/quic/tlscontext.h                         |   2 +-
 test/parallel/test-quic-alpn-h3.mjs           |  26 +-
 test/parallel/test-quic-alpn.mjs              |  10 +
 .../test-quic-certificate-compression.mjs     |   2 +
 .../test-quic-early-selection-order.mjs       |  12 +-
 test/parallel/test-quic-h3-attach.mjs         | 267 +++++++++++++++++
 .../parallel/test-quic-h3-callback-errors.mjs |  44 +--
 test/parallel/test-quic-h3-close-behavior.mjs |  11 +-
 .../test-quic-h3-concurrent-requests.mjs      |  11 +-
 test/parallel/test-quic-h3-datagram.mjs       |  33 ++-
 test/parallel/test-quic-h3-error-codes.mjs    |  20 +-
 .../test-quic-h3-flow-control-volume.mjs      |  11 +-
 test/parallel/test-quic-h3-goaway.mjs         |  10 +-
 .../test-quic-h3-handshake-failure.mjs        |  17 +-
 .../parallel/test-quic-h3-header-interest.mjs |  10 +-
 .../test-quic-h3-header-validation.mjs        |  20 +-
 .../test-quic-h3-informational-headers.mjs    |  11 +-
 ...-maxstreamdata-external-buffer-failure.mjs |  11 +-
 test/parallel/test-quic-h3-origin.mjs         |  18 +-
 test/parallel/test-quic-h3-pending-stream.mjs |  11 +-
 .../parallel/test-quic-h3-post-filehandle.mjs |  11 +-
 test/parallel/test-quic-h3-post-request.mjs   |  11 +-
 test/parallel/test-quic-h3-priority.mjs       |  20 +-
 test/parallel/test-quic-h3-qpack-settings.mjs |  34 ++-
 .../test-quic-h3-request-rejected.mjs         |  11 +-
 .../test-quic-h3-request-response.mjs         |  18 +-
 test/parallel/test-quic-h3-settings.mjs       |  58 ++--
 .../test-quic-h3-status-code-type.mjs         |  11 +-
 test/parallel/test-quic-h3-stream-credit.mjs  |  11 +-
 ...st-quic-h3-stream-destroy-no-resurrect.mjs |  14 +-
 ...st-quic-h3-stream-destroy-with-headers.mjs |  11 +-
 .../test-quic-h3-stream-idle-timeout.mjs      |  29 +-
 .../test-quic-h3-stream-without-onstream.mjs  |  43 ++-
 .../test-quic-h3-trailing-headers.mjs         |  11 +-
 ...quic-h3-uni-stream-limit-start-failure.mjs |  20 +-
 .../test-quic-h3-uni-stream-teardown.mjs      |  26 +-
 .../test-quic-h3-zero-rtt-bogus-ticket.mjs    |   2 +
 ...est-quic-h3-zero-rtt-rejected-settings.mjs |  36 ++-
 test/parallel/test-quic-h3-zero-rtt.mjs       |  16 +-
 ...quic-internal-endpoint-listen-defaults.mjs |   9 +-
 ...est-quic-internal-endpoint-stats-state.mjs |   8 +-
 .../test-quic-session-application-options.mjs | 121 ++++----
 .../test-quic-session-emit-ordering.mjs       |   6 +-
 .../test-quic-session-stream-lifecycle.mjs    |   5 +-
 .../test-quic-zero-rtt-disabled-server.mjs    |   3 +-
 66 files changed, 1581 insertions(+), 560 deletions(-)
 create mode 100644 lib/internal/quic/http3.js
 create mode 100644 test/parallel/test-quic-h3-attach.mjs

diff --git a/benchmark/quic/h3-request.js b/benchmark/quic/h3-request.js
index f96a18407ae1..88fca0225f0e 100644
--- a/benchmark/quic/h3-request.js
+++ b/benchmark/quic/h3-request.js
@@ -22,7 +22,7 @@ const bench = common.createBenchmark(main, {
              '--no-warnings'] });
 
 async function main({ mode, n }) {
-  const { listen, connect } = require('node:quic');
+  const { listen, connect, Http3Session } = require('node:quic');
   const { bytes } = require('stream/iter');
 
   const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
@@ -37,11 +37,13 @@ async function main({ mode, n }) {
     ':authority': 'localhost',
   };
 
-  const endpoint = await listen((session) => {
+  const endpoint = await listen((quicSession) => {
+    const session = new Http3Session(quicSession);
     session.opened.catch(() => {});
     session.closed.catch(() => {});
     session.onstream = (stream) => { stream.closed.catch(() => {}); };
   }, {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     onheaders() {
       this.sendHeaders({ ':status': '200' });
@@ -63,12 +65,12 @@ async function main({ mode, n }) {
   // A full handshake, one request, one response. When resume is supplied the
   // request goes out in the first flight, before the handshake completes.
   async function exchange(resume) {
-    const session = await connect(address, {
+    const session = new Http3Session(await connect(address, {
       servername: 'localhost',
       verifyPeer: 'manual',
       alpn: 'h3',
       ...resume,
-    });
+    }));
     const stream = await session.createBidirectionalStream({
       headers: request,
       onheaders,
@@ -89,7 +91,7 @@ async function main({ mode, n }) {
     const { promise, resolve } = Promise.withResolvers();
     let ticket;
     let token;
-    const session = await connect(address, {
+    const session = new Http3Session(await connect(address, {
       servername: 'localhost',
       verifyPeer: 'manual',
       alpn: 'h3',
@@ -101,7 +103,7 @@ async function main({ mode, n }) {
         token ??= value;
         if (ticket !== undefined) resolve();
       },
-    });
+    }));
     await session.opened;
     await promise;
     session.close();
@@ -115,12 +117,12 @@ async function main({ mode, n }) {
   // otherwise a ticket the server stopped accepting would quietly turn this
   // into a measurement of the 1-RTT path.
   async function checkEarlyDataAccepted() {
-    const session = await connect(address, {
+    const session = new Http3Session(await connect(address, {
       servername: 'localhost',
       verifyPeer: 'manual',
       alpn: 'h3',
       ...resume,
-    });
+    }));
     const stream = await session.createBidirectionalStream({
       headers: request,
       onheaders,
diff --git a/benchmark/quic/handshake.js b/benchmark/quic/handshake.js
index 9f0404008e03..430e6a6e198f 100644
--- a/benchmark/quic/handshake.js
+++ b/benchmark/quic/handshake.js
@@ -11,21 +11,23 @@ const { createPrivateKey } = require('crypto');
 
 const bench = common.createBenchmark(main, {
   // 'raw' negotiates a non-HTTP ALPN and does no application work.
-  // 'h3' negotiates HTTP/3, so the server also builds an nghttp3 connection
-  // and its control/QPACK streams for every session.
+  // 'h3' installs HTTP/3 on every session, so each peer also builds an
+  // nghttp3 connection and its control/QPACK streams.
   protocol: ['raw', 'h3'],
   concurrency: [1, 10],
   n: [1000],
 }, { flags: ['--experimental-quic', '--no-warnings'] });
 
 async function main({ protocol, concurrency, n }) {
-  const { listen, connect } = require('node:quic');
+  const { listen, connect, Http3Session } = require('node:quic');
 
   const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
   const cert = fixtures.readKey('agent1-cert.pem');
-  const alpn = protocol === 'h3' ? 'h3' : 'quic-bench';
+  const http3 = protocol === 'h3';
+  const alpn = http3 ? 'h3' : 'quic-bench';
 
-  const endpoint = await listen((session) => {
+  const endpoint = await listen((quicSession) => {
+    const session = http3 ? new Http3Session(quicSession) : quicSession;
     // A benchmark peer never reads these; swallow so a torn-down session
     // cannot produce an unhandled rejection.
     session.opened.catch(() => {});
@@ -46,11 +48,12 @@ async function main({ protocol, concurrency, n }) {
   const address = endpoint.address;
 
   async function handshake() {
-    const session = await connect(address, {
+    const quicSession = await connect(address, {
       servername: 'localhost',
       verifyPeer: 'manual',
       alpn,
     });
+    const session = http3 ? new Http3Session(quicSession) : quicSession;
     await session.opened;
     session.close();
     await session.closed.catch(() => {});
diff --git a/doc/api/quic.md b/doc/api/quic.md
index bd737ae230f0..832bfafd0f30 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -239,20 +239,20 @@ counter tracks how many packets have been dropped by the filter.
 
 ### Applications
 
-Every `QuicSession` is associated with a single application protocol, negotiated
-via ALPN during the TLS handshake. The `quic` module is designed to be
-application-agnostic in general but includes built-in support for HTTP/3 as a
-specific application protocol. When using HTTP/3, the `quic` module provides
+Every active `QuicSession` is associated with a single application protocol
+implementation. The `quic` module is designed to be application-agnostic
+in general, but includes optional built-in support for HTTP/3 as a specific
+application protocol. When using HTTP/3, the `quic` module provides
 additional APIs for handling HTTP/3-specific features such as headers, trailers,
 and prioritization. For other application protocols, users can implement their
 own message framing and multiplexing on top of the core QUIC transport features.
 
 When initiating a TLS handshake, the client will include a list of supported
 ALPN protocols in the `ClientHello`. The server selects one of these protocols
-(if any) and includes it in the `ServerHello`. The negotiated protocol determines
-how the `QuicSession` and `QuicStream` APIs behave. For example, when the `h3`
-protocol is negotiated for HTTP/3, the `QuicSession` and `QuicStream` will support
-HTTP/3-specific features.
+(if any) and includes it in the `ServerHello`. The negotiated protocol does not
+automatically change how the session behaves: HTTP/3 is attached explicitly
+using the [`Http3Session`][] API, and a session it is never attached to uses
+the raw QUIC protocol directly.
 
 Currently, the `quic` module only supports HTTP/3 as a built-in application protocol.
 All other protocols must be implemented by the user on top of the provided JavaScript
@@ -505,7 +505,10 @@ const endpoint = new QuicEndpoint({
   address: '127.0.0.1:1234',
 });
 
-const client = await connect('123.123.123.123:8888', { endpoint });
+const client = await connect('123.123.123.123:8888', {
+  alpn: 'h3',
+  endpoint,
+});
 ```
 
 ## `quic.listen(onsession[, options])`
@@ -527,7 +530,7 @@ import { listen } from 'node:quic';
 
 const endpoint = await listen((session) => {
   // ... handle the session
-});
+}, { alpn: ['h3'] });
 
 // Closing the endpoint allows any sessions open when close is called
 // to complete naturally while preventing new sessions from being
@@ -961,8 +964,9 @@ added:
 * Type: {quic.ApplicationOptions}
 
 The current application-level options for this session. These include settings
-that are specific to the negotiated application protocol (e.g. HTTP/3) and may
-be negotiated separately from the transport parameters. Read only.
+that are specific to the installed application protocol (e.g. HTTP/3) and may
+be negotiated separately from the transport parameters. `undefined` until an
+application is installed. Read only.
 You can use the callback [`session.onapplication`][] to be informed, when settings
 from the remote arrive.
 
@@ -2702,7 +2706,8 @@ added:
 
 * Type: {Object}
 
-The application specific options.
+The application specific options, configured for HTTP/3 with
+[`new Http3Session()`][].
 
 #### `applicationOptions.maxHeaderPairs`
 
@@ -3102,36 +3107,7 @@ preference order that the server supports (e.g. `['h3', 'h3-29']`).
 During the TLS handshake, the server selects the first protocol from its
 list that the client also supports.
 
-The negotiated ALPN determines which Application implementation is used
-for the session. `'h3'` and `'h3-*'` variants select the HTTP/3
-application; all other values select the default application.
-
-Default: `'h3'`
-
-#### `sessionOptions.application`
-
-<!-- YAML
-added:
- - v26.2.0
- - v24.20.0
--->
-
-* Type: {quic.ApplicationOptions}
-
-Application-specific options.
-
-```mjs
-const { listen } = await import('node:quic');
-
-await listen((session) => { /* ... */ }, {
-  application: {
-    maxHeaderPairs: 64,
-    qpackMaxDTableCapacity: 8192,
-    enableDatagrams: true,
-  },
-  // ... other session options
-});
-```
+This option is required; omitting it throws `ERR_MISSING_OPTION`.
 
 #### `sessionOptions.ca`
 
@@ -3553,6 +3529,7 @@ contain:
 
 ```mjs
 const endpoint = await listen(callback, {
+  alpn: ['h3'],
   sni: {
     '*': { keys: [defaultKey], certs: [defaultCert] },
     'api.example.com': { keys: [apiKey], certs: [apiCert], port: 8443 },
@@ -4134,13 +4111,12 @@ added:
  - v24.20.0
 -->
 
-When the negotiated ALPN identifier is `'h3'` (or one of the `'h3-*'`
-draft variants), the QUIC session runs the HTTP/3 application backed
-by `nghttp3`. `'h3'` is the default ALPN for `quic.connect()` and
-`quic.listen()`, so HTTP/3 is what you get unless you select a
-different ALPN explicitly.
+HTTP/3, backed by `nghttp3`, can run on top of a QUIC session by attaching
+an [`Http3Session`][]. Negotiating the `'h3'` ALPN tells the peer which
+protocol to speak, but does not change how the connection works locally,
+so both are needed. See [`new Http3Session()`][] for more details.
 
-Selecting the HTTP/3 application enables a number of stream- and
+Attaching the HTTP/3 application enables a number of stream- and
 session-level capabilities that are not available to non-HTTP/3
 applications:
 
@@ -4176,13 +4152,13 @@ applications:
 ### Minimal HTTP/3 client
 
 ```mjs
-import { connect } from 'node:quic';
+import { connect, Http3Session } from 'node:quic';
 import process from 'node:process';
 
-const session = await connect('example.com:443', {
-  // ALPN defaults to 'h3'.
+const session = new Http3Session(await connect('example.com:443', {
+  alpn: 'h3',
   servername: 'example.com',
-});
+}));
 await session.opened;
 
 const stream = await session.createBidirectionalStream({
@@ -4227,17 +4203,21 @@ A few things to note:
 ### Minimal HTTP/3 server
 
 ```mjs
-import { listen } from 'node:quic';
+import { listen, Http3Session } from 'node:quic';
 
 const encoder = new TextEncoder();
 
-const endpoint = await listen((session) => {
+const endpoint = await listen((quicSession) => {
+  // Attaching HTTP/3 has to happen here, synchronously, before the
+  // callback returns.
+  const session = new Http3Session(quicSession);
+
   // The session.onstream callback fires for each new client-initiated
   // stream. It is optional here: with `onheaders` configured below,
   // request streams are consumed through that callback.
 }, {
+  alpn: ['h3'],
   sni: { '*': { keys: [defaultKey], certs: [defaultCert] } },
-  // ALPN defaults to 'h3'.
   onheaders(headers) {
     // `this` is the QuicStream. Pseudo-headers are available on the
     // request header block (`:method`, `:path`, `:scheme`,
@@ -4286,6 +4266,151 @@ Server-side notes:
   cookie handling. These are deliberately left to higher-level
   libraries built on top of `node:quic`.
 
+## Class: `Http3Session`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+This class wraps a [`QuicSession`][], attaching an HTTP/3 application protocol
+implementation which interprets the raw QUIC data and exposes APIs to allow
+you to use HTTP/3 over QUIC. Once the HTTP/3 application is attached, this
+session should be used instead of the raw QUIC session for all HTTP/3
+interactions. The streams that this session exposes are still `QuicStream`
+instances, but they gain HTTP/3 APIs and functionality from the application.
+
+The HTTP/3 session API exposes all key HTTP/3 session details: the settings,
+statistics, TLS identity, and HTTP/3-level events. The QUIC transport details
+underneath (e.g. paths, transport parameters, and key updates) remain on the
+QUIC session, accessible as [`http3session.quicSession`][].
+
+HTTP/3 frames every stream on the connection, so once this is attached,
+streams cannot be opened on the QUIC session directly:
+[`session.createBidirectionalStream()`][] and
+[`session.createUnidirectionalStream()`][] will throw `ERR_INVALID_STATE`,
+and request streams should be opened with
+[`http3session.createBidirectionalStream()`][] instead.
+
+### `new Http3Session(session[, options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `session` {quic.QuicSession} The QUIC session to attach HTTP/3 to.
+* `options` {Object}
+  * `settings` {quic.ApplicationOptions} The HTTP/3 settings to use.
+    Defaults apply to anything left out.
+  * `ongoaway` {Function} See [`http3session.ongoaway`][].
+  * `onorigin` {Function} See [`session.onorigin`][].
+  * `onsettings` {Function} See [`http3session.onsettings`][].
+
+HTTP/3 can only be attached before the session becomes **active**. A session
+becomes active when: a stream is created on it; a datagram is sent with
+[`session.sendDatagram()`][]; immediately after a server session's
+[`quic.listen()`][] callback returns; or immediately after a client's
+`session.opened` promise resolves.
+
+Only what this side does is listed, because nothing the peer sends can arrive
+any earlier: its streams and datagrams need keys that are only unlocked once
+the session is already active.
+
+In practice this means a server session should be attached synchronously
+inside the [`quic.listen()`][] callback, and a client session should be
+attached synchronously when the [`session.opened`][] promise resolves (or
+before), and in both cases before anything is sent on the session.
+
+Attaching to a session that is already active throws `ERR_INVALID_STATE`, and
+leaves the session untouched.
+
+### Members forwarded to the QUIC session
+
+<!-- YAML
+added: REPLACEME
+-->
+
+Each of the following behaves exactly as the member of the same name on the
+underlying [`QuicSession`][]: `alpnProtocol`, `certificate`, `close()`,
+`closed`, `destroy()`, `destroyed`, `ephemeralKeyInfo`, `onerror`, `opened`,
+`peerCertificate`, `servername`, and `stats`.
+
+### `http3session.createBidirectionalStream([options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Returns: {Promise} fulfilled with a {quic.QuicStream}
+
+Opens an HTTP/3 request stream. Equivalent to
+[`session.createBidirectionalStream()`][] on the underlying session.
+
+HTTP/3 has no server-initiated request streams, so calling this on a server
+session throws `ERR_INVALID_STATE`.
+
+### `http3session.ongoaway`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {Function}
+
+See [`session.ongoaway`][].
+
+### `http3session.onorigin`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {quic.OnOriginCallback}
+
+See [`session.onorigin`][].
+
+### `http3session.onsettings`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {quic.OnApplicationCallback}
+
+See [`session.onapplication`][].
+
+### `http3session.onstream`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {Function}
+
+Called with each request stream the peer opens, as a {quic.QuicStream}. See
+[`session.onstream`][].
+
+### `http3session.quicSession`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {quic.QuicSession}
+
+The QUIC session on which this HTTP/3 session is running.
+
+### `http3session.settings`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {quic.ApplicationOptions|null}
+
+The HTTP/3 settings in effect, including any update received from the peer's
+SETTINGS frame, which may arrive after the session opens. `null` once the
+session is destroyed.
+
 ## Performance measurement
 
 <!-- YAML
@@ -4821,13 +4946,15 @@ throughput issues caused by flow control.
 [RFC 9369]: https://www.rfc-editor.org/rfc/rfc9369
 [RFC 9412]: https://www.rfc-editor.org/rfc/rfc9412
 [RFC 9443]: https://www.rfc-editor.org/rfc/rfc9443
+[`Http3Session`]: #class-http3session
 [`PerformanceEntry`]: perf_hooks.md#class-performanceentry
 [`PerformanceObserver`]: perf_hooks.md#class-performanceobserver
 [`QuicEndpoint`]: #class-quicendpoint
 [`QuicError`]: #class-quicerror
-[`application.enableConnectProtocol`]: #sessionoptionsapplication
-[`application.enableDatagrams`]: #sessionoptionsapplication
-[`application.qpackMaxDTableCapacity`]: #sessionoptionsapplication
+[`QuicSession`]: #class-quicsession
+[`application.enableConnectProtocol`]: #applicationoptionsenableconnectprotocol
+[`application.enableDatagrams`]: #applicationoptionsenabledatagrams
+[`application.qpackMaxDTableCapacity`]: #applicationoptionsqpackmaxdtablecapacity
 [`certificateCompression`]: #sessionoptionscertificatecompression
 [`crypto.X509Certificate`]: crypto.md#class-x509certificate
 [`endpoint.busy`]: #endpointbusy
@@ -4847,8 +4974,13 @@ throughput issues caused by flow control.
 [`endpointOptions.versionNegotiationRate`]: #endpointoptionsversionnegotiationrate
 [`error.errorCode`]: #errorerrorcode
 [`fs.promises.open(path, 'r')`]: fs.md#fspromisesopenpath-flags-mode
+[`http3session.createBidirectionalStream()`]: #http3sessioncreatebidirectionalstreamoptions
+[`http3session.ongoaway`]: #http3sessionongoaway
+[`http3session.onsettings`]: #http3sessiononsettings
+[`http3session.quicSession`]: #http3sessionquicsession
 [`maxDatagramFrameSize`]: #transportparamsmaxdatagramframesize
 [`net.BlockList`]: net.md#class-netblocklist
+[`new Http3Session()`]: #new-http3sessionsession-options
 [`quic.connect()`]: #quicconnectaddress-options
 [`quic.listen()`]: #quiclistenonsession-options
 [`session.close()`]: #sessioncloseoptions
@@ -4868,6 +5000,7 @@ throughput issues caused by flow control.
 [`session.onqlog`]: #sessiononqlog
 [`session.onsessionticket`]: #sessiononsessionticket
 [`session.onstream`]: #sessiononstream
+[`session.opened`]: #sessionopened
 [`session.sendDatagram()`]: #sessionsenddatagramdatagram-encoding
 [`sessionOptions.cc`]: #sessionoptionscc
 [`sessionOptions.ciphers`]: #sessionoptionsciphers
diff --git a/lib/internal/quic/http3.js b/lib/internal/quic/http3.js
new file mode 100644
index 000000000000..4d321345d6aa
--- /dev/null
+++ b/lib/internal/quic/http3.js
@@ -0,0 +1,269 @@
+'use strict';
+
+const {
+  BigInt,
+  FunctionPrototypeBind,
+  NumberIsInteger,
+} = primordials;
+
+const {
+  getOptionValue,
+} = require('internal/options');
+
+if (!process.features.quic || !getOptionValue('--experimental-quic')) {
+  return;
+}
+
+// Internal, experimental HTTP/3 layer over node:quic.
+//
+// A QuicSession created without an application is a raw QUIC session.
+// Attaching an Http3Session makes it an HTTP/3 one, and from then on its
+// streams are HTTP/3 request streams.
+
+const {
+  QuicSession,
+  getQuicSessionState,
+  kCreateStream,
+  kSessionHandle,
+} = require('internal/quic/quic');
+
+const {
+  QUIC_APPLICATION_HTTP3,
+  QUIC_APPLICATION_PENDING,
+  STREAM_DIRECTION_BIDIRECTIONAL: kStreamDirectionBidirectional,
+  kHttp3Settings,
+} = internalBinding('quic');
+
+const {
+  validateFunction,
+  validateObject,
+} = require('internal/validators');
+
+const {
+  codes: {
+    ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_STATE,
+    ERR_OUT_OF_RANGE,
+  },
+} = require('internal/errors');
+
+const kEmptyObject = { __proto__: null };
+const kMaxUint64 = (1n << 64n) - 1n;
+
+const kNumericSettings = [
+  'maxHeaderPairs',
+  'maxHeaderLength',
+  'maxFieldSectionSize',
+  'qpackMaxDTableCapacity',
+  'qpackEncoderMaxDTableCapacity',
+  'qpackBlockedStreams',
+];
+const kBooleanSettings = [
+  'enableConnectProtocol',
+  'enableDatagrams',
+];
+
+// Validate settings and return them as a plain null-proto object:
+function prepareH3Settings(settings) {
+  const out = { __proto__: null };
+  for (let n = 0; n < kNumericSettings.length; n++) {
+    const name = kNumericSettings[n];
+    const value = settings[name];
+    if (value === undefined) continue;
+    let big;
+    if (typeof value === 'bigint') {
+      big = value;
+    } else if (typeof value === 'number') {
+      if (!NumberIsInteger(value)) {
+        throw new ERR_OUT_OF_RANGE(`options.settings.${name}`, 'an integer',
+                                   value);
+      }
+      big = BigInt(value);
+    } else {
+      throw new ERR_INVALID_ARG_TYPE(`options.settings.${name}`,
+                                     ['number', 'bigint'], value);
+    }
+    if (big < 0n || big > kMaxUint64) {
+      throw new ERR_OUT_OF_RANGE(`options.settings.${name}`,
+                                 `>= 0 && <= ${kMaxUint64}`, value);
+    }
+    out[name] = big;
+  }
+  for (let n = 0; n < kBooleanSettings.length; n++) {
+    const name = kBooleanSettings[n];
+    const value = settings[name];
+    if (value === undefined) continue;
+    if (typeof value !== 'boolean') {
+      throw new ERR_INVALID_ARG_TYPE(`options.settings.${name}`, 'boolean',
+                                     value);
+    }
+    out[name] = value;
+  }
+  return out;
+}
+
+function checkAttachable(session, state) {
+  if (session.destroyed ||
+    state.applicationType === undefined ||
+    session[kSessionHandle] === undefined) {
+    throw new ERR_INVALID_STATE(
+      'An application cannot be attached to a destroyed QUIC session');
+  }
+  if (state.applicationType !== 0) {
+    throw new ERR_INVALID_STATE(
+      'The QUIC session already has an application attached');
+  }
+}
+
+class Http3Session {
+  #session;
+  #onstream;
+  #ongoaway;
+  #onorigin;
+  #onsettings;
+  #onerror;
+
+  /**
+   * Attaches HTTP/3 to a QuicSession that has not yet become active.
+   * @param {QuicSession} session the QUIC session to attach to
+   * @param {object} [options]
+   * @param {ApplicationOptions} [options.settings]
+   * @param {Function} [options.ongoaway]
+   * @param {Function} [options.onorigin]
+   * @param {Function} [options.onsettings]
+   */
+  constructor(session, options = kEmptyObject) {
+    if (!(session instanceof QuicSession)) {
+      throw new ERR_INVALID_ARG_TYPE('session', 'QuicSession', session);
+    }
+    validateObject(options, 'options');
+    const { ongoaway, onorigin, onsettings, settings } = options;
+    if (ongoaway !== undefined) validateFunction(ongoaway, 'options.ongoaway');
+    if (onorigin !== undefined) validateFunction(onorigin, 'options.onorigin');
+    if (onsettings !== undefined) {
+      validateFunction(onsettings, 'options.onsettings');
+    }
+    const state = getQuicSessionState(session);
+
+    let preparedSettings;
+    if (settings !== undefined) {
+      validateObject(settings, 'options.settings');
+      preparedSettings = prepareH3Settings(settings);
+    }
+
+    // Reading settings could call getters and go into JS, so do this after:
+    checkAttachable(session, state);
+
+    const handle = session[kSessionHandle];
+    if (preparedSettings !== undefined) handle[kHttp3Settings] = preparedSettings;
+    state.applicationType = QUIC_APPLICATION_HTTP3 | QUIC_APPLICATION_PENDING;
+    this.#session = session;
+    if (ongoaway !== undefined) this.ongoaway = ongoaway;
+    if (onorigin !== undefined) this.onorigin = onorigin;
+    if (onsettings !== undefined) this.onsettings = onsettings;
+  }
+
+  /**
+   * The QUIC session carrying this HTTP/3 session
+   * @type {QuicSession}
+   */
+  get quicSession() { return this.#session; }
+
+  /**
+   * The settings in effect, including any update from the peer's SETTINGS
+   * frame, which may arrive after the session opens. Null once destroyed.
+   * @type {ApplicationOptions|null}
+   */
+  get settings() { return this.#session.applicationOptions; }
+
+  /** @type {string|undefined} */
+  get servername() { return this.#session.servername; }
+
+  /** @type {string|undefined} */
+  get alpnProtocol() { return this.#session.alpnProtocol; }
+
+  /** @type {object|undefined} */
+  get certificate() { return this.#session.certificate; }
+
+  /** @type {object|undefined} */
+  get peerCertificate() { return this.#session.peerCertificate; }
+
+  /** @type {object|undefined} */
+  get ephemeralKeyInfo() { return this.#session.ephemeralKeyInfo; }
+
+  /** @type {quic.QuicSession.Stats} */
+  get stats() { return this.#session.stats; }
+
+  // Ensure that 'this' in callbacks registered here is the Http3Session
+  #bind(fn) {
+    return fn === undefined ? undefined : FunctionPrototypeBind(fn, this);
+  }
+
+  /**
+   * Called with each request stream the peer opens.
+   * @type {Function|undefined}
+   */
+  get onstream() { return this.#onstream; }
+  set onstream(fn) {
+    this.#session.onstream = this.#bind(fn);
+    this.#onstream = fn;
+  }
+
+  /** @type {Function|undefined} */
+  get ongoaway() { return this.#ongoaway; }
+  set ongoaway(fn) {
+    this.#session.ongoaway = this.#bind(fn);
+    this.#ongoaway = fn;
+  }
+
+  /** @type {Function|undefined} */
+  get onorigin() { return this.#onorigin; }
+  set onorigin(fn) {
+    this.#session.onorigin = this.#bind(fn);
+    this.#onorigin = fn;
+  }
+
+  /** @type {Function|undefined} */
+  get onsettings() { return this.#onsettings; }
+  set onsettings(fn) {
+    this.#session.onapplication = this.#bind(fn);
+    this.#onsettings = fn;
+  }
+
+  /** @type {Function|undefined} */
+  get onerror() { return this.#onerror; }
+  set onerror(fn) {
+    this.#session.onerror = this.#bind(fn);
+    this.#onerror = fn;
+  }
+
+  /** @type {Promise<object>} */
+  get opened() { return this.#session.opened; }
+
+  /** @type {Promise<void>} */
+  get closed() { return this.#session.closed; }
+
+  /** @type {boolean} */
+  get destroyed() { return this.#session.destroyed; }
+
+  /**
+   * Opens a request stream.
+   * @returns {Promise<QuicStream>}
+   */
+  createBidirectionalStream(options) {
+    if (getQuicSessionState(this.#session).isServer) {
+      throw new ERR_INVALID_STATE(
+        'Server sessions cannot open HTTP/3 request streams');
+    }
+    return this.#session[kCreateStream](
+      kStreamDirectionBidirectional, options);
+  }
+
+  close(options) { return this.#session.close(options); }
+
+  destroy(error, options) { return this.#session.destroy(error, options); }
+}
+
+module.exports = {
+  Http3Session,
+};
diff --git a/lib/internal/quic/quic.js b/lib/internal/quic/quic.js
index 632369fc9086..89dbec99667a 100644
--- a/lib/internal/quic/quic.js
+++ b/lib/internal/quic/quic.js
@@ -67,6 +67,8 @@ const {
   DEFAULT_PREFERRED_ADDRESS_POLICY: kPreferredAddressDefault,
   STREAM_DIRECTION_BIDIRECTIONAL: kStreamDirectionBidirectional,
   STREAM_DIRECTION_UNIDIRECTIONAL: kStreamDirectionUnidirectional,
+  QUIC_APPLICATION_DEFAULT: kApplicationTypeDefault,
+  QUIC_APPLICATION_PENDING: kApplicationTypePending,
   CLOSECONTEXT_CLOSE: kCloseContextClose,
   CLOSECONTEXT_BIND_FAILURE: kCloseContextBindFailure,
   CLOSECONTEXT_LISTEN_FAILURE: kCloseContextListenFailure,
@@ -111,6 +113,7 @@ const {
     ERR_INVALID_STATE,
     ERR_INVALID_THIS,
     ERR_MISSING_ARGS,
+    ERR_MISSING_OPTION,
     ERR_OUT_OF_RANGE,
     ERR_QUIC_CONNECTION_FAILED,
     ERR_QUIC_ENDPOINT_CLOSED,
@@ -210,6 +213,7 @@ const {
   kPrivateConstructor,
   kReset,
   kSendHeaders,
+  kCreateStream,
   kSessionApplication,
   kSessionTicket,
   kStopSending,
@@ -279,6 +283,9 @@ const {
 
 const kNilDatagramId = 0n;
 
+// Internal-only symbol to expose the session #handle to applications
+const kSessionHandle = Symbol('kSessionHandle');
+
 // 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.
@@ -400,7 +407,6 @@ const endpointRegistry = new SafeSet();
  * @property {'use'|'ignore'|'default'} [preferredAddressPolicy] The preferred address policy
  * @property {'strict'|'auto'|'manual'} [verifyPeer='auto'] Peer certificate verification policy (client only)
  * @property {'error'|'ignore'} [truncatedReads] Truncated read policy
- * @property {ApplicationOptions} [application] The application options
  * @property {TransportParams} [transportParams] The transport parameters
  * @property {string} [servername] The server name identifier (client only)
  * @property {string|string[]} [alpn] The ALPN protocol identifier(s).
@@ -2953,6 +2959,16 @@ class QuicSession {
     return this.#handle.applicationOptions();
   }
 
+  /**
+   * Handle accessor to allow applications to reach the session handle.
+   * Returns undefined once destroyed.
+   * @type {object|undefined}
+   */
+  get [kSessionHandle]() {
+    assertIsQuicSession(this);
+    return this.#handle;
+  }
+
   get localTransportParams() {
     if (this.#inner.localTransportParams !== undefined) {
       return this.#inner.localTransportParams;
@@ -3518,6 +3534,7 @@ class QuicSession {
    */
   async createBidirectionalStream(options = kEmptyObject) {
     assertIsQuicSession(this);
+    this.#assertOwnsStreams();
     return await this.#createStream(kStreamDirectionBidirectional, options);
   }
 
@@ -3529,9 +3546,28 @@ class QuicSession {
    */
   async createUnidirectionalStream(options = kEmptyObject) {
     assertIsQuicSession(this);
+    this.#assertOwnsStreams();
     return await this.#createStream(kStreamDirectionUnidirectional, options);
   }
 
+  // If a non-default application type is used, this session does not own the
+  // streams - streams created here would not integrate into the application
+  // and will generally stall or crash. Once an application is attached, the
+  // application owns all stream creation.
+  #assertOwnsStreams() {
+    const type = this.#inner.state.applicationType & ~kApplicationTypePending;
+    if (type > kApplicationTypeDefault) {
+      throw new ERR_INVALID_STATE(
+        'Raw QUIC streams cannot be created on a session with a non-default ' +
+        'application attached. Create streams through the application ' +
+        'interface (e.g. Http3Session) instead');
+    }
+  }
+
+  async [kCreateStream](direction, options) {
+    return await this.#createStream(direction, options);
+  }
+
   /**
    * Send a datagram. The id of the sent datagram will be returned. The status
    * of the sent datagram will be reported via the datagram-status event if
@@ -5245,7 +5281,6 @@ function processTlsOptions(tls, forServer) {
 
   // Encode the ALPN option to wire format (length-prefixed protocol names).
   // Server: array of protocol names. Client: single protocol name.
-  // If not specified, the C++ default (h3) is used.
   let encodedAlpn;
   if (alpn !== undefined) {
     const protocols = forServer ?
@@ -5278,6 +5313,9 @@ function processTlsOptions(tls, forServer) {
       offset += protocols[i].length;
     }
     encodedAlpn = buf.toString('latin1');
+  } else {
+    // Transport-only: there is no application protocol to default to.
+    throw new ERR_MISSING_OPTION('options.alpn');
   }
 
   if (ca !== undefined) {
@@ -5469,9 +5507,6 @@ function processSessionOptions(options, config = kEmptyObject) {
     streamIdleTimeout,
     verifyPeer = 'auto',
     truncatedReads = 'error',
-    // HTTP/3 application-specific options. Nested under `application`
-    // to separate protocol-specific settings from transport-level ones.
-    application = kEmptyObject,
     // Session callbacks that can be set at construction time to avoid
     // race conditions with events that fire during or immediately
     // after the handshake.
@@ -5556,6 +5591,8 @@ function processSessionOptions(options, config = kEmptyObject) {
     }
   }
 
+  const tls = processTlsOptions(options, forServer);
+
   const actualEndpoint = processEndpointOption(endpoint,
                                                reuseEndpoint,
                                                forServer,
@@ -5573,7 +5610,7 @@ function processSessionOptions(options, config = kEmptyObject) {
       preferredAddressIpv6: preferredAddressIpv6?.[kSocketAddressHandle],
     },
     tls: {
-      ...processTlsOptions(options, forServer),
+      ...tls,
       // Forward strict mode to C++ so SSL_VERIFY_PEER is set on the
       // client SSL_CTX. For 'auto' and 'manual' modes, the handshake
       // completes regardless and the result is handled in JS.
@@ -5601,7 +5638,6 @@ function processSessionOptions(options, config = kEmptyObject) {
     drainingPeriodMultiplier,
     maxDatagramSendAttempts,
     streamIdleTimeout,
-    application,
     onerror,
     onstream,
     ondatagram,
@@ -5738,6 +5774,9 @@ module.exports = {
   CC_ALGO_BBR,
   DEFAULT_CIPHERS,
   DEFAULT_GROUPS,
+  // Internal only, for the HTTP/3 layer's integration with node:quic.
+  kCreateStream,
+  kSessionHandle,
   // These are exported only for internal testing purposes.
   getQuicStreamState,
   getQuicSessionState,
diff --git a/lib/internal/quic/state.js b/lib/internal/quic/state.js
index 0a47e2e7adc8..2b6a52a03951 100644
--- a/lib/internal/quic/state.js
+++ b/lib/internal/quic/state.js
@@ -79,6 +79,7 @@ const {
   IDX_STATE_SESSION_HEADERS_SUPPORTED,
   IDX_STATE_SESSION_STREAM_CALLBACKS_SUPPORTED,
   IDX_STATE_SESSION_WRAPPED,
+  IDX_STATE_SESSION_IS_SERVER,
   IDX_STATE_SESSION_APPLICATION_TYPE,
   IDX_STATE_SESSION_NO_ERROR_CODE,
   IDX_STATE_SESSION_INTERNAL_ERROR_CODE,
@@ -113,6 +114,7 @@ const {
   IDX_STATE_STREAM_BUDGET,
   IDX_STATE_STREAM_RESET_CODE,
   IDX_STATE_STREAM_SIZE,
+  QUIC_APPLICATION_PENDING,
 } = internalBinding('quic');
 
 assert(IDX_STATE_SESSION_LISTENER_FLAGS !== undefined);
@@ -127,6 +129,7 @@ assert(IDX_STATE_SESSION_PRIORITY_SUPPORTED !== undefined);
 assert(IDX_STATE_SESSION_HEADERS_SUPPORTED !== undefined);
 assert(IDX_STATE_SESSION_STREAM_CALLBACKS_SUPPORTED !== undefined);
 assert(IDX_STATE_SESSION_WRAPPED !== undefined);
+assert(IDX_STATE_SESSION_IS_SERVER !== undefined);
 assert(IDX_STATE_SESSION_APPLICATION_TYPE !== undefined);
 assert(IDX_STATE_SESSION_NO_ERROR_CODE !== undefined);
 assert(IDX_STATE_SESSION_INTERNAL_ERROR_CODE !== undefined);
@@ -495,7 +498,7 @@ class QuicSessionState {
    */
   get headersSupported() {
     const handle = this.#handle;
-    if (handle === undefined) return undefined;
+    if (handle === undefined || !this.#hasApplication) return undefined;
     return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_SESSION_HEADERS_SUPPORTED);
   }
 
@@ -507,7 +510,7 @@ class QuicSessionState {
    */
   get streamCallbacksSupported() {
     const handle = this.#handle;
-    if (handle === undefined) return undefined;
+    if (handle === undefined || !this.#hasApplication) return undefined;
     return DataViewPrototypeGetUint8(
       handle, this.#offset + IDX_STATE_SESSION_STREAM_CALLBACKS_SUPPORTED);
   }
@@ -519,13 +522,41 @@ class QuicSessionState {
     return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_SESSION_WRAPPED) !== 0;
   }
 
-  /** @type {number} */
+  /**
+   * The application the session is running, as an `Application::Type` value,
+   * or 0 for none. The `QUIC_APPLICATION_PENDING` flag will be set if the
+   * application attach has been requested but not yet completed.
+   * @type {number|undefined}
+   */
   get applicationType() {
     const handle = this.#handle;
     if (handle === undefined) return undefined;
     return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_SESSION_APPLICATION_TYPE);
   }
 
+  set applicationType(val) {
+    const handle = this.#handle;
+    if (handle === undefined) return;
+    DataViewPrototypeSetUint8(handle, this.#offset + IDX_STATE_SESSION_APPLICATION_TYPE, val);
+  }
+
+  // True once an application has actually been attached (not just requested)
+  get #hasApplication() {
+    const handle = this.#handle;
+    if (handle === undefined) return false;
+    const type = DataViewPrototypeGetUint8(
+      handle, this.#offset + IDX_STATE_SESSION_APPLICATION_TYPE);
+    return type !== 0 && (type & QUIC_APPLICATION_PENDING) === 0;
+  }
+
+  /** @type {boolean|undefined} */
+  get isServer() {
+    const handle = this.#handle;
+    if (handle === undefined) return undefined;
+    return DataViewPrototypeGetUint8(
+      handle, this.#offset + IDX_STATE_SESSION_IS_SERVER) !== 0;
+  }
+
   /**
    * The negotiated application protocol's "no error" code, populated
    * by the C++ layer when the application is selected during ALPN
@@ -535,7 +566,7 @@ class QuicSessionState {
    */
   get noErrorCode() {
     const handle = this.#handle;
-    if (handle === undefined) return undefined;
+    if (handle === undefined || !this.#hasApplication) return undefined;
     return DataViewPrototypeGetBigUint64(
       handle, this.#offset + IDX_STATE_SESSION_NO_ERROR_CODE, kIsLittleEndian);
   }
@@ -551,14 +582,14 @@ class QuicSessionState {
    */
   get internalErrorCode() {
     const handle = this.#handle;
-    if (handle === undefined) return undefined;
+    if (handle === undefined || !this.#hasApplication) return undefined;
     return DataViewPrototypeGetBigUint64(
       handle, this.#offset + IDX_STATE_SESSION_INTERNAL_ERROR_CODE, kIsLittleEndian);
   }
 
   get requestRejectedCode() {
     const handle = this.#handle;
-    if (handle === undefined) return undefined;
+    if (handle === undefined || !this.#hasApplication) return undefined;
     return DataViewPrototypeGetBigUint64(
       handle, this.#offset + IDX_STATE_SESSION_REQUEST_REJECTED_CODE, kIsLittleEndian);
   }
diff --git a/lib/internal/quic/symbols.js b/lib/internal/quic/symbols.js
index 1ed44ebe2b13..ded5e7280a6e 100644
--- a/lib/internal/quic/symbols.js
+++ b/lib/internal/quic/symbols.js
@@ -48,6 +48,7 @@ const kNewSession = Symbol('kNewSession');
 const kNewStream = Symbol('kNewStream');
 const kNewToken = Symbol('kNewToken');
 const kStreamCallbacks = Symbol('kStreamCallbacks');
+const kCreateStream = Symbol('kCreateStream');
 const kOrigin = Symbol('kOrigin');
 const kOwner = Symbol('kOwner');
 const kPathValidation = Symbol('kPathValidation');
@@ -82,6 +83,7 @@ module.exports = {
   kKeyObjectHandle,
   kListen,
   kNewSession,
+  kCreateStream,
   kNewStream,
   kNewToken,
   kStreamCallbacks,
diff --git a/lib/quic.js b/lib/quic.js
index 90f3a6addf0d..f013dabf6356 100644
--- a/lib/quic.js
+++ b/lib/quic.js
@@ -20,6 +20,10 @@ const {
   DEFAULT_GROUPS,
 } = require('internal/quic/quic');
 
+const {
+  Http3Session,
+} = require('internal/quic/http3');
+
 const cc = {
   get RENO() { return CC_ALGO_RENO; },
   get CUBIC() { return CC_ALGO_CUBIC; },
@@ -36,6 +40,7 @@ module.exports = {
   connect,
   listen,
   listEndpoints,
+  Http3Session,
   QuicEndpoint,
   QuicError,
   QuicSession,
diff --git a/src/node_builtins.cc b/src/node_builtins.cc
index 21af988c95d8..4ff8dd8ebd22 100644
--- a/src/node_builtins.cc
+++ b/src/node_builtins.cc
@@ -148,8 +148,8 @@ BuiltinLoader::BuiltinCategories BuiltinLoader::GetBuiltinCategories() const {
         "internal/streams/lazy_transform",
 #endif  // !HAVE_OPENSSL
 #ifndef OPENSSL_NO_QUIC
-        "internal/quic/quic", "internal/quic/symbols", "internal/quic/stats",
-        "internal/quic/state",
+        "internal/quic/quic", "internal/quic/http3", "internal/quic/symbols",
+        "internal/quic/stats", "internal/quic/state",
 #endif  // !OPENSSL_NO_QUIC
 #if HAVE_DTLS
         "internal/dtls/dtls", "internal/dtls/symbols", "internal/dtls/stats",
diff --git a/src/quic/README.md b/src/quic/README.md
index 8c23ed2f4af9..c8daf0bade5f 100644
--- a/src/quic/README.md
+++ b/src/quic/README.md
@@ -15,7 +15,7 @@ The stack is layered as:
 ├─────────────────────────────────────────────┤
 │  Endpoint      — UDP socket, packet I/O     │
 │  Session       — QUIC connection (ngtcp2)   │
-│  Application   — ALPN protocol logic        │
+│  Application   — Protocol logic (e.g. h3)   │
 │  Stream        — Bidirectional data flow    │
 ├─────────────────────────────────────────────┤
 │  ngtcp2 / nghttp3 / OpenSSL                 │
@@ -26,9 +26,9 @@ The stack is layered as:
 
 An **Endpoint** binds a UDP socket and dispatches incoming packets to
 **Sessions**. Each Session wraps an `ngtcp2_conn` and delegates
-protocol-specific behavior to an **Application** (selected by ALPN
-negotiation). Sessions contain **Streams** — bidirectional or unidirectional
-data channels that carry application data.
+protocol-specific behavior to an **Application**. Sessions contain
+**Streams** — bidirectional or unidirectional data channels that carry
+application data.
 
 ## File Map
 
@@ -135,20 +135,20 @@ re-reading from the source.
 ### Application Abstraction
 
 `Session::Application` is a virtual interface that the Session delegates
-ALPN-specific behavior to. Two implementations exist:
+protocol-specific behavior to. Two implementations exist:
 
-* **`DefaultApplication`** (`application.cc`): Used for non-HTTP/3 ALPN
-  protocols. Maintains its own stream scheduling queue. Streams are scheduled
-  via an intrusive linked list.
+* **`DefaultApplication`** (`application.cc`): Raw QUIC streams, with no
+  framing of its own. Maintains its own stream scheduling queue. Streams are
+  scheduled via an intrusive linked list.
 
-* **`Http3ApplicationImpl`** (`http3.cc`): Used when ALPN negotiates `h3`.
-  Wraps `nghttp3_conn` for HTTP/3 framing, header compression (QPACK),
-  server push, and stream prioritization. Manages unidirectional control
-  streams internally.
+* **`Http3ApplicationImpl`** (`http3.cc`): Wraps `nghttp3_conn` for HTTP/3
+  framing, header compression (QPACK), server push, and stream
+  prioritization. Manages unidirectional control streams internally.
 
-The Application is selected as soon as the ALPN protocol is known:
-immediately for clients, and for servers from the `OnClientHello` TLS
-callback (see [Server handshake ordering](#server-handshake-ordering)).
+A Session starts without an Application. JavaScript schedules an attach (that
+is what `new Http3Session(session)` does) by writing to the shared state, and
+the Session attaches it - or the `DefaultApplication` - when it becomes active,
+meaning the first time an Application is needed.
 
 ### Thread-Local Allocator
 
@@ -179,21 +179,19 @@ succeed but memory tracking is silently skipped.
 
 **Client**: `Endpoint::Connect()` builds a `Session::Config` with
 `Side::CLIENT`, creates a `TLSContext`, and calls `Session::Create()` →
-`ngtcp2_conn_client_new()`. The Application is selected immediately.
+`ngtcp2_conn_client_new()`.
 
 **Server**: `Endpoint::Receive()` processes an Initial packet through
 address validation (retry tokens, LRU cache), then calls `Session::Create()`
-→ `ngtcp2_conn_server_new()`. The Application is selected later, once the
-ClientHello names an ALPN protocol.
+→ `ngtcp2_conn_server_new()`.
 
 ### Server handshake ordering
 
 A server has to make several decisions from the ClientHello, and the order
-matters: the ALPN protocol depends on which identity SNI selected, the
-Application depends on the ALPN protocol, and JavaScript needs a
-`QuicSession` object before any 0-RTT request arrives on it. TLS is
-therefore stopped at the ClientHello, before the point where a session
-ticket could be accepted and early data could start flowing:
+matters: the ALPN protocol depends on which identity SNI selected, and
+JavaScript needs a `QuicSession` object before any 0-RTT request arrives on
+it. TLS is therefore stopped at the ClientHello, before the point where a
+session ticket could be accepted and early data could start flowing:
 
 ```text
 ngtcp2_conn_read_pkt()
@@ -201,7 +199,6 @@ ngtcp2_conn_read_pkt()
     → TLSContext::OnClientHello()        // SSL_CTX_set_client_hello_cb
        ├── SelectSNIContext() + SSL_set_SSL_CTX()
        ├── crypto::SelectNextProtocol()  // against that identity's list
-       ├── Session::InstallApplicationForAlpn()
        └── return SSL_CLIENT_HELLO_RETRY  // handshake suspended here
     ← SSL_ERROR_WANT_CLIENT_HELLO_CB     // ngtcp2 treats this as "not done"
  ← 0
diff --git a/src/quic/application.cc b/src/quic/application.cc
index 6f25c3771a75..25f1073a3cb4 100644
--- a/src/quic/application.cc
+++ b/src/quic/application.cc
@@ -271,9 +271,6 @@ class DefaultApplication final : public Session::Application {
     // condition (code 0 would be treated as a clean close).
     session().DestroyAllStreams(
         QuicError::ForApplication(GetInternalErrorCode()));
-    if (!session().is_destroyed()) {
-      session().EmitEarlyDataRejected();
-    }
   }
 
   bool ReceiveStreamOpen(stream_id id) override {
diff --git a/src/quic/application.h b/src/quic/application.h
index 4fd748763742..54f7d1a7ee70 100644
--- a/src/quic/application.h
+++ b/src/quic/application.h
@@ -22,7 +22,7 @@ enum class HeadersFlags : uint8_t {
   TERMINAL,
 };
 
-// An Application implements the ALPN-protocol specific semantics on behalf
+// An Application implements the protocol-specific semantics on behalf
 // of a QUIC Session.
 class Session::Application : public MemoryRetainer {
  public:
@@ -35,14 +35,21 @@ class Session::Application : public MemoryRetainer {
   // options passed at construction time since some options can be negotiated.
   virtual const Options& options() const = 0;
 
-  // The type of Application, exposed via the session state so JS
-  // can observe which Application was selected after ALPN negotiation.
-  // This is used primarily for testing/debugging.
+  // The type of Application, exposed via the session state so JS can observe
+  // which Application the session ended up with. This is used primarily for
+  // testing/debugging.
   enum class Type : uint8_t {
-    NONE = 0,     // Not yet selected (server pre-negotiation)
-    DEFAULT = 1,  // DefaultApplication (non-h3 ALPN)
-    HTTP3 = 2,    // Http3ApplicationImpl (h3 / h3-XX ALPN)
+    NONE = 0,     // None installed yet
+    DEFAULT = 1,  // DefaultApplication (raw QUIC streams)
+    HTTP3 = 2,    // Http3ApplicationImpl
   };
+
+  // Set alongside a Type in the session's shared application_type state to
+  // mean "requested but not yet attached". JavaScript sets it to trigger the
+  // application attach later, SetApplication clears it by writing the bare
+  // Type. Keeping type & pending/installed in one place avoids duplicating
+  // type definition and simplifies application checks.
+  static constexpr uint8_t kTypePending = 0x80;
   virtual Type type() const = 0;
 
   virtual bool Start();
diff --git a/src/quic/bindingdata.cc b/src/quic/bindingdata.cc
index d5711d88cb92..f0113cf41225 100644
--- a/src/quic/bindingdata.cc
+++ b/src/quic/bindingdata.cc
@@ -32,6 +32,7 @@ using v8::Isolate;
 using v8::Local;
 using v8::Object;
 using v8::String;
+using v8::Symbol;
 using v8::Value;
 
 namespace quic {
@@ -438,6 +439,17 @@ Local<DictionaryTemplate> BindingData::transport_params_template() const {
                                     transport_params_template_);
 }
 
+Local<Symbol> BindingData::http3_settings_symbol() {
+  if (http3_settings_symbol_.IsEmpty()) {
+    auto symbol = Symbol::New(
+        env()->isolate(),
+        FIXED_ONE_BYTE_STRING(env()->isolate(), "quic.http3.settings"));
+    http3_settings_symbol_.Reset(env()->isolate(), symbol);
+    return symbol;
+  }
+  return http3_settings_symbol_.Get(env()->isolate());
+}
+
 void BindingData::set_application_options_template(
     Local<DictionaryTemplate> tmpl) {
   application_options_template_.Reset(env()->isolate(), tmpl);
diff --git a/src/quic/bindingdata.h b/src/quic/bindingdata.h
index 96ac6a349182..7f5b680e5084 100644
--- a/src/quic/bindingdata.h
+++ b/src/quic/bindingdata.h
@@ -329,6 +329,8 @@ class BindingData final
   void set_transport_params_template(v8::Local<v8::DictionaryTemplate> tmpl);
   v8::Local<v8::DictionaryTemplate> transport_params_template() const;
 
+  v8::Local<v8::Symbol> http3_settings_symbol();
+
   void set_application_options_template(v8::Local<v8::DictionaryTemplate> tmpl);
   v8::Local<v8::DictionaryTemplate> application_options_template() const;
 
@@ -352,6 +354,7 @@ class BindingData final
 
   v8::Global<v8::DictionaryTemplate> transport_params_template_;
   v8::Global<v8::DictionaryTemplate> application_options_template_;
+  v8::Global<v8::Symbol> http3_settings_symbol_;
 
 #define V(name, _) v8::Global<v8::Function> name##_callback_;
   QUIC_JS_CALLBACKS(V)
diff --git a/src/quic/endpoint.cc b/src/quic/endpoint.cc
index 8a92986c5a9c..35dc7f9227f8 100644
--- a/src/quic/endpoint.cc
+++ b/src/quic/endpoint.cc
@@ -2010,9 +2010,11 @@ void Endpoint::EmitNewSession(const BaseObjectPtr<Session>& session) {
   // exists but it is in a destroyed state. Care should be taken accessing
   // session after this point.
 
-  // Deliver any qlog written while processing the packets that carried the
-  // ClientHello, which is the only output that can predate this callback.
+  // At this point, the session is active and JS has had its chance to request
+  // an application. We attach the application now, and then deliver any qlog
+  // written during the ClientHello - the only output that can predate this.
   if (!session->is_destroyed()) {
+    session->EnsureApplication();
     session->FlushPendingQlog();
   }
 }
diff --git a/src/quic/http3.cc b/src/quic/http3.cc
index fb48bd3e0032..f8b79401471d 100644
--- a/src/quic/http3.cc
+++ b/src/quic/http3.cc
@@ -23,9 +23,12 @@ namespace node {
 
 using v8::Array;
 using v8::Global;
+using v8::HandleScope;
 using v8::Integer;
 using v8::Local;
 using v8::LocalVector;
+using v8::Object;
+using v8::TryCatch;
 using v8::Value;
 
 namespace quic {
@@ -210,9 +213,6 @@ class Http3ApplicationImpl final : public Session::Application {
     started_ = false;
     session().DestroyAllStreams(
         QuicError::ForApplication(GetInternalErrorCode()));
-    if (!session().is_destroyed()) {
-      session().EmitEarlyDataRejected();
-    }
   }
 
   bool ReceiveStreamOpen(stream_id id) override {
@@ -1524,10 +1524,46 @@ class Http3ApplicationImpl final : public Session::Application {
       nullptr};
 };
 
-std::unique_ptr<Session::Application> CreateHttp3Application(
-    Session* session, const Session::Application_Options& options) {
-  Debug(session, "Selecting HTTP/3 application");
-  return std::make_unique<Http3ApplicationImpl>(session, options);
+Session::Application_Options Http3SettingsFromHandle(const Session& session) {
+  Environment* env = session.env();
+  HandleScope scope(env->isolate());
+
+  Local<Value> stored;
+  if (!session.object()
+           ->Get(env->context(), BindingData::Get(env).http3_settings_symbol())
+           .ToLocal(&stored) ||
+      !stored->IsObject()) {
+    return Session::Application_Options::kDefault;
+  }
+
+  Session::Application_Options options;
+  {
+    TryCatch try_catch(env->isolate());
+    if (Session::Application_Options::From(env, stored).To(&options)) {
+      return options;
+    }
+  }
+  return Session::Application_Options::kDefault;
+}
+
+void InitHttp3PerContext(Realm* realm, Local<Object> target) {
+  Environment* env = realm->env();
+  // The application id JavaScript writes into the session's application_type
+  // to request HTTP/3, and the symbol it leaves the settings under.
+  constexpr int QUIC_APPLICATION_HTTP3 =
+      static_cast<int>(Session::Application::Type::HTTP3);
+  NODE_DEFINE_CONSTANT(target, QUIC_APPLICATION_HTTP3);
+  target
+      ->Set(realm->context(),
+            FIXED_ONE_BYTE_STRING(env->isolate(), "kHttp3Settings"),
+            BindingData::Get(env).http3_settings_symbol())
+      .Check();
+}
+
+std::unique_ptr<Session::Application> CreateHttp3Application(Session* session) {
+  Debug(session, "Installing HTTP/3 application");
+  return std::make_unique<Http3ApplicationImpl>(
+      session, Http3SettingsFromHandle(*session));
 }
 
 }  // namespace quic
diff --git a/src/quic/http3.h b/src/quic/http3.h
index 09033ca78b3d..257d24180bf2 100644
--- a/src/quic/http3.h
+++ b/src/quic/http3.h
@@ -2,18 +2,24 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include <v8.h>
 #include <memory>
 #include "application.h"
 #include "session.h"
 
-namespace node::quic {
+namespace node {
+class ExternalReferenceRegistry;
+class Realm;
+namespace quic {
 
 // Create an HTTP/3 Application implementation for the given session.
-// Uses the Application_Options from the session's config for HTTP/3
-// specific settings (qpack, max header length, etc.).
-std::unique_ptr<Session::Application> CreateHttp3Application(
-    Session* session, const Session::Application_Options& options);
+std::unique_ptr<Session::Application> CreateHttp3Application(Session* session);
 
-}  // namespace node::quic
+Session::Application_Options Http3SettingsFromHandle(const Session& session);
+
+void InitHttp3PerContext(Realm* realm, v8::Local<v8::Object> target);
+
+}  // namespace quic
+}  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/quic/quic.cc b/src/quic/quic.cc
index 36e781f1d700..815e6f445c1d 100644
--- a/src/quic/quic.cc
+++ b/src/quic/quic.cc
@@ -2,6 +2,7 @@
 #include "guard.h"
 #ifndef OPENSSL_NO_QUIC
 
+#include <async_wrap-inl.h>
 #include <base_object-inl.h>
 #include <env-inl.h>
 #include <memory_tracker-inl.h>
@@ -10,6 +11,7 @@
 #include <v8.h>
 #include "bindingdata.h"
 #include "endpoint.h"
+#include "http3.h"
 #include "node_external_reference.h"
 
 #include <ngtcp2/ngtcp2_crypto_ossl.h>
@@ -49,6 +51,7 @@ void CreatePerContextProperties(Local<Object> target,
   Endpoint::InitPerContext(realm, target);
   Session::InitPerContext(realm, target);
   Stream::InitPerContext(realm, target);
+  InitHttp3PerContext(realm, target);
 }
 
 void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
diff --git a/src/quic/session.cc b/src/quic/session.cc
index 90d59487a2a7..84d3e9a8b961 100644
--- a/src/quic/session.cc
+++ b/src/quic/session.cc
@@ -139,6 +139,7 @@ uint64_t MaxDatagramPayload(uint64_t max_frame_size) {
   V(HEADERS_SUPPORTED, headers_supported, uint8_t)                             \
   V(STREAM_CALLBACKS_SUPPORTED, stream_callbacks_supported, uint8_t)           \
   V(WRAPPED, wrapped, uint8_t)                                                 \
+  V(IS_SERVER, is_server, uint8_t)                                             \
   V(APPLICATION_TYPE, application_type, uint8_t)                               \
   V(NO_ERROR_CODE, no_error_code, error_code)                                  \
   V(INTERNAL_ERROR_CODE, internal_error_code, error_code)                      \
@@ -653,20 +654,6 @@ Maybe<Session::Options> Session::Options::From(Environment* env,
     }
   }
 
-  // Parse the application-specific options (HTTP/3 qpack settings, etc.).
-  // These are used if the negotiated ALPN selects Http3ApplicationImpl.
-  {
-    Local<Value> app_val;
-    if (params->Get(env->context(), state.application_string())
-            .ToLocal(&app_val) &&
-        !app_val->IsUndefined()) {
-      if (!Application_Options::From(env, app_val)
-               .To(&options.application_options)) {
-        return Nothing<Options>();
-      }
-    }
-  }
-
   // Parse the SNI map from the tls options.
   {
     Local<Value> tls_val;
@@ -1246,10 +1233,16 @@ struct Session::Impl final : public MemoryRetainer {
 
     Local<Object> obj;
     if (!session->has_application()) {
-      // The application has not yet been selected (ALPN negotiation is not
-      // yet complete on the server) or the session has been destroyed. In
-      // either case, the application options are not available.
-      return args.GetReturnValue().SetUndefined();
+      // Not installed yet. If an attach has been scheduled, its settings are
+      // already known and can be reported before the install happens.
+      if ((session->application_type() & ~Application::kTypePending) !=
+          static_cast<uint8_t>(Application::Type::HTTP3)) {
+        return args.GetReturnValue().SetUndefined();
+      }
+      if (Http3SettingsFromHandle(*session).ToObject(env).ToLocal(&obj)) {
+        args.GetReturnValue().Set(obj);
+      }
+      return;
     }
     auto& options = session->application().options();
     if (options.ToObject(env).ToLocal(&obj)) {
@@ -1448,6 +1441,9 @@ struct Session::Impl final : public MemoryRetainer {
 
     if (level != NGTCP2_ENCRYPTION_LEVEL_1RTT) return NGTCP2_SUCCESS;
 
+    session->keys_ready_ = true;
+    if (!session->impl_->application_) return NGTCP2_SUCCESS;
+
     // If the application was already started via on_receive_tx_key
     // (0-RTT path), this is a no-op.
     if (session->application().is_started()) return NGTCP2_SUCCESS;
@@ -1507,6 +1503,7 @@ struct Session::Impl final : public MemoryRetainer {
     // application for processing. If it ends up being a user stream, the
     // application will handle creating the Stream handle and passing that off
     // to the JavaScript side.
+    CHECK(session->impl_->application_);
     if (!session->application().ReceiveStreamData(
             stream_id, data, datalen, data_flags, stream_user_data)) {
       return NGTCP2_ERR_CALLBACK_FAILURE;
@@ -1531,10 +1528,10 @@ struct Session::Impl final : public MemoryRetainer {
       if (level != NGTCP2_ENCRYPTION_LEVEL_0RTT) return NGTCP2_SUCCESS;
     }
 
-    // application_ may be null if ALPN selection hasn't happened yet
-    // (e.g., ALPN mismatch causes the handshake to fail during key
-    // installation). Without an application, we can't start.
-    if (!session->impl_->application_) return NGTCP2_ERR_CALLBACK_FAILURE;
+    session->keys_ready_ = true;
+    // A session with no application installed has nothing to start; whichever
+    // one is installed later starts itself, see EnsureApplication().
+    if (!session->impl_->application_) return NGTCP2_SUCCESS;
 
     Debug(session,
           "Receiving TX key for level %s for dcid %s",
@@ -1598,6 +1595,7 @@ struct Session::Impl final : public MemoryRetainer {
 
   static int on_stream_open(ngtcp2_conn* conn, stream_id id, void* user_data) {
     NGTCP2_CALLBACK_SCOPE(session)
+    CHECK(session->impl_->application_);
     if (!session->application().ReceiveStreamOpen(id)) {
       return NGTCP2_ERR_CALLBACK_FAILURE;
     }
@@ -1644,6 +1642,9 @@ struct Session::Impl final : public MemoryRetainer {
     if (session->impl_->application_) {
       session->application().EarlyDataRejected();
     }
+    if (!session->is_destroyed()) {
+      session->EmitEarlyDataRejected();
+    }
     return NGTCP2_SUCCESS;
   }
 
@@ -1785,7 +1786,7 @@ Session::SendPendingDataScope::~SendPendingDataScope() {
   DCHECK_GE(session->impl_->send_scope_depth_, 1);
   Debug(session, "Send Scope Depth %zu", session->impl_->send_scope_depth_);
   if (--session->impl_->send_scope_depth_ == 0 &&
-      session->impl_->application_ && !session->impl_->handshake_deferred_) {
+      !session->impl_->handshake_deferred_) {
     session->SendPendingData();
   }
 }
@@ -2027,7 +2028,7 @@ void Session::SendPendingData() {
     stream_data.fin = false;
     stream_data.stream.reset();
 
-    if (application().GetStreamData(&stream_data) < 0) {
+    if (impl_->application_ && application().GetStreamData(&stream_data) < 0) {
       Debug(this, "Application failed to get stream data");
       SetLastError(QuicError::ForNgtcp2Error(NGTCP2_ERR_INTERNAL));
       closed = true;
@@ -2272,12 +2273,7 @@ Session::Session(Endpoint* endpoint,
   DCHECK(impl_);
   STAT_RECORD_TIMESTAMP(Stats, created_at);
 
-  // For clients, select the Application immediately - the ALPN is
-  // known upfront from the options. For servers, application_ stays
-  // null until the ClientHello names a protocol.
-  if (config.side == Side::CLIENT) {
-    InstallApplicationForAlpn(DecodeAlpn(config.options.tls_options.alpn));
-  }
+  impl_->state()->is_server = config.side == Side::SERVER ? 1 : 0;
 
   // For client sessions with a session ticket and early data enabled,
   // defer the handshake until the first stream or datagram is sent.
@@ -2441,15 +2437,6 @@ void Session::Close(CloseMethod method) {
       }
       impl_->state()->graceful_close = 1;
 
-      // application_ may be null for server sessions if close() is called
-      // before the TLS handshake selects the ALPN. Without an application
-      // we cannot do a graceful shutdown (GOAWAY, CONNECTION_CLOSE etc.),
-      // so fall through to a silent close.
-      if (!impl_->application_) {
-        impl_->state()->silent_close = 1;
-        return FinishClose();
-      }
-
       // The SendPendingDataScope ensures that the GOAWAY packet queued
       // by BeginShutdown is actually sent. Without it, the GOAWAY sits
       // in nghttp3's outq until the next Receive() triggers a send.
@@ -2458,8 +2445,10 @@ void Session::Close(CloseMethod method) {
       // Signal application-level graceful shutdown (e.g., HTTP/3 GOAWAY).
       // BeginShutdown can trigger callbacks that re-enter JS and destroy
       // this session, so check is_destroyed() after it returns.
-      application().BeginShutdown();
-      if (is_destroyed()) return;
+      if (impl_->application_) {
+        application().BeginShutdown();
+        if (is_destroyed()) return;
+      }
 
       // If there are no open streams, then we can close immediately and
       // not worry about waiting around.
@@ -2478,7 +2467,7 @@ void Session::Close(CloseMethod method) {
       // writable stream with a closed read side is the normal request/
       // response pattern (server received full request, still sending
       // response). The application protocol handles stream completion.
-      if (!application().stream_fin_managed_by_application()) {
+      if (!stream_fin_managed_by_application()) {
         Session::SendPendingDataScope send_scope(this);
         for (auto& [id, stream] : impl_->streams_) {
           if (stream->is_writable() && !stream->is_readable()) {
@@ -2610,38 +2599,20 @@ bool Session::has_application() const {
   return !is_destroyed() && impl_->application_ != nullptr;
 }
 
+uint8_t Session::application_type() const {
+  if (is_destroyed()) return 0;
+  return impl_->state()->application_type;
+}
+
 Session::Application& Session::application() const {
   DCHECK(!is_destroyed());
   DCHECK(impl_->application_);
   return *impl_->application_;
 }
 
-std::string_view Session::DecodeAlpn(std::string_view wire) {
-  // ALPN wire format is length-prefixed: [len][name]. Extract the first entry.
-  if (wire.size() >= 2) {
-    uint8_t len = static_cast<uint8_t>(wire[0]);
-    if (len > 0 && static_cast<size_t>(len + 1) <= wire.size()) {
-      return wire.substr(1, len);
-    }
-  }
-  return {};
-}
-
-std::unique_ptr<Session::Application> Session::SelectApplicationFromAlpn(
-    std::string_view alpn) {
-  // h3 and h3-XX variants use Http3ApplicationImpl.
-  // Everything else uses DefaultApplication.
-  if (alpn == "h3" || (alpn.size() > 3 && alpn.substr(0, 3) == "h3-")) {
-    return CreateHttp3Application(this, config().options.application_options);
-  }
-  return CreateDefaultApplication(this, config().options.application_options);
-}
-
-void Session::InstallApplicationForAlpn(std::string_view alpn) {
-  // Acting on the ClientHello twice would install a second Application over
-  // a live one; TLSSession::EarlySelection is what prevents that.
-  CHECK(!has_application());
-  SetApplication(SelectApplicationFromAlpn(alpn));
+bool Session::stream_fin_managed_by_application() const {
+  return impl_->application_ != nullptr &&
+         impl_->application_->stream_fin_managed_by_application();
 }
 
 void Session::SetEarlyRemoteTransportParams(std::span<const uint8_t> params) {
@@ -2651,8 +2622,35 @@ void Session::SetEarlyRemoteTransportParams(std::span<const uint8_t> params) {
       *this, params.data(), params.size()));
 }
 
+// This method is called at any point where we need an application to be
+// attached. It checks whether JS has requested a specific implementation,
+// and either installs that, or the default (raw QUIC) application.
+bool Session::EnsureApplication() {
+  if (is_destroyed()) [[unlikely]]
+    return false;
+  if (impl_->application_) [[likely]]
+    return true;
+
+  if ((impl_->state()->application_type & ~Application::kTypePending) ==
+      static_cast<uint8_t>(Application::Type::HTTP3)) {
+    SetApplication(CreateHttp3Application(this));
+  } else {
+    SetApplication(
+        CreateDefaultApplication(this, Application_Options::kDefault));
+  }
+
+  // If the keys are already ready, that means we should start immediately.
+  // If application start fails then we can't continue.
+  if (keys_ready_ && !application().Start()) {
+    Debug(this, "Application start failed");
+    return false;
+  }
+  return true;
+}
+
 void Session::SetApplication(std::unique_ptr<Application> app) {
   DCHECK(!impl_->application_);
+  DCHECK(app);
   impl_->state()->application_type = static_cast<uint8_t>(app->type());
   impl_->state()->headers_supported = static_cast<uint8_t>(
       app->SupportsHeaders() ? HeadersSupportState::SUPPORTED
@@ -2663,7 +2661,7 @@ void Session::SetApplication(std::unique_ptr<Application> app) {
                                : StreamCallbacksSupportState::UNSUPPORTED);
   // Surface the application's "no error" and "internal error" codes via
   // session state so that JS-side code (e.g. the stream writer's fail()
-  // path) can resolve the right wire code for the negotiated ALPN
+  // path) can resolve the right wire code for the installed application
   // without duplicating the per-application table.
   impl_->state()->no_error_code = app->GetNoErrorCode();
   impl_->state()->internal_error_code = app->GetInternalErrorCode();
@@ -3022,13 +3020,11 @@ void Session::SendBatch(Packet::Ptr* packets,
 
 void Session::FlushPendingData() {
   DCHECK(!is_destroyed());
-  if (impl_->application_) {
-    // Prefer synchronous sends during the deferred flush to avoid the
-    // one-tick latency of async uv_udp_send from the uv_check callback.
-    flags_.prefer_try_send = true;
-    SendPendingData();
-    flags_.prefer_try_send = false;
-  }
+  // Prefer synchronous sends during the deferred flush to avoid the
+  // one-tick latency of async uv_udp_send from the uv_check callback.
+  flags_.prefer_try_send = true;
+  SendPendingData();
+  flags_.prefer_try_send = false;
 }
 
 void Session::Send(Packet::Ptr packet) {
@@ -3105,6 +3101,9 @@ datagram_id Session::SendDatagram(Store&& data) {
     return 0;
   }
 
+  if (!EnsureApplication()) [[unlikely]]
+    return 0;
+
   const ngtcp2_transport_params* tp = remote_transport_params();
   uint64_t max_datagram_size = MaxDatagramPayload(tp->max_datagram_frame_size);
 
@@ -3211,6 +3210,9 @@ MaybeLocal<Object> Session::OpenStream(Direction direction,
   if (!can_create_streams()) [[unlikely]]
     return {};
 
+  if (!EnsureApplication()) [[unlikely]]
+    return {};
+
   // If can_open_streams() returns false, we are able to create streams but
   // they will remain in a pending state. The implication is that the session
   // TLS handshake is still progressing. Note that when a pending stream is
@@ -3407,16 +3409,14 @@ void Session::StreamDataBlocked(stream_id id) {
 void Session::CollectSessionTicketAppData(
     SessionTicket::AppData* app_data) const {
   DCHECK(!is_destroyed());
+  CHECK(has_application());
   application().CollectSessionTicketAppData(app_data);
 }
 
 SessionTicket::AppData::Status Session::ExtractSessionTicketAppData(
     const SessionTicket::AppData& app_data, Flag flag) {
   DCHECK(!is_destroyed());
-  // Renew, so the client stops offering a ticket that is never accepted.
-  if (!has_application()) [[unlikely]] {
-    return SessionTicket::AppData::Status::TICKET_IGNORE_RENEW;
-  }
+  CHECK(has_application());
   return application().ExtractSessionTicketAppData(app_data, flag);
 }
 
@@ -3701,7 +3701,6 @@ void Session::SendConnectionClose() {
 
 void Session::OnTimeout() {
   if (is_destroyed()) return;
-  if (!impl_->application_) return;
   // Hold a strong reference to prevent the Session from being freed during
   // re-entrant calls. SendPendingData's scope guard calls UpdateTimer(),
   // which can synchronously re-enter OnTimeout() when the timer has already
@@ -3889,6 +3888,12 @@ bool Session::HandshakeCompleted() {
 
   EmitHandshakeComplete();
 
+  if (is_destroyed()) return false;
+
+  // Handshake is completed, session.opened has been emitted finished & any
+  // following microtasks - time up, we now need an Application to continue.
+  if (!EnsureApplication()) return false;
+
   return true;
 }
 
@@ -4244,9 +4249,8 @@ void Session::EmitApplication() {
   if (!env()->can_call_into_js()) return;
 
   if (!has_application()) {
-    // The application has not yet been selected (ALPN negotiation is not
-    // yet complete on the server) or the session has been destroyed. In
-    // either case, the application options are not available.
+    // The application has not yet been installed, or the session has been
+    // destroyed. In either case, the application options are not available.
     // Should not happen, but we bail out
     return;
   }
@@ -4449,11 +4453,16 @@ void Session::InitPerContext(Realm* realm, Local<Object> target) {
       static_cast<uint8_t>(Direction::BIDIRECTIONAL);
   static constexpr auto STREAM_DIRECTION_UNIDIRECTIONAL =
       static_cast<uint8_t>(Direction::UNIDIRECTIONAL);
+  static constexpr auto QUIC_APPLICATION_DEFAULT =
+      static_cast<uint8_t>(Application::Type::DEFAULT);
+  static constexpr auto QUIC_APPLICATION_PENDING = Application::kTypePending;
   static constexpr auto QUIC_PROTO_MAX = NGTCP2_PROTO_VER_MAX;
   static constexpr auto QUIC_PROTO_MIN = NGTCP2_PROTO_VER_MIN;
 
   NODE_DEFINE_CONSTANT(target, STREAM_DIRECTION_BIDIRECTIONAL);
   NODE_DEFINE_CONSTANT(target, STREAM_DIRECTION_UNIDIRECTIONAL);
+  NODE_DEFINE_CONSTANT(target, QUIC_APPLICATION_DEFAULT);
+  NODE_DEFINE_CONSTANT(target, QUIC_APPLICATION_PENDING);
   NODE_DEFINE_CONSTANT(target, DEFAULT_MAX_HEADER_LIST_PAIRS);
   NODE_DEFINE_CONSTANT(target, DEFAULT_MAX_HEADER_LENGTH);
   NODE_DEFINE_CONSTANT(target, QUIC_PROTO_MAX);
diff --git a/src/quic/session.h b/src/quic/session.h
index 936c9e68db6e..0ffe1f822adb 100644
--- a/src/quic/session.h
+++ b/src/quic/session.h
@@ -11,6 +11,7 @@
 #include <node_sockaddr.h>
 #include <timer_wrap.h>
 #include <util.h>
+#include <memory>
 #include <optional>
 #include <span>
 #include "bindingdata.h"
@@ -101,7 +102,7 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
     static const Application_Options kDefault;
   };
 
-  // An Application implements the ALPN-protocol specific semantics on behalf
+  // An Application implements the protocol-specific semantics on behalf
   // of a QUIC Session.
   class Application;
 
@@ -158,10 +159,6 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
     // so that it cannot be garbage collected.
     BaseObjectPtr<BaseObject> cid_factory_ref;
 
-    // Application-specific options (used for HTTP/3 if the negotiated
-    // ALPN selects Http3ApplicationImpl).
-    Application_Options application_options = Application_Options::kDefault;
-
     // When true, QLog output will be enabled for the session.
     bool qlog = false;
 
@@ -347,8 +344,11 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
   TLSSession& tls_session() const;
   bool has_application() const;
   Application& application() const;
+
   const Config& config() const;
   const Options& options() const;
+
+  uint8_t application_type() const;
   const SocketAddress& remote_address() const;
   const SocketAddress& local_address() const;
 
@@ -423,21 +423,17 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
   // (ngtcp2_conn_read_pkt or ngtcp2_conn_continue_handshake).
   bool AfterNgtcp2Read(int err);
 
-  // Decode the first ALPN protocol name from wire format (length-prefixed).
-  static std::string_view DecodeAlpn(std::string_view wire);
-
-  // Select the Application implementation based on the negotiated ALPN.
-  // h3 (and h3-XX variants) map to Http3ApplicationImpl; all others map
-  // to DefaultApplication. Sets the application_type state field.
-  std::unique_ptr<Application> SelectApplicationFromAlpn(std::string_view alpn);
-
-  // Install the Application on the session. Called at construction for
-  // clients (ALPN known upfront) or from the ClientHello callback for
-  // servers (ALPN negotiated during handshake). Must be called before any
+  // Attach the Application to the session. Must be called before any
   // application data is received.
   void SetApplication(std::unique_ptr<Application> app);
 
-  void InstallApplicationForAlpn(std::string_view alpn);
+  // Attach the Application that JavaScript requested in the session's shared
+  // state, or the DefaultApplication if it named none. Called at every point
+  // an Application is first needed - a stream created on the session, a
+  // datagram sent, or the session handed to JavaScript - so one is always in
+  // place before anything can arrive from the peer. False if the application
+  // could not be started, which is fatal to the session.
+  bool EnsureApplication();
 
   // ngtcp2 ignores the duplicate when the TLS stack reports these again.
   void SetEarlyRemoteTransportParams(std::span<const uint8_t> params);
@@ -525,6 +521,8 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
   void ShutdownStream(stream_id id, QuicError error = QuicError());
   void ShutdownStreamWrite(stream_id id, QuicError code = QuicError());
 
+  bool stream_fin_managed_by_application() const;
+
   // Use the configured CID::Factory to generate a new CID.
   CID new_cid(size_t len = CID::kMaxLength) const;
 
@@ -742,6 +740,11 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
 
   bool hello_processed_ = false;
 
+  // Set once the encryption keys an application needs in order to start are
+  // installed. An application attached before this point is started by the
+  // key callbacks; after this it misses those so starts itself.
+  bool keys_ready_ = false;
+
   QuicConnectionPointer connection_;
   std::unique_ptr<TLSSession> tls_session_;
   friend struct NgTcp2CallbackScope;
diff --git a/src/quic/tlscontext.cc b/src/quic/tlscontext.cc
index e68380fd0424..efc1b118a06b 100644
--- a/src/quic/tlscontext.cc
+++ b/src/quic/tlscontext.cc
@@ -398,10 +398,6 @@ crypto::ClientHelloResult TLSContext::OnClientHello(
   Debug(&session, "ALPN negotiation succeeded: %s", *negotiated);
   tls_session.set_alpn(*negotiated);
 
-  // Install the Application while the handshake is still stopped, so that
-  // it is in place before a session ticket can be accepted and early data
-  // can start arriving.
-  session.InstallApplicationForAlpn(*negotiated);
   session.set_hello_processed();
 
   // Stop here. Session::AfterNgtcp2Read surfaces the server session to
diff --git a/src/quic/tlscontext.h b/src/quic/tlscontext.h
index 8209eda12dbc..16e2ef76e3a5 100644
--- a/src/quic/tlscontext.h
+++ b/src/quic/tlscontext.h
@@ -220,7 +220,7 @@ class TLSContext final : public MemoryRetainer,
     // The ALPN protocol identifier(s) in wire format (length-prefixed,
     // concatenated). For clients this is a single entry. For servers
     // this may contain multiple entries in preference order.
-    std::string alpn = NGHTTP3_ALPN_H3;
+    std::string alpn;
 
     // The list of TLS ciphers to use for this session.
     std::string ciphers = DEFAULT_CIPHERS;
diff --git a/test/parallel/test-quic-alpn-h3.mjs b/test/parallel/test-quic-alpn-h3.mjs
index 9cf6e88f6cb3..aaf0bdf85171 100644
--- a/test/parallel/test-quic-alpn-h3.mjs
+++ b/test/parallel/test-quic-alpn-h3.mjs
@@ -14,32 +14,40 @@ const { createPrivateKey } = await import('node:crypto');
 const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
 const cert = fixtures.readKey('agent1-cert.pem');
 
-// Test h3 ALPN negotiation with Http3ApplicationImpl.
-// Both server and client use the default ALPN (h3).
+// Negotiating the h3 ALPN does not itself activate HTTP/3. The ALPN is
+// reported as usual, but the session keeps the default application unless it
+// has an Http3Session attached.
 
 const serverOpened = Promise.withResolvers();
 
 const serverEndpoint = await listen(mustCall(async (serverSession) => {
+  assert.strictEqual(serverSession.alpnProtocol, 'h3');
   const info = await serverSession.opened;
   assert.strictEqual(info.protocol, 'h3');
   serverOpened.resolve();
-  serverSession.close();
 }), {
+  alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
 });
 
 assert.notStrictEqual(serverEndpoint.address, undefined);
 
 const clientSession = await connect(serverEndpoint.address, {
+  alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
 });
 
-async function checkClient() {
-  const info = await clientSession.opened;
-  assert.strictEqual(info.protocol, 'h3');
-}
+const info = await clientSession.opened;
+assert.strictEqual(info.protocol, 'h3');
+await serverOpened.promise;
+
+// Not an HTTP/3 request stream, so it cannot carry headers.
+const stream = await clientSession.createBidirectionalStream();
+assert.throws(() => stream.sendHeaders({ ':status': '200' }), {
+  code: 'ERR_INVALID_STATE',
+  message: /does not support headers/,
+});
 
-await Promise.all([serverOpened.promise, checkClient()]);
-await clientSession.close();
+clientSession.destroy();
 await serverEndpoint.close();
diff --git a/test/parallel/test-quic-alpn.mjs b/test/parallel/test-quic-alpn.mjs
index 9ca3d40e4fef..494bcd0119ee 100644
--- a/test/parallel/test-quic-alpn.mjs
+++ b/test/parallel/test-quic-alpn.mjs
@@ -43,6 +43,16 @@ const clientSession = await connect(serverEndpoint.address, {
 
 await Promise.all([serverOpened.promise, checkSession(clientSession)]);
 await clientSession.close();
+
+// Omitting ALPN entirely is rejected up front too, with its own error:
+// node:quic is transport-only and has no application protocol to default to.
+await assert.rejects(listen(mustNotCall(), {
+  sni: { '*': { keys: [key], certs: [cert] } },
+}), { code: 'ERR_MISSING_OPTION', message: /options\.alpn/ });
+await assert.rejects(connect(serverEndpoint.address, { verifyPeer: 'manual' }), {
+  code: 'ERR_MISSING_OPTION', message: /options\.alpn/,
+});
+
 await serverEndpoint.close();
 
 // QUIC requires an application protocol, so a server that offers none is
diff --git a/test/parallel/test-quic-certificate-compression.mjs b/test/parallel/test-quic-certificate-compression.mjs
index 455029bfb648..5c04364389c8 100644
--- a/test/parallel/test-quic-certificate-compression.mjs
+++ b/test/parallel/test-quic-certificate-compression.mjs
@@ -74,12 +74,14 @@ async function handshake({ serverAlgs, clientAlgs }) {
     serverOpened.resolve();
     serverSession.close();
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     ...(serverAlgs !== undefined ?
       { certificateCompression: serverAlgs } : {}),
   });
 
   const clientSession = await connect(endpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
     ...(clientAlgs !== undefined ?
diff --git a/test/parallel/test-quic-early-selection-order.mjs b/test/parallel/test-quic-early-selection-order.mjs
index f7cc89fb04c0..3d7c39a3e1eb 100644
--- a/test/parallel/test-quic-early-selection-order.mjs
+++ b/test/parallel/test-quic-early-selection-order.mjs
@@ -13,6 +13,7 @@ if (!hasQuic) {
 }
 
 const { listen, connect } = await import('../common/quic.mjs');
+const { Http3Session } = await import('node:quic');
 const { bytes } = await import('stream/iter');
 
 const encoder = new TextEncoder();
@@ -27,7 +28,8 @@ const decoder = new TextDecoder();
   const gotTicket = Promise.withResolvers();
   const gotToken = Promise.withResolvers();
 
-  const endpoint = await listen(mustCall((ss) => {
+  const endpoint = await listen(mustCall((quicSession) => {
+    const ss = new Http3Session(quicSession);
     // No streams initially, stream must arrive in the onstream event, for
     // both the normal and the 0RTT sessions:
     assert.strictEqual(ss.stats.bidiInStreamCount, 0n);
@@ -52,12 +54,12 @@ const decoder = new TextDecoder();
   };
 
   // Open a 1st session, send a request, get session ticket & token:
-  const cs1 = await connect(endpoint.address, {
+  const cs1 = new Http3Session(await connect(endpoint.address, {
     servername: 'localhost',
     alpn: 'h3',
     onsessionticket: mustCall((t) => { ticket = t; gotTicket.resolve(); }, 2),
     onnewtoken: mustCall((t) => { token = t; gotToken.resolve(); }),
-  });
+  }));
   await cs1.opened;
   await Promise.all([gotTicket.promise, gotToken.promise]);
   const s1 = await cs1.createBidirectionalStream({
@@ -68,12 +70,12 @@ const decoder = new TextDecoder();
   await Promise.all([s1.closed, cs1.closed]);
 
   // Open 2nd session, reusing the ticket & token:
-  const cs2 = await connect(endpoint.address, {
+  const cs2 = new Http3Session(await connect(endpoint.address, {
     servername: 'localhost',
     alpn: 'h3',
     sessionTicket: ticket,
     token,
-  });
+  }));
 
   // Send a 0RTT request immediately, before the handshake completes:
   const s2 = await cs2.createBidirectionalStream({
diff --git a/test/parallel/test-quic-h3-attach.mjs b/test/parallel/test-quic-h3-attach.mjs
new file mode 100644
index 000000000000..0759a3852a47
--- /dev/null
+++ b/test/parallel/test-quic-h3-attach.mjs
@@ -0,0 +1,267 @@
+// Flags: --experimental-quic --experimental-stream-iter --no-warnings
+
+// Test: attaching HTTP/3 to a node:quic session - when it is allowed, what
+// it validates, and how it behaves when the window has closed.
+
+import { hasQuic, skip, mustCall } from '../common/index.mjs';
+import assert from 'node:assert';
+import * as fixtures from '../common/fixtures.mjs';
+
+if (!hasQuic) {
+  skip('QUIC is not enabled');
+}
+
+const { listen, connect, Http3Session } = await import('node:quic');
+const { createPrivateKey } = await import('node:crypto');
+const { bytes } = await import('stream/iter');
+
+const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
+const cert = fixtures.readKey('agent1-cert.pem');
+const serverOpts = {
+  alpn: ['h3'],
+  sni: { '*': { keys: [key], certs: [cert] } },
+};
+const clientOpts = {
+  alpn: 'h3',
+  servername: 'localhost',
+  verifyPeer: 'manual',
+};
+const enc = new TextEncoder();
+const dec = new TextDecoder();
+
+// Only a QuicSession can carry an HTTP/3 session.
+assert.throws(() => new Http3Session({}), { code: 'ERR_INVALID_ARG_TYPE' });
+
+// Both peers attached after the session already exists, and the attach
+// itself validated.
+{
+  const endpoint = await listen(mustCall((quicSession) => {
+    const session = new Http3Session(quicSession);
+    assert.strictEqual(session.quicSession, quicSession);
+
+    // Can only attach once:
+    assert.throws(() => new Http3Session(quicSession),
+                  { code: 'ERR_INVALID_STATE' });
+  }), serverOpts);
+
+  const quicClient = await connect(endpoint.address, clientOpts);
+
+  // Options are validated before anything is recorded, so the session is
+  // still attachable after these failures:
+  assert.throws(() => new Http3Session(quicClient, null),
+                { code: 'ERR_INVALID_ARG_TYPE' });
+  assert.throws(() => new Http3Session(quicClient, { ongoaway: 5 }),
+                { code: 'ERR_INVALID_ARG_TYPE' });
+
+  const client = new Http3Session(quicClient);
+  await client.opened;
+
+  assert.strictEqual(client.alpnProtocol, 'h3');
+  assert.strictEqual(client.servername, 'localhost');
+  assert.strictEqual(typeof client.stats.createdAt, 'bigint');
+  assert.strictEqual(typeof client.ephemeralKeyInfo, 'object');
+  await client.close();
+  await endpoint.close();
+}
+
+const tooLate = {
+  code: 'ERR_INVALID_STATE',
+  message: /already has an application/,
+};
+
+// Server: an attach deferred past the session callback is rejected.
+{
+  const done = Promise.withResolvers();
+  const endpoint = await listen(mustCall((quicSession) => {
+    setImmediate(mustCall(() => {
+      assert.throws(() => new Http3Session(quicSession), tooLate);
+      done.resolve();
+    }));
+  }), serverOpts);
+  const client = await connect(endpoint.address, clientOpts);
+  await client.opened;
+  await done.promise;
+  await client.close();
+  await endpoint.close();
+}
+
+// Client: the window stays open across the microtask checkpoint that resolves
+// `opened`, so the negotiated ALPN can be read and acted on before attaching.
+{
+  const endpoint = await listen(mustCall((quicSession) => {
+    new Http3Session(quicSession);
+  }), serverOpts);
+  const client = await connect(endpoint.address, clientOpts);
+  const info = await client.opened;
+  assert.strictEqual(info.protocol, 'h3');
+  assert.strictEqual(client.alpnProtocol, 'h3');
+  // Further already-settled awaits are still the same checkpoint.
+  await null;
+  const http3 = new Http3Session(client);
+  assert.strictEqual(http3.alpnProtocol, 'h3');
+  await http3.close();
+  await endpoint.close();
+}
+
+// Client: yielding to the event loop closes the window, and it is rejected
+// twice over - a failed attach must not poison the session into reporting
+// some other reason.
+{
+  const endpoint = await listen(mustCall((quicSession) => {
+    new Http3Session(quicSession);
+  }), serverOpts);
+  const client = await connect(endpoint.address, clientOpts);
+  await client.opened;
+  await new Promise(setImmediate);
+  assert.throws(() => new Http3Session(client), tooLate);
+  assert.throws(() => new Http3Session(client), tooLate);
+
+  await client.close();
+  await endpoint.close();
+}
+
+// Client: an attach once any stream exists is rejected, even pre-handshake.
+{
+  const serverGot = Promise.withResolvers();
+  const endpoint = await listen(mustCall((quicSession) => {
+    quicSession.onstream = mustCall(async (stream) => {
+      assert.strictEqual(dec.decode(await bytes(stream)), 'x');
+      quicSession.close();
+      serverGot.resolve();
+    });
+  }), serverOpts);
+  const client = await connect(endpoint.address, clientOpts);
+  const raw = await client.createUnidirectionalStream({ body: enc.encode('x') });
+  assert.throws(() => new Http3Session(client), tooLate);
+  await client.opened;
+  await serverGot.promise;
+  await raw.closed;
+  await client.close();
+  await endpoint.close();
+}
+
+// Client: sending a datagram attaches the application.
+{
+  const dgramOpts = { transportParams: { maxDatagramFrameSize: 100 } };
+  const endpoint = await listen(mustCall((quicSession) => {
+    quicSession.closed.catch(() => {});
+  }), { ...serverOpts, ...dgramOpts });
+  const client = await connect(endpoint.address, { ...clientOpts, ...dgramOpts });
+  await client.opened;
+  await client.sendDatagram(enc.encode('x'));
+  assert.throws(() => new Http3Session(client), tooLate);
+  await client.close();
+  await endpoint.close();
+}
+
+// A client that opens no stream gets its application installed when the
+// handshake completes, which may be well after the attach. The settings it
+// asked for should survive the gap, with anything else left as default.
+{
+  const settings = {
+    maxHeaderPairs: 33n,
+    qpackBlockedStreams: 77n,
+    enableConnectProtocol: false,
+  };
+  const endpoint = await listen(mustCall((quicSession) => {
+    new Http3Session(quicSession);
+  }), serverOpts);
+  const client = new Http3Session(
+    await connect(endpoint.address, clientOpts), { settings });
+
+  await client.opened;
+  const applied = client.settings;
+  assert.strictEqual(applied.maxHeaderPairs, 33n);
+  assert.strictEqual(applied.qpackBlockedStreams, 77n);
+  assert.strictEqual(applied.enableConnectProtocol, false);
+  assert.strictEqual(applied.qpackMaxDtableCapacity, 4096n);
+  await client.close();
+  await endpoint.close();
+}
+
+// Parsing the settings runs their property getters, i.e. arbitrary JS, part
+// way through the attach. We should safely handle even the weirdest things
+// you could do as part of that:
+{
+  // Server: the getter destroys the session.
+  const done = Promise.withResolvers();
+  const endpoint = await listen(mustCall((quicSession) => {
+    const settings = {
+      get maxHeaderPairs() { quicSession.destroy(); return 10n; },
+    };
+    assert.throws(() => new Http3Session(quicSession, { settings }), {
+      code: 'ERR_INVALID_STATE',
+      message: /destroyed/,
+    });
+    done.resolve();
+  }), serverOpts);
+  const client = await connect(endpoint.address, clientOpts);
+  await done.promise;
+  client.destroy();
+  await endpoint.close();
+}
+{
+  // Client: the getter creates a stream.
+  const endpoint = await listen(mustCall((quicSession) => {
+    quicSession.onstream = mustCall(async (stream) => {
+      assert.strictEqual(dec.decode(await bytes(stream)), 'x');
+      quicSession.close();
+    });
+  }), serverOpts);
+
+  const client = await connect(endpoint.address, clientOpts);
+  let raw;
+  const settings = {
+    get maxHeaderPairs() {
+      raw = client.createUnidirectionalStream({ body: enc.encode('x') });
+      return 10n;
+    },
+  };
+  assert.throws(() => new Http3Session(client, { settings }), tooLate);
+  await (await raw).closed;
+  await client.close();
+  await endpoint.close();
+}
+{
+  // Client: the getter attaches another Http3Session. That inner attach is
+  // the one that sticks; the outer one finds the session already claimed.
+  const endpoint = await listen(mustCall((quicSession) => {
+    new Http3Session(quicSession);
+  }), serverOpts);
+
+  const client = await connect(endpoint.address, clientOpts);
+  let inner;
+  const settings = {
+    get maxHeaderPairs() { inner = new Http3Session(client); return 10n; },
+  };
+  assert.throws(() => new Http3Session(client, { settings }), {
+    code: 'ERR_INVALID_STATE',
+    message: /already has an application/,
+  });
+  assert.ok(inner instanceof Http3Session);
+  assert.throws(() => new Http3Session(client), {
+    code: 'ERR_INVALID_STATE',
+    message: /already has an application/,
+  });
+  await client.opened;
+  await client.close();
+  await endpoint.close();
+}
+
+// HTTP/3 has no server-initiated request streams, so a server session must
+// refuse to open one however it is asked.
+{
+  const refused = Promise.withResolvers();
+  const endpoint = await listen(mustCall((quicSession) => {
+    const server = new Http3Session(quicSession);
+    assert.throws(() => server.createBidirectionalStream(), {
+      code: 'ERR_INVALID_STATE',
+      message: /Server sessions cannot open HTTP\/3 request streams/,
+    });
+    refused.resolve();
+  }), serverOpts);
+  const client = new Http3Session(await connect(endpoint.address, clientOpts));
+  await refused.promise;
+  await client.close();
+  await endpoint.close();
+}
diff --git a/test/parallel/test-quic-h3-callback-errors.mjs b/test/parallel/test-quic-h3-callback-errors.mjs
index be8ed391b8d5..9fbd64ab0a44 100644
--- a/test/parallel/test-quic-h3-callback-errors.mjs
+++ b/test/parallel/test-quic-h3-callback-errors.mjs
@@ -15,7 +15,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 
 const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
@@ -24,7 +24,8 @@ const encoder = new TextEncoder();
 
 async function makeServer(onheadersHandler, extraOpts = {}) {
   const done = Promise.withResolvers();
-  const ep = await listen(mustCall(async (ss) => {
+  const ep = await listen(mustCall(async (quicSession) => {
+    const ss = new Http3Session(quicSession);
     ss.onstream = mustCall((stream) => {
       // The server completes its response before the client's
       // callback throws, so the server stream always resolves.
@@ -33,6 +34,7 @@ async function makeServer(onheadersHandler, extraOpts = {}) {
     await ss.closed;
     done.resolve();
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     transportParams: { maxIdleTimeout: 1 },
     onheaders: onheadersHandler,
@@ -51,11 +53,12 @@ async function makeServer(onheadersHandler, extraOpts = {}) {
     }),
   );
 
-  const c = await connect(ep.address, {
+  const c = new Http3Session(await connect(ep.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
     transportParams: { maxIdleTimeout: 1 },
-  });
+  }));
   await c.opened;
 
   const s = await c.createBidirectionalStream({
@@ -91,11 +94,12 @@ async function makeServer(onheadersHandler, extraOpts = {}) {
     }),
   );
 
-  const c = await connect(ep.address, {
+  const c = new Http3Session(await connect(ep.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
     transportParams: { maxIdleTimeout: 1 },
-  });
+  }));
   await c.opened;
 
   const s = await c.createBidirectionalStream({
@@ -136,11 +140,12 @@ async function makeServer(onheadersHandler, extraOpts = {}) {
     },
   );
 
-  const c = await connect(ep.address, {
+  const c = new Http3Session(await connect(ep.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
     transportParams: { maxIdleTimeout: 1 },
-  });
+  }));
   await c.opened;
 
   const s = await c.createBidirectionalStream({
@@ -171,9 +176,11 @@ async function makeServer(onheadersHandler, extraOpts = {}) {
 
 // Sync throw in onorigin callback destroys the session.
 {
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const ss = new Http3Session(quicSession);
     await ss.closed;
   }), {
+    alpn: ['h3'],
     sni: {
       '*': { keys: [key], certs: [cert] },
       'example.com': { keys: [key], certs: [cert] },
@@ -185,17 +192,19 @@ async function makeServer(onheadersHandler, extraOpts = {}) {
     },
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const quicSession = await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'example.com',
     verifyPeer: 'manual',
     transportParams: { maxIdleTimeout: 1 },
-    onorigin: mustCall(function() {
-      throw new Error('onorigin error');
-    }),
     onerror: mustCall(function(error) {
       assert.strictEqual(error.message, 'onorigin error');
     }),
+    onorigin: mustCall(function() {
+      throw new Error('onorigin error');
+    }),
   });
+  const clientSession = new Http3Session(quicSession);
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
@@ -226,7 +235,8 @@ async function makeServer(onheadersHandler, extraOpts = {}) {
   const serverStreamRejected = Promise.withResolvers();
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const ss = new Http3Session(quicSession);
     ss.onstream = mustCall(async (stream) => {
       // The server stream rejects because onwanttrailers threw.
       await assert.rejects(stream.closed, mustCall((err) => {
@@ -238,6 +248,7 @@ async function makeServer(onheadersHandler, extraOpts = {}) {
     await ss.closed;
     serverDone.resolve();
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     transportParams: { maxIdleTimeout: 1 },
     onheaders: mustCall(function(headers) {
@@ -250,11 +261,12 @@ async function makeServer(onheadersHandler, extraOpts = {}) {
     }),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
     transportParams: { maxIdleTimeout: 1 },
-  });
+  }));
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
diff --git a/test/parallel/test-quic-h3-close-behavior.mjs b/test/parallel/test-quic-h3-close-behavior.mjs
index e3b73ce9b0b9..20292ffb8ca1 100644
--- a/test/parallel/test-quic-h3-close-behavior.mjs
+++ b/test/parallel/test-quic-h3-close-behavior.mjs
@@ -12,7 +12,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -27,10 +27,12 @@ const decoder = new TextDecoder();
   let requestCount = 0;
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const ss = new Http3Session(quicSession);
     serverSession = ss;
     ss.onstream = mustCall(2);
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     onheaders: mustCall((headers, stream) => {
       stream.sendHeaders({ ':status': '200' });
@@ -48,10 +50,11 @@ const decoder = new TextDecoder();
     }, 2),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  });
+  }));
   await clientSession.opened;
 
   const stream1 = await clientSession.createBidirectionalStream({
diff --git a/test/parallel/test-quic-h3-concurrent-requests.mjs b/test/parallel/test-quic-h3-concurrent-requests.mjs
index 5bd5635008ca..5ec48540dfe6 100644
--- a/test/parallel/test-quic-h3-concurrent-requests.mjs
+++ b/test/parallel/test-quic-h3-concurrent-requests.mjs
@@ -16,7 +16,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -29,7 +29,8 @@ const REQUEST_COUNT = 5;
 let serverStreamsCompleted = 0;
 const serverDone = Promise.withResolvers();
 
-const serverEndpoint = await listen(mustCall(async (serverSession) => {
+const serverEndpoint = await listen(mustCall(async (quicSession) => {
+  const serverSession = new Http3Session(quicSession);
   serverSession.onstream = mustCall((stream) => {
     stream.closed.then(mustCall(() => {
       if (++serverStreamsCompleted === REQUEST_COUNT) {
@@ -39,6 +40,7 @@ const serverEndpoint = await listen(mustCall(async (serverSession) => {
     }));
   }, REQUEST_COUNT);
 }), {
+  alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
   onheaders: mustCall(function(headers) {
     const path = headers[':path'];
@@ -52,10 +54,11 @@ const serverEndpoint = await listen(mustCall(async (serverSession) => {
   }, REQUEST_COUNT),
 });
 
-const clientSession = await connect(serverEndpoint.address, {
+const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-});
+}));
 await clientSession.opened;
 
 // Open all requests concurrently.
diff --git a/test/parallel/test-quic-h3-datagram.mjs b/test/parallel/test-quic-h3-datagram.mjs
index 38aeb971c8fe..55eb13e107b6 100644
--- a/test/parallel/test-quic-h3-datagram.mjs
+++ b/test/parallel/test-quic-h3-datagram.mjs
@@ -15,7 +15,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 const { setTimeout: sleep } = await import('timers/promises');
@@ -31,7 +31,10 @@ const decoder = new TextDecoder();
   const clientGotDatagram = Promise.withResolvers();
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const ss = new Http3Session(quicSession, {
+      settings: { enableDatagrams: true },
+    });
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
     });
@@ -40,8 +43,8 @@ const decoder = new TextDecoder();
     ss.close();
     serverDone.resolve();
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
-    application: { enableDatagrams: true },
     transportParams: { maxDatagramFrameSize: 100 },
     // Server echoes received datagram back to client.
     ondatagram: mustCall(function(data) {
@@ -61,10 +64,10 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const quicSession = await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-    application: { enableDatagrams: true },
     transportParams: { maxDatagramFrameSize: 100 },
     // Client receives datagram from server.
     ondatagram: mustCall(function(data) {
@@ -76,6 +79,7 @@ const decoder = new TextDecoder();
       clientGotDatagram.resolve();
     }),
   });
+  const clientSession = new Http3Session(quicSession, { settings: { enableDatagrams: true } });
   await clientSession.opened;
 
   // Datagrams work alongside H3 request/response.
@@ -92,7 +96,7 @@ const decoder = new TextDecoder();
   });
 
   // Send datagram from client.
-  await clientSession.sendDatagram(new Uint8Array([10, 20, 30]));
+  await clientSession.quicSession.sendDatagram(new Uint8Array([10, 20, 30]));
 
   // H3 response body is received.
   const body = await bytes(stream);
@@ -114,16 +118,19 @@ const decoder = new TextDecoder();
 {
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    // Server explicitly disables H3 datagrams.
+    const ss = new Http3Session(quicSession, {
+      settings: { enableDatagrams: false },
+    });
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       ss.close();
       serverDone.resolve();
     });
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
-    // Server explicitly disables H3 datagrams.
-    application: { enableDatagrams: false },
     // But transport-level datagrams ARE supported.
     transportParams: { maxDatagramFrameSize: 100 },
     // Server should NOT receive any datagrams.
@@ -135,12 +142,13 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const quicSession = await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-    application: { enableDatagrams: true },
     transportParams: { maxDatagramFrameSize: 100 },
   });
+  const clientSession = new Http3Session(quicSession, { settings: { enableDatagrams: true } });
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
@@ -163,7 +171,8 @@ const decoder = new TextDecoder();
 
   // 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]));
+  const dgId =
+    await clientSession.quicSession.sendDatagram(new Uint8Array([1, 2, 3]));
   assert.strictEqual(dgId, 0n);
 
   await Promise.all([stream.closed, serverDone.promise]);
diff --git a/test/parallel/test-quic-h3-error-codes.mjs b/test/parallel/test-quic-h3-error-codes.mjs
index 3a91a2e8f056..12d3a7043255 100644
--- a/test/parallel/test-quic-h3-error-codes.mjs
+++ b/test/parallel/test-quic-h3-error-codes.mjs
@@ -12,7 +12,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -25,7 +25,8 @@ const decoder = new TextDecoder();
 {
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const ss = new Http3Session(quicSession);
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       // Close with an explicit H3 application error code.
@@ -33,6 +34,7 @@ const decoder = new TextDecoder();
       serverDone.resolve();
     });
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     onheaders: mustCall(function(headers) {
       this.sendHeaders({ ':status': '200' });
@@ -41,10 +43,11 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  });
+  }));
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
@@ -77,13 +80,15 @@ const decoder = new TextDecoder();
 {
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const ss = new Http3Session(quicSession);
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       ss.close();
       serverDone.resolve();
     });
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     onheaders: mustCall(function(headers) {
       this.sendHeaders({ ':status': '200' });
@@ -92,10 +97,11 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  });
+  }));
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
diff --git a/test/parallel/test-quic-h3-flow-control-volume.mjs b/test/parallel/test-quic-h3-flow-control-volume.mjs
index e422d1a411ad..ebe8cf58a8e0 100644
--- a/test/parallel/test-quic-h3-flow-control-volume.mjs
+++ b/test/parallel/test-quic-h3-flow-control-volume.mjs
@@ -24,7 +24,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { makePayload, hashBytes } = await import('../common/quic.mjs');
 const { bytes } = await import('stream/iter');
@@ -48,7 +48,8 @@ assert.notStrictEqual(requestHash, responseHash);
 
 const serverDone = Promise.withResolvers();
 
-const serverEndpoint = await listen(mustCall(async (serverSession) => {
+const serverEndpoint = await listen(mustCall(async (quicSession) => {
+  const serverSession = new Http3Session(quicSession);
   serverSession.onstream = mustCall(async (stream) => {
     // Read the large request body. This is the path where DATA payload
     // credit is deferred until consumption.
@@ -62,6 +63,7 @@ const serverEndpoint = await listen(mustCall(async (serverSession) => {
     serverDone.resolve();
   });
 }), {
+  alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
   transportParams: {
     initialMaxStreamDataBidiRemote: kStreamWindow,
@@ -78,7 +80,8 @@ const serverEndpoint = await listen(mustCall(async (serverSession) => {
   }),
 });
 
-const clientSession = await connect(serverEndpoint.address, {
+const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
   transportParams: {
@@ -87,7 +90,7 @@ const clientSession = await connect(serverEndpoint.address, {
   },
   maxStreamWindow: kStreamWindow,
   maxWindow: kConnWindow,
-});
+}));
 
 const info = await clientSession.opened;
 assert.strictEqual(info.protocol, 'h3');
diff --git a/test/parallel/test-quic-h3-goaway.mjs b/test/parallel/test-quic-h3-goaway.mjs
index bb0bf8e966c1..cc1a625c882d 100644
--- a/test/parallel/test-quic-h3-goaway.mjs
+++ b/test/parallel/test-quic-h3-goaway.mjs
@@ -19,7 +19,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -42,10 +42,12 @@ dc.subscribe('quic.session.goaway', mustCall((msg) => {
   const bothHeadersReceived = Promise.withResolvers();
   let clientHeaderCount = 0;
 
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const ss = new Http3Session(quicSession);
     serverSession = ss;
     ss.onstream = mustCall(2);
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     onheaders: mustCall(function(headers) {
       const path = headers[':path'];
@@ -66,7 +68,8 @@ dc.subscribe('quic.session.goaway', mustCall((msg) => {
     }, 2),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const quicSession = await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
     // Ongoaway fires when the peer sends GOAWAY.
@@ -75,6 +78,7 @@ dc.subscribe('quic.session.goaway', mustCall((msg) => {
       goawayReceived.resolve();
     }),
   });
+  const clientSession = new Http3Session(quicSession);
   await clientSession.opened;
 
   const onClientHeaders = mustCall(function(headers) {
diff --git a/test/parallel/test-quic-h3-handshake-failure.mjs b/test/parallel/test-quic-h3-handshake-failure.mjs
index 201d3999d65a..351e738f32b9 100644
--- a/test/parallel/test-quic-h3-handshake-failure.mjs
+++ b/test/parallel/test-quic-h3-handshake-failure.mjs
@@ -7,9 +7,9 @@
 // assertion failure in nghttp3 (conn->tx.ctrl != NULL).
 //
 // The test creates an H3 server and a client that immediately closes the
-// session before the handshake completes. The server creates the H3
-// application during ALPN negotiation, but Start() (which binds control
-// streams) hasn't been called yet when the session is torn down.
+// session before the handshake completes. The server attaches the H3
+// application, but Start() (which binds control streams) hasn't
+// been called yet when the session is torn down.
 // The server must handle this gracefully without crashing.
 
 import { hasQuic, skip, mustNotCall } from '../common/index.mjs';
@@ -20,15 +20,17 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 
 const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
 const cert = fixtures.readKey('agent1-cert.pem');
 
-const serverEndpoint = await listen(async (serverSession) => {
+const serverEndpoint = await listen(async (quicSession) => {
+  const serverSession = new Http3Session(quicSession);
   await serverSession.closed;
 }, {
+  alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
   onheaders: mustNotCall(),
 });
@@ -36,12 +38,13 @@ const serverEndpoint = await listen(async (serverSession) => {
 // Connect then immediately close the session before the handshake completes.
 // This exercises the H3 shutdown path on the server while the H3 application
 // exists but hasn't started (control streams not yet bound).
-const clientSession = await connect(serverEndpoint.address, {
+const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
   // h3 ALPN — must match the server so the H3 application is selected
   // on the server side before we tear it down.
-});
+}));
 
 // Close immediately — don't wait for handshake.
 await clientSession.close();
diff --git a/test/parallel/test-quic-h3-header-interest.mjs b/test/parallel/test-quic-h3-header-interest.mjs
index 4fe05b6f6d3e..7aa5162bd4c9 100644
--- a/test/parallel/test-quic-h3-header-interest.mjs
+++ b/test/parallel/test-quic-h3-header-interest.mjs
@@ -12,7 +12,7 @@ if (!hasQuic) {
 }
 
 const { createPrivateKey } = await import('node:crypto');
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { bytes } = await import('stream/iter');
 
 const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
@@ -21,13 +21,15 @@ const encoder = new TextEncoder();
 const decoder = new TextDecoder();
 const serverDone = Promise.withResolvers();
 
-const serverEndpoint = await listen(mustCall(async (serverSession) => {
+const serverEndpoint = await listen(mustCall(async (quicSession) => {
+  const serverSession = new Http3Session(quicSession);
   serverSession.onstream = mustCall(async (stream) => {
     await stream.closed;
     serverSession.close();
     serverDone.resolve();
   });
 }), {
+  alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
   onheaders: mustCall(function() {
     this.sendInformationalHeaders({
@@ -42,10 +44,12 @@ const serverEndpoint = await listen(mustCall(async (serverSession) => {
   }),
 });
 
-const clientSession = await connect(serverEndpoint.address, {
+const quicSession = await connect(serverEndpoint.address, {
+  alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
 });
+const clientSession = new Http3Session(quicSession);
 await clientSession.opened;
 
 const infoReceived = Promise.withResolvers();
diff --git a/test/parallel/test-quic-h3-header-validation.mjs b/test/parallel/test-quic-h3-header-validation.mjs
index a75a884c39b9..3ea5965a942c 100644
--- a/test/parallel/test-quic-h3-header-validation.mjs
+++ b/test/parallel/test-quic-h3-header-validation.mjs
@@ -21,7 +21,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -35,13 +35,15 @@ const decoder = new TextDecoder();
 {
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const ss = new Http3Session(quicSession);
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       ss.close();
       serverDone.resolve();
     });
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     onheaders: mustCall(function(headers) {
       // H3V-01: All header names should be lowercase regardless
@@ -72,10 +74,11 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  });
+  }));
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
@@ -114,13 +117,15 @@ const decoder = new TextDecoder();
 {
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const ss = new Http3Session(quicSession);
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       ss.close();
       serverDone.resolve();
     });
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     onheaders: mustCall(function(headers) {
       // All four required pseudo-headers present.
@@ -134,10 +139,11 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  });
+  }));
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
diff --git a/test/parallel/test-quic-h3-informational-headers.mjs b/test/parallel/test-quic-h3-informational-headers.mjs
index 357b507ae0db..a5b1c9ad3330 100644
--- a/test/parallel/test-quic-h3-informational-headers.mjs
+++ b/test/parallel/test-quic-h3-informational-headers.mjs
@@ -19,7 +19,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -45,13 +45,15 @@ dc.subscribe('quic.stream.headers', mustCall((msg) => {
 
 const serverDone = Promise.withResolvers();
 
-const serverEndpoint = await listen(mustCall(async (serverSession) => {
+const serverEndpoint = await listen(mustCall(async (quicSession) => {
+  const serverSession = new Http3Session(quicSession);
   serverSession.onstream = mustCall(async (stream) => {
     await stream.closed;
     serverSession.close();
     serverDone.resolve();
   });
 }), {
+  alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
   onheaders: mustCall(function(headers) {
     // Send 103 Early Hints before the final response.
@@ -72,10 +74,11 @@ const serverEndpoint = await listen(mustCall(async (serverSession) => {
   }),
 });
 
-const clientSession = await connect(serverEndpoint.address, {
+const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-});
+}));
 await clientSession.opened;
 
 const clientInfoReceived = Promise.withResolvers();
diff --git a/test/parallel/test-quic-h3-maxstreamdata-external-buffer-failure.mjs b/test/parallel/test-quic-h3-maxstreamdata-external-buffer-failure.mjs
index df74e4db408b..4a7b8a125fe6 100644
--- a/test/parallel/test-quic-h3-maxstreamdata-external-buffer-failure.mjs
+++ b/test/parallel/test-quic-h3-maxstreamdata-external-buffer-failure.mjs
@@ -11,7 +11,7 @@ import { setTimeout as sleep } from 'node:timers/promises';
 if (!hasQuic) {
   skip('QUIC is not enabled');
 }
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { drainableProtocol } = await import('stream/iter');
 
@@ -30,13 +30,15 @@ const BODY = WINDOW - 11;
 let letServerRead;
 const serverMayRead = new Promise((resolve) => { letServerRead = resolve; });
 
-const endpoint = await listen((session) => {
+const endpoint = await listen((quicSession) => {
+  const session = new Http3Session(quicSession);
   session.onstream = async (stream) => {
     await serverMayRead;
     // eslint-disable-next-line no-unused-vars
     for await (const _ of stream) { /* reading extends the window */ }
   };
 }, {
+  alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
   transportParams: {
     initialMaxStreamDataBidiRemote: WINDOW,
@@ -45,10 +47,11 @@ const endpoint = await listen((session) => {
   onheaders() { this.sendHeaders({ ':status': '200' }); },
 });
 
-const session = await connect(endpoint.address, {
+const session = new Http3Session(await connect(endpoint.address, {
+  alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-});
+}));
 await session.opened;
 
 // Budget well above the window, so the window is what stops the writer.
diff --git a/test/parallel/test-quic-h3-origin.mjs b/test/parallel/test-quic-h3-origin.mjs
index 9f80449b6b65..970072378806 100644
--- a/test/parallel/test-quic-h3-origin.mjs
+++ b/test/parallel/test-quic-h3-origin.mjs
@@ -13,7 +13,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -29,13 +29,15 @@ const decoder = new TextDecoder();
   const originReceived = Promise.withResolvers();
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const ss = new Http3Session(quicSession);
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       ss.close();
       serverDone.resolve();
     });
   }), {
+    alpn: ['h3'],
     sni: {
       // Wildcard entry should NOT appear in ORIGIN frame.
       '*': { keys: [key], certs: [cert] },
@@ -50,7 +52,8 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const quicSession = await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'example.com',
     verifyPeer: 'manual',
     // Client receives ORIGIN frame via onorigin callback.
@@ -67,6 +70,7 @@ const decoder = new TextDecoder();
       originReceived.resolve();
     }),
   });
+  const clientSession = new Http3Session(quicSession);
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
@@ -97,13 +101,15 @@ const decoder = new TextDecoder();
   const originReceived = Promise.withResolvers();
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const ss = new Http3Session(quicSession);
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       ss.close();
       serverDone.resolve();
     });
   }), {
+    alpn: ['h3'],
     sni: {
       '*': { keys: [key], certs: [cert] },
       // Non-default port → origin includes port.
@@ -128,7 +134,8 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const quicSession = await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'custom-port.example.com',
     verifyPeer: 'manual',
     onorigin: mustCall(function(origins) {
@@ -163,6 +170,7 @@ const decoder = new TextDecoder();
       originReceived.resolve();
     }),
   });
+  const clientSession = new Http3Session(quicSession);
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
diff --git a/test/parallel/test-quic-h3-pending-stream.mjs b/test/parallel/test-quic-h3-pending-stream.mjs
index a6e9c8cfd912..5bec314b9a55 100644
--- a/test/parallel/test-quic-h3-pending-stream.mjs
+++ b/test/parallel/test-quic-h3-pending-stream.mjs
@@ -12,7 +12,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -26,13 +26,15 @@ const decoder = new TextDecoder();
 {
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const ss = new Http3Session(quicSession);
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       ss.close();
       serverDone.resolve();
     });
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     onheaders: mustCall(function(headers) {
       // Headers were enqueued before the stream opened
@@ -46,10 +48,11 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  });
+  }));
 
   // Create the stream BEFORE awaiting opened. The stream is pending
   // until the handshake completes and the QUIC stream can be opened.
diff --git a/test/parallel/test-quic-h3-post-filehandle.mjs b/test/parallel/test-quic-h3-post-filehandle.mjs
index a4c583463d24..91809031bbf5 100644
--- a/test/parallel/test-quic-h3-post-filehandle.mjs
+++ b/test/parallel/test-quic-h3-post-filehandle.mjs
@@ -17,7 +17,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -35,7 +35,8 @@ writeFileSync(testFile, testContent);
 {
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (serverSession) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const serverSession = new Http3Session(quicSession);
     serverSession.onstream = mustCall(async (stream) => {
       const body = await bytes(stream);
       assert.strictEqual(decoder.decode(body), testContent);
@@ -45,6 +46,7 @@ writeFileSync(testFile, testContent);
       serverDone.resolve();
     });
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     onheaders: mustCall(function(headers) {
       assert.strictEqual(headers[':method'], 'POST');
@@ -56,10 +58,11 @@ writeFileSync(testFile, testContent);
     }),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  });
+  }));
 
   const info = await clientSession.opened;
   assert.strictEqual(info.protocol, 'h3');
diff --git a/test/parallel/test-quic-h3-post-request.mjs b/test/parallel/test-quic-h3-post-request.mjs
index c5d9635a640c..527200904be8 100644
--- a/test/parallel/test-quic-h3-post-request.mjs
+++ b/test/parallel/test-quic-h3-post-request.mjs
@@ -17,7 +17,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -30,7 +30,8 @@ const requestBody = 'Hello from the client';
 
 const serverDone = Promise.withResolvers();
 
-const serverEndpoint = await listen(mustCall(async (serverSession) => {
+const serverEndpoint = await listen(mustCall(async (quicSession) => {
+  const serverSession = new Http3Session(quicSession);
   serverSession.onstream = mustCall(async (stream) => {
     // Read the full request body from the client.
     const body = await bytes(stream);
@@ -42,6 +43,7 @@ const serverEndpoint = await listen(mustCall(async (serverSession) => {
     serverDone.resolve();
   });
 }), {
+  alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
   onheaders: mustCall(function(headers) {
     assert.strictEqual(headers[':method'], 'POST');
@@ -63,10 +65,11 @@ const serverEndpoint = await listen(mustCall(async (serverSession) => {
   }),
 });
 
-const clientSession = await connect(serverEndpoint.address, {
+const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-});
+}));
 
 const info = await clientSession.opened;
 assert.strictEqual(info.protocol, 'h3');
diff --git a/test/parallel/test-quic-h3-priority.mjs b/test/parallel/test-quic-h3-priority.mjs
index 10be3d6f216e..007a1d475c95 100644
--- a/test/parallel/test-quic-h3-priority.mjs
+++ b/test/parallel/test-quic-h3-priority.mjs
@@ -17,7 +17,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -30,7 +30,8 @@ const decoder = new TextDecoder();
   let requestCount = 0;
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const ss = new Http3Session(quicSession);
     ss.onstream = mustCall((stream) => {
       // Server sees priority on the stream.
       const pri = stream.priority;
@@ -39,6 +40,7 @@ const decoder = new TextDecoder();
       assert.strictEqual(typeof pri.incremental, 'boolean');
     }, 4);
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     onheaders: mustCall(function(headers) {
       this.sendHeaders({ ':status': '200' });
@@ -50,10 +52,11 @@ const decoder = new TextDecoder();
     }, 4),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  });
+  }));
   await clientSession.opened;
 
   // Priority set at creation time via options.
@@ -162,7 +165,8 @@ const decoder = new TextDecoder();
   const serverSawHighPriority = Promise.withResolvers();
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const ss = new Http3Session(quicSession);
     ss.onstream = mustCall(async (stream) => {
       // Read the request body — this acts as a signal that the
       // client's PRIORITY_UPDATE has been sent. The control stream
@@ -182,6 +186,7 @@ const decoder = new TextDecoder();
       serverDone.resolve();
     });
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     onheaders: mustCall(function(headers) {
       this.sendHeaders({ ':status': '200' });
@@ -190,10 +195,11 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  });
+  }));
   await clientSession.opened;
 
   // Create stream with default priority and a body. The body serves
diff --git a/test/parallel/test-quic-h3-qpack-settings.mjs b/test/parallel/test-quic-h3-qpack-settings.mjs
index f30b7163cf6b..e965cfac9618 100644
--- a/test/parallel/test-quic-h3-qpack-settings.mjs
+++ b/test/parallel/test-quic-h3-qpack-settings.mjs
@@ -17,7 +17,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -50,12 +50,15 @@ async function makeRequest(clientSession, path) {
   const serverDone = Promise.withResolvers();
   let requestCount = 0;
 
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    // Server disables QPACK dynamic table.
+    const ss = new Http3Session(quicSession, {
+      settings: { qpackMaxDTableCapacity: 0, qpackBlockedStreams: 0 },
+    });
     ss.onstream = mustCall(2);
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
-    // Server disables QPACK dynamic table.
-    application: { qpackMaxDTableCapacity: 0, qpackBlockedStreams: 0 },
     onheaders: mustCall(function(headers) {
       this.sendHeaders({ ':status': '200' });
       this.writer.writeSync(encoder.encode(headers[':path']));
@@ -66,11 +69,14 @@ async function makeRequest(clientSession, path) {
     }, 2),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  // Client also disables QPACK dynamic table.
+  const quicSession = await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-    // Client also disables QPACK dynamic table.
-    application: { qpackMaxDTableCapacity: 0, qpackBlockedStreams: 0 },
+  });
+  const clientSession = new Http3Session(quicSession, {
+    settings: { qpackMaxDTableCapacity: 0, qpackBlockedStreams: 0 },
   });
   await clientSession.opened;
 
@@ -89,11 +95,14 @@ async function makeRequest(clientSession, path) {
   const serverDone = Promise.withResolvers();
   let requestCount = 0;
 
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const ss = new Http3Session(quicSession, {
+      settings: { qpackMaxDTableCapacity: 8192, qpackBlockedStreams: 200 },
+    });
     ss.onstream = mustCall(2);
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
-    application: { qpackMaxDTableCapacity: 8192, qpackBlockedStreams: 200 },
     onheaders: mustCall(function(headers) {
       this.sendHeaders({ ':status': '200' });
       this.writer.writeSync(encoder.encode(headers[':path']));
@@ -104,10 +113,13 @@ async function makeRequest(clientSession, path) {
     }, 2),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const quicSession = await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-    application: { qpackMaxDTableCapacity: 8192, qpackBlockedStreams: 200 },
+  });
+  const clientSession = new Http3Session(quicSession, {
+    settings: { qpackMaxDTableCapacity: 8192, qpackBlockedStreams: 200 },
   });
   await clientSession.opened;
 
diff --git a/test/parallel/test-quic-h3-request-rejected.mjs b/test/parallel/test-quic-h3-request-rejected.mjs
index 6ed987b395af..82d6c22945c4 100644
--- a/test/parallel/test-quic-h3-request-rejected.mjs
+++ b/test/parallel/test-quic-h3-request-rejected.mjs
@@ -14,7 +14,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 
 const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
@@ -25,16 +25,19 @@ const H3_REQUEST_REJECTED = 0x10bn;
 
 // The server registers no stream consumer, so an incoming request stream
 // is rejected on arrival.
-const serverEndpoint = await listen(mustCall((serverSession) => {
+const serverEndpoint = await listen(mustCall((quicSession) => {
+  const serverSession = new Http3Session(quicSession);
   serverSession.onerror = () => {};
 }), {
+  alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
 });
 
-const clientSession = await connect(serverEndpoint.address, {
+const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-});
+}));
 await clientSession.opened;
 
 const reset = Promise.withResolvers();
diff --git a/test/parallel/test-quic-h3-request-response.mjs b/test/parallel/test-quic-h3-request-response.mjs
index cde16684d7e9..f868629d1456 100644
--- a/test/parallel/test-quic-h3-request-response.mjs
+++ b/test/parallel/test-quic-h3-request-response.mjs
@@ -17,7 +17,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -34,18 +34,18 @@ const serverDone = Promise.withResolvers();
 // to the stream. A regular function is used so `this` is accessible.
 // safeCallbackInvoke(fn, owner, ...args) consumes the owner for error
 // handling and forwards only ...args to fn.
-const serverEndpoint = await listen(mustCall(async (serverSession) => {
+const serverEndpoint = await listen(mustCall(async (quicSession) => {
+  const serverSession = new Http3Session(quicSession);
   serverSession.onstream = mustCall(async (stream) => {
     await stream.closed;
     serverSession.close();
     serverDone.resolve();
   });
 }), {
+  alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
-  // Default ALPN is h3 — omitted intentionally to exercise the default.
-  //
-  // onheaders is provided via listen options so it is applied to
-  // incoming streams (via kStreamCallbacks) BEFORE onstream fires.
+  // The onheaders callback is provided via listen options so it is applied
+  // to incoming streams (via kStreamCallbacks) BEFORE onstream fires.
   // For H3, onheaders must be set because the H3 application delivers
   // headers and stream[kHeaders] asserts the callback exists.
   onheaders: mustCall(function(headers) {
@@ -72,11 +72,11 @@ const serverEndpoint = await listen(mustCall(async (serverSession) => {
   }),
 });
 
-const clientSession = await connect(serverEndpoint.address, {
+const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-  // Default ALPN is h3.
-});
+}));
 
 const info = await clientSession.opened;
 assert.strictEqual(info.protocol, 'h3');
diff --git a/test/parallel/test-quic-h3-settings.mjs b/test/parallel/test-quic-h3-settings.mjs
index 733d3865e872..f74856cfa83c 100644
--- a/test/parallel/test-quic-h3-settings.mjs
+++ b/test/parallel/test-quic-h3-settings.mjs
@@ -14,7 +14,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -29,16 +29,19 @@ const decoder = new TextDecoder();
 {
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    // Allow 5 header pairs: 4 pseudo-headers + 1 custom.
+    const ss = new Http3Session(quicSession, {
+      settings: { maxHeaderPairs: 5 },
+    });
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       ss.close();
       serverDone.resolve();
     });
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
-    // Allow 5 header pairs: 4 pseudo-headers + 1 custom.
-    application: { maxHeaderPairs: 5 },
     onheaders: mustCall(function(headers) {
       assert.strictEqual(headers[':method'], 'GET');
       assert.strictEqual(headers[':path'], '/limited');
@@ -55,10 +58,11 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  });
+  }));
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
@@ -91,17 +95,20 @@ const decoder = new TextDecoder();
   const serverDone = Promise.withResolvers();
   const longValue = 'x'.repeat(200);
 
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    // Limit total header bytes. The 4 pseudo-headers fit within 100
+    // bytes, but adding x-long (6 + 200 = 206 bytes) exceeds it.
+    const ss = new Http3Session(quicSession, {
+      settings: { maxHeaderLength: 100 },
+    });
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       ss.close();
       serverDone.resolve();
     });
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
-    // Limit total header bytes. The 4 pseudo-headers fit within 100
-    // bytes, but adding x-long (6 + 200 = 206 bytes) exceeds it.
-    application: { maxHeaderLength: 100 },
     onheaders: mustCall(function(headers) {
       assert.strictEqual(headers[':method'], 'GET');
       assert.strictEqual(headers[':path'], '/length-limited');
@@ -114,10 +121,11 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  });
+  }));
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
@@ -145,33 +153,39 @@ const decoder = new TextDecoder();
 {
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (ss) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const ss = new Http3Session(quicSession, {
+      settings: { enableConnectProtocol: true, enableDatagrams: true },
+      onsettings: mustCall((appopt) => {
+        assert.strictEqual(appopt.enableDatagrams, true);
+        assert.strictEqual(appopt.enableConnectProtocol, false);
+        // Must be false, as this is only sent from server side
+      }),
+    });
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       ss.close();
       serverDone.resolve();
     });
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
-    application: { enableConnectProtocol: true, enableDatagrams: true },
     onheaders: mustCall(function(headers) {
       this.sendHeaders({ ':status': '200' });
       this.writer.writeSync(encoder.encode('settings-ok'));
       this.writer.endSync();
     }),
-    onapplication: mustCall((appopt) => {
-      assert.strictEqual(appopt.enableDatagrams, true);
-      assert.strictEqual(appopt.enableConnectProtocol, false);
-      // Must be false, as this is only sent from server side
-    })
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const quicSession = await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-    application: { enableConnectProtocol: true, enableDatagrams: true },
   });
-  clientSession.onapplication = mustCall((appopt) => {
+  const clientSession = new Http3Session(quicSession, {
+    settings: { enableConnectProtocol: true, enableDatagrams: true },
+  });
+  clientSession.onsettings = mustCall((appopt) => {
     assert.strictEqual(appopt.enableConnectProtocol, true);
     assert.strictEqual(appopt.enableDatagrams, true);
   });
diff --git a/test/parallel/test-quic-h3-status-code-type.mjs b/test/parallel/test-quic-h3-status-code-type.mjs
index a1bc7178e17a..485f6e7e4b83 100644
--- a/test/parallel/test-quic-h3-status-code-type.mjs
+++ b/test/parallel/test-quic-h3-status-code-type.mjs
@@ -11,7 +11,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 
 const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
@@ -21,7 +21,8 @@ const codes = [200, 204, 404];
 let serverResponses = 0;
 const serverDone = Promise.withResolvers();
 
-const serverEndpoint = await listen(mustCall(async (ss) => {
+const serverEndpoint = await listen(mustCall(async (quicSession) => {
+  const ss = new Http3Session(quicSession);
   ss.onstream = mustCall(() => {
     if (++serverResponses === codes.length) {
       ss.close();
@@ -29,6 +30,7 @@ const serverEndpoint = await listen(mustCall(async (ss) => {
     }
   }, codes.length);
 }), {
+  alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
   onheaders: mustCall(function() {
     const status = codes[serverResponses - 1];
@@ -37,10 +39,11 @@ const serverEndpoint = await listen(mustCall(async (ss) => {
   }, codes.length),
 });
 
-const clientSession = await connect(serverEndpoint.address, {
+const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-});
+}));
 await clientSession.opened;
 
 for (const expected of codes) {
diff --git a/test/parallel/test-quic-h3-stream-credit.mjs b/test/parallel/test-quic-h3-stream-credit.mjs
index 276a6ede247a..acf24fbd8bd6 100644
--- a/test/parallel/test-quic-h3-stream-credit.mjs
+++ b/test/parallel/test-quic-h3-stream-credit.mjs
@@ -17,7 +17,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -29,13 +29,15 @@ const kRequests = 6;
 let liveServerStreams = 0;
 let peakLiveServerStreams = 0;
 
-const serverEndpoint = await listen(mustCall((serverSession) => {
+const serverEndpoint = await listen(mustCall((quicSession) => {
+  const serverSession = new Http3Session(quicSession);
   serverSession.onstream = mustCall((stream) => {
     liveServerStreams++;
     peakLiveServerStreams = Math.max(peakLiveServerStreams, liveServerStreams);
     stream.closed.then(mustCall(() => { liveServerStreams--; }));
   }, kRequests);
 }), {
+  alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
   // Only one client-initiated bidi stream may be open at a time.
   transportParams: { initialMaxStreamsBidi: 1 },
@@ -47,10 +49,11 @@ const serverEndpoint = await listen(mustCall((serverSession) => {
   }, kRequests),
 });
 
-const clientSession = await connect(serverEndpoint.address, {
+const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-});
+}));
 
 const info = await clientSession.opened;
 assert.strictEqual(info.protocol, 'h3');
diff --git a/test/parallel/test-quic-h3-stream-destroy-no-resurrect.mjs b/test/parallel/test-quic-h3-stream-destroy-no-resurrect.mjs
index c9e05eb245b1..1e08a318cd14 100644
--- a/test/parallel/test-quic-h3-stream-destroy-no-resurrect.mjs
+++ b/test/parallel/test-quic-h3-stream-destroy-no-resurrect.mjs
@@ -23,7 +23,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { makePayload } = await import('../common/quic.mjs');
 
@@ -41,12 +41,14 @@ const responseBody = makePayload(kResponseSize, 17);
 assert.ok(kResponseSize * kRequests > kConnWindow * 4,
           'aggregate response data must far exceed the connection window');
 
-const serverEndpoint = await listen(mustCall((serverSession) => {
+const serverEndpoint = await listen(mustCall((quicSession) => {
+  const serverSession = new Http3Session(quicSession);
   serverSession.onstream = mustCall((stream) => {
     // The client destroys these early; the truncated write is expected.
     stream.onerror = () => {};
   }, kRequests);
 }), {
+  alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
   onheaders: mustCall(function() {
     this.sendHeaders({ ':status': '200' });
@@ -54,14 +56,15 @@ const serverEndpoint = await listen(mustCall((serverSession) => {
   }, kRequests),
 });
 
-const clientSession = await connect(serverEndpoint.address, {
+const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
   transportParams: {
     initialMaxData: kConnWindow,
     initialMaxStreamDataBidiLocal: kResponseSize * 2,
   },
-});
+}));
 
 // The client opens every stream itself; the server opens none. Any onstream
 // here is a destroyed request stream being resurrected and misreported as
@@ -91,7 +94,8 @@ for (let i = 0; i < kRequests; i++) {
 }
 
 // Exactly one locally-opened stream per request.
-assert.strictEqual(Number(clientSession.stats.bidiOutStreamCount), kRequests);
+assert.strictEqual(Number(clientSession.stats.bidiOutStreamCount),
+                   kRequests);
 
 await clientSession.close();
 await serverEndpoint.close();
diff --git a/test/parallel/test-quic-h3-stream-destroy-with-headers.mjs b/test/parallel/test-quic-h3-stream-destroy-with-headers.mjs
index 2f5739185f99..d0ac441891e3 100644
--- a/test/parallel/test-quic-h3-stream-destroy-with-headers.mjs
+++ b/test/parallel/test-quic-h3-stream-destroy-with-headers.mjs
@@ -12,7 +12,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 
 const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
@@ -20,19 +20,22 @@ const cert = fixtures.readKey('agent1-cert.pem');
 
 const serverDone = Promise.withResolvers();
 
-const serverEndpoint = await listen(mustCall(async (ss) => {
+const serverEndpoint = await listen(mustCall(async (quicSession) => {
+  const ss = new Http3Session(quicSession);
   // The server may or may not see the stream depending on timing.
   // Either way, it should not crash.
   await ss.closed;
   serverDone.resolve();
 }), {
+  alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
 });
 
-const clientSession = await connect(serverEndpoint.address, {
+const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-});
+}));
 await clientSession.opened;
 
 // Create a stream with headers, then immediately destroy it.
diff --git a/test/parallel/test-quic-h3-stream-idle-timeout.mjs b/test/parallel/test-quic-h3-stream-idle-timeout.mjs
index f3e83a8397ca..553f95485aaf 100644
--- a/test/parallel/test-quic-h3-stream-idle-timeout.mjs
+++ b/test/parallel/test-quic-h3-stream-idle-timeout.mjs
@@ -17,7 +17,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 
 const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
@@ -29,7 +29,8 @@ const encoder = new TextEncoder();
 {
   const streamDestroyed = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (serverSession) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const serverSession = new Http3Session(quicSession);
     serverSession.onstream = mustCall(async (stream) => {
       // Don't read — let the stream sit idle after the initial headers.
       // The stream idle timeout should destroy it, rejecting stream.closed.
@@ -39,6 +40,7 @@ const encoder = new TextEncoder();
       streamDestroyed.resolve();
     });
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     streamIdleTimeout: 100,
     onheaders() {
@@ -46,11 +48,12 @@ const encoder = new TextEncoder();
     },
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
     transportParams: { maxIdleTimeout: 1 },
-  });
+  }));
 
   await clientSession.opened;
 
@@ -86,7 +89,8 @@ const encoder = new TextEncoder();
 {
   const serverGotData = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (serverSession) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const serverSession = new Http3Session(quicSession);
     serverSession.onstream = mustCall(async (stream) => {
       const data = await text(stream);
       assert.strictEqual(data, 'xy');
@@ -94,6 +98,7 @@ const encoder = new TextEncoder();
       await serverSession.close();
     });
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     streamIdleTimeout: 500,
     onheaders: mustCall(function(headers) {
@@ -103,10 +108,11 @@ const encoder = new TextEncoder();
     }),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  });
+  }));
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
@@ -136,7 +142,8 @@ const encoder = new TextEncoder();
 {
   const streamSurvived = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (serverSession) => {
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    const serverSession = new Http3Session(quicSession);
     serverSession.onstream = mustCall(async (stream) => {
       const data = await text(stream);
       assert.strictEqual(data, 'xy');
@@ -146,6 +153,7 @@ const encoder = new TextEncoder();
     await setTimeout(700);
     await serverSession.close();
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     streamIdleTimeout: 0,  // Disabled
     onheaders: mustCall(function(headers) {
@@ -153,10 +161,11 @@ const encoder = new TextEncoder();
     }),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  });
+  }));
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
diff --git a/test/parallel/test-quic-h3-stream-without-onstream.mjs b/test/parallel/test-quic-h3-stream-without-onstream.mjs
index fcd5bbe019ba..20ec0350e6d1 100644
--- a/test/parallel/test-quic-h3-stream-without-onstream.mjs
+++ b/test/parallel/test-quic-h3-stream-without-onstream.mjs
@@ -19,7 +19,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { text } = await import('stream/iter');
 
@@ -42,9 +42,11 @@ function failOnConsumerWarning(warning) {
   const serverDone = Promise.withResolvers();
 
   // Note: no `onstream` callback anywhere on this session.
-  const serverEndpoint = await listen(mustCall((serverSession) => {
+  const serverEndpoint = await listen(mustCall((quicSession) => {
+    const serverSession = new Http3Session(quicSession);
     serverSession.onerror = () => {};
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     onheaders: mustCall(function(headers) {
       assert.strictEqual(headers[':path'], '/test');
@@ -59,10 +61,11 @@ function failOnConsumerWarning(warning) {
     }),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  });
+  }));
   await clientSession.opened;
 
   const headersReceived = Promise.withResolvers();
@@ -147,13 +150,19 @@ const kNonConsumerCallbacks = ['oninfo', 'ontrailers', 'onwanttrailers'];
   // QuicStream is not exported; obtain its prototype from a stream instance,
   // then offer every `on*` accessor to listen() and see which ones the
   // session actually attaches to a received stream.
-  const bootstrap = await listen(mustCall((session) => {
+  const bootstrap = await listen(mustCall((quicSession) => {
+    const session = new Http3Session(quicSession);
     session.onerror = () => {};
-  }), { sni: { '*': { keys: [key], certs: [cert] } }, onstream: () => {} });
-  const bootSession = await connect(bootstrap.address, {
+  }), {
+    alpn: ['h3'],
+    sni: { '*': { keys: [key], certs: [cert] } },
+    onstream: () => {},
+  });
+  const bootSession = new Http3Session(await connect(bootstrap.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  });
+  }));
   await bootSession.opened;
   const probeStream = await bootSession.createBidirectionalStream();
   probeStream.onerror = () => {};
@@ -166,21 +175,24 @@ const kNonConsumerCallbacks = ['oninfo', 'ontrailers', 'onwanttrailers'];
   for (const name of candidates) probes[name] = () => {};
 
   const applied = Promise.withResolvers();
-  const serverEndpoint = await listen(mustCall((session) => {
+  const serverEndpoint = await listen(mustCall((quicSession) => {
+    const session = new Http3Session(quicSession);
     session.onerror = () => {};
   }), {
     __proto__: null,
     ...probes,
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     onstream: mustCall((stream) => {
       applied.resolve(candidates.filter((n) => typeof stream[n] === 'function'));
     }),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  });
+  }));
   await clientSession.opened;
   const stream = await clientSession.createBidirectionalStream({
     headers: {
@@ -215,17 +227,20 @@ for (const callbackName of kNonConsumerCallbacks) {
     }
   });
 
-  const serverEndpoint = await listen(mustCall((serverSession) => {
+  const serverEndpoint = await listen(mustCall((quicSession) => {
+    const serverSession = new Http3Session(quicSession);
     serverSession.onerror = () => {};
   }), {
+    alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
     [callbackName]: mustNotCall(),
   });
 
-  const clientSession = await connect(serverEndpoint.address, {
+  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  });
+  }));
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
diff --git a/test/parallel/test-quic-h3-trailing-headers.mjs b/test/parallel/test-quic-h3-trailing-headers.mjs
index f4ffc223d4d5..c6e08b5748d9 100644
--- a/test/parallel/test-quic-h3-trailing-headers.mjs
+++ b/test/parallel/test-quic-h3-trailing-headers.mjs
@@ -18,7 +18,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -47,13 +47,15 @@ dc.subscribe('quic.stream.trailers', mustCall((msg) => {
 
 const serverDone = Promise.withResolvers();
 
-const serverEndpoint = await listen(mustCall(async (serverSession) => {
+const serverEndpoint = await listen(mustCall(async (quicSession) => {
+  const serverSession = new Http3Session(quicSession);
   serverSession.onstream = mustCall(async (stream) => {
     await stream.closed;
     serverSession.close();
     serverDone.resolve();
   });
 }), {
+  alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
   onheaders: mustCall(function(headers) {
     // Send response headers.
@@ -77,10 +79,11 @@ const serverEndpoint = await listen(mustCall(async (serverSession) => {
   }),
 });
 
-const clientSession = await connect(serverEndpoint.address, {
+const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-});
+}));
 await clientSession.opened;
 
 const clientHeadersReceived = Promise.withResolvers();
diff --git a/test/parallel/test-quic-h3-uni-stream-limit-start-failure.mjs b/test/parallel/test-quic-h3-uni-stream-limit-start-failure.mjs
index 78f78ac1d582..bc784d4aa0c9 100644
--- a/test/parallel/test-quic-h3-uni-stream-limit-start-failure.mjs
+++ b/test/parallel/test-quic-h3-uni-stream-limit-start-failure.mjs
@@ -11,7 +11,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 
 const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
@@ -20,19 +20,21 @@ const cert = fixtures.readKey('agent1-cert.pem');
 const serverEndpoint = await listen(async (serverSession) => {
   await serverSession.closed;
 }, {
+  alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
   // No uni streams allowed:
   transportParams: { initialMaxStreamsUni: 0 },
   onheaders: mustNotCall(),
 });
 
-// Expect the client to cleanly fail - not crash the process
-await assert.rejects(async () => {
-  const clientSession = await connect(serverEndpoint.address, {
-    servername: 'localhost',
-    verifyPeer: 'manual',
-  });
-  await clientSession.opened;
-}, { code: 'ERR_QUIC_TRANSPORT_ERROR' });
+const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  alpn: 'h3',
+  servername: 'localhost',
+  verifyPeer: 'manual',
+}));
+
+// Expect the client to cleanly fail & close - not crash the process.
+await assert.rejects(clientSession.closed,
+                     { code: 'ERR_QUIC_TRANSPORT_ERROR' });
 
 await serverEndpoint.close();
diff --git a/test/parallel/test-quic-h3-uni-stream-teardown.mjs b/test/parallel/test-quic-h3-uni-stream-teardown.mjs
index 6f93ef73eb2d..62aebd804c02 100644
--- a/test/parallel/test-quic-h3-uni-stream-teardown.mjs
+++ b/test/parallel/test-quic-h3-uni-stream-teardown.mjs
@@ -1,11 +1,13 @@
 // Flags: --experimental-quic --no-warnings
 
 // Regression test for https://github.com/nodejs/node/issues/65408.
-// A client-created unidirectional stream is not a valid HTTP/3 request stream,
-// but nghttp3 handles it internally. Destroying the endpoint after receiving
-// data on that stream must not crash during process teardown.
+// A client-created unidirectional stream is not a valid HTTP/3 request
+// stream, and data arriving on one could crash during process teardown.
+// HTTP/3 frames its own streams, so the QUIC session now refuses to open
+// streams directly at all, which puts that state out of reach.
 
 import { hasQuic, skip, mustNotCall } from '../common/index.mjs';
+import assert from 'node:assert';
 import * as fixtures from '../common/fixtures.mjs';
 
 if (!hasQuic) {
@@ -13,22 +15,28 @@ if (!hasQuic) {
 }
 
 const { createPrivateKey } = await import('node:crypto');
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 
 const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
 const cert = fixtures.readKey('agent1-cert.pem');
 
 const endpoint = await listen(mustNotCall(), {
+  alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
 });
 
-const session = await connect(endpoint.address, {
+const session = new Http3Session(await connect(endpoint.address, {
+  alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-});
-
-const stream = await session.createUnidirectionalStream();
-stream.writer.writeSync('x');
+}));
+
+const refused = {
+  code: 'ERR_INVALID_STATE',
+  message: /Raw QUIC streams cannot be created/,
+};
+await assert.rejects(session.quicSession.createUnidirectionalStream(), refused);
+await assert.rejects(session.quicSession.createBidirectionalStream(), refused);
 
 endpoint.destroy();
 await endpoint.closed;
diff --git a/test/parallel/test-quic-h3-zero-rtt-bogus-ticket.mjs b/test/parallel/test-quic-h3-zero-rtt-bogus-ticket.mjs
index f724375d9def..cc244f86e866 100644
--- a/test/parallel/test-quic-h3-zero-rtt-bogus-ticket.mjs
+++ b/test/parallel/test-quic-h3-zero-rtt-bogus-ticket.mjs
@@ -20,12 +20,14 @@ const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
 const cert = fixtures.readKey('agent1-cert.pem');
 
 const serverEndpoint = await listen(mustNotCall(), {
+  alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
 });
 
 // Bogus ticket data (random bytes) is rejected at the format level.
 await assert.rejects(
   connect(serverEndpoint.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
     sessionTicket: randomBytes(256),
diff --git a/test/parallel/test-quic-h3-zero-rtt-rejected-settings.mjs b/test/parallel/test-quic-h3-zero-rtt-rejected-settings.mjs
index 755bde188e0b..e472844656fe 100644
--- a/test/parallel/test-quic-h3-zero-rtt-rejected-settings.mjs
+++ b/test/parallel/test-quic-h3-zero-rtt-rejected-settings.mjs
@@ -17,7 +17,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey, randomBytes } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -27,18 +27,20 @@ const sni = { '*': { keys: [key], certs: [cert] } };
 const decoder = new TextDecoder();
 
 // Helper: establish an H3 session, get a ticket, close.
-async function getTicket(endpointOptions) {
+async function getTicket({ settings, ...endpointOptions }) {
   let savedTicket;
   let savedToken;
   const gotTicket = Promise.withResolvers();
   const gotToken = Promise.withResolvers();
 
-  const ep = await listen(mustCall(async (ss) => {
+  const ep = await listen(mustCall(async (quicSession) => {
+    const ss = new Http3Session(quicSession, { settings });
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       ss.close();
     });
   }), {
+    alpn: ['h3'],
     sni,
     ...endpointOptions,
     onheaders: mustCall(function(headers) {
@@ -48,7 +50,8 @@ async function getTicket(endpointOptions) {
     }),
   });
 
-  const cs = await connect(ep.address, {
+  const cs = new Http3Session(await connect(ep.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
     ...endpointOptions,
@@ -62,7 +65,7 @@ async function getTicket(endpointOptions) {
       savedToken = token;
       gotToken.resolve();
     }),
-  });
+  }), { settings });
   await cs.opened;
   await Promise.all([gotTicket.promise, gotToken.promise]);
 
@@ -90,21 +93,26 @@ async function getTicket(endpointOptions) {
 // recreated (EarlyDataRejected destroys the nghttp3 connection).
 // The initial 0-RTT stream may not survive this transition, so we
 // only verify earlyDataAccepted is false and close cleanly.
-async function attemptRejected0RTT(endpointOptions, ticket, token) {
-  const ep = await listen(mustCall(async (ss) => {
+async function attemptRejected0RTT({ settings, ...endpointOptions },
+                                   ticket, token) {
+  const ep = await listen(mustCall(async (quicSession) => {
+    const ss = new Http3Session(quicSession, { settings });
     await ss.closed;
   }), {
+    alpn: ['h3'],
     sni,
     ...endpointOptions,
   });
 
-  const cs = await connect(ep.address, {
+  const quicSession = await connect(ep.address, {
+    alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
     ...endpointOptions,
     sessionTicket: ticket,
     token,
   });
+  const cs = new Http3Session(quicSession, { settings });
 
   // Trigger the deferred handshake by opening a stream.
   // With 0-RTT, the handshake is deferred until the first stream
@@ -137,13 +145,13 @@ const tokenSecret = randomBytes(16);
 {
   const { ticket, token } = await getTicket({
     endpoint: { tokenSecret },
-    application: { enableConnectProtocol: true },
+    settings: { enableConnectProtocol: true },
   });
 
   await attemptRejected0RTT({
     endpoint: { tokenSecret },
     // EnableConnectProtocol reduced from true to false.
-    application: { enableConnectProtocol: false },
+    settings: { enableConnectProtocol: false },
   }, ticket, token);
 }
 
@@ -151,13 +159,13 @@ const tokenSecret = randomBytes(16);
 {
   const { ticket, token } = await getTicket({
     endpoint: { tokenSecret },
-    application: { enableDatagrams: true },
+    settings: { enableDatagrams: true },
   });
 
   await attemptRejected0RTT({
     endpoint: { tokenSecret },
     // EnableDatagrams reduced from true to false.
-    application: { enableDatagrams: false },
+    settings: { enableDatagrams: false },
   }, ticket, token);
 }
 
@@ -165,12 +173,12 @@ const tokenSecret = randomBytes(16);
 {
   const { ticket, token } = await getTicket({
     endpoint: { tokenSecret },
-    application: { maxFieldSectionSize: 10000 },
+    settings: { maxFieldSectionSize: 10000 },
   });
 
   await attemptRejected0RTT({
     endpoint: { tokenSecret },
     // MaxFieldSectionSize reduced from 10000 to 100.
-    application: { maxFieldSectionSize: 100 },
+    settings: { maxFieldSectionSize: 100 },
   }, ticket, token);
 }
diff --git a/test/parallel/test-quic-h3-zero-rtt.mjs b/test/parallel/test-quic-h3-zero-rtt.mjs
index f836caa1ec4f..ee2ec0ba7987 100644
--- a/test/parallel/test-quic-h3-zero-rtt.mjs
+++ b/test/parallel/test-quic-h3-zero-rtt.mjs
@@ -14,7 +14,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect } = await import('node:quic');
+const { listen, connect, Http3Session } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -31,7 +31,8 @@ const gotToken = Promise.withResolvers();
 let serverSessionCount = 0;
 const secondDone = Promise.withResolvers();
 
-const serverEndpoint = await listen(mustCall((ss) => {
+const serverEndpoint = await listen(mustCall((quicSession) => {
+  const ss = new Http3Session(quicSession);
   const num = ++serverSessionCount;
   ss.onstream = mustCall(async (stream) => {
     if (num === 2) {
@@ -44,6 +45,7 @@ const serverEndpoint = await listen(mustCall((ss) => {
     ss.close();
   });
 }, 2), {
+  alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
   onheaders: mustCall(function(headers) {
     this.sendHeaders({ ':status': '200' });
@@ -53,7 +55,8 @@ const serverEndpoint = await listen(mustCall((ss) => {
 });
 
 // --- First connection: establish H3 session, receive ticket ---
-const cs1 = await connect(serverEndpoint.address, {
+const cs1 = new Http3Session(await connect(serverEndpoint.address, {
+  alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
   onsessionticket: mustCall(function(ticket) {
@@ -67,7 +70,7 @@ const cs1 = await connect(serverEndpoint.address, {
     savedToken = token;
     gotToken.resolve();
   }),
-});
+}));
 
 const info1 = await cs1.opened;
 assert.strictEqual(info1.earlyDataAttempted, false);
@@ -95,12 +98,13 @@ assert.ok(savedTicket);
 assert.ok(savedToken);
 
 // --- Second connection: 0-RTT with H3 ---
-const cs2 = await connect(serverEndpoint.address, {
+const cs2 = new Http3Session(await connect(serverEndpoint.address, {
+  alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
   sessionTicket: savedTicket,
   token: savedToken,
-});
+}));
 
 // Send H3 request BEFORE handshake completes — true 0-RTT.
 const s2 = await cs2.createBidirectionalStream({
diff --git a/test/parallel/test-quic-internal-endpoint-listen-defaults.mjs b/test/parallel/test-quic-internal-endpoint-listen-defaults.mjs
index 42cfa784263c..5c97fb7ad86c 100644
--- a/test/parallel/test-quic-internal-endpoint-listen-defaults.mjs
+++ b/test/parallel/test-quic-internal-endpoint-listen-defaults.mjs
@@ -17,6 +17,7 @@ const { getQuicEndpointState } = (await import('internal/quic/quic')).default;
 const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
 const cert = fixtures.readKey('agent1-cert.pem');
 const sni = { '*': { keys: [key], certs: [cert] } };
+const alpn = ['quic-test'];
 
 const endpoint = new QuicEndpoint();
 const state = getQuicEndpointState(endpoint);
@@ -26,7 +27,7 @@ assert.ok(!state.isListening);
 
 assert.strictEqual(endpoint.address, undefined);
 
-await assert.rejects(listen(123, { sni, endpoint }), {
+await assert.rejects(listen(123, { alpn, sni, endpoint }), {
   code: 'ERR_INVALID_ARG_TYPE',
 });
 // Buffer is not detached.
@@ -36,11 +37,11 @@ await assert.rejects(listen(mustNotCall(), 123), {
   code: 'ERR_INVALID_ARG_TYPE',
 });
 
-await listen(mustNotCall(), { sni, endpoint });
+await listen(mustNotCall(), { alpn, sni, endpoint });
 // Buffer is not detached.
 assert.strictEqual(cert.buffer.detached, false);
 
-await assert.rejects(listen(mustNotCall(), { sni, endpoint }), {
+await assert.rejects(listen(mustNotCall(), { alpn, sni, endpoint }), {
   code: 'ERR_INVALID_STATE',
 });
 // Buffer is not detached.
@@ -64,7 +65,7 @@ assert.strictEqual(endpoint.closed, endpoint.close());
 await endpoint.closed;
 assert.ok(endpoint.destroyed);
 
-await assert.rejects(listen(mustNotCall(), { sni, endpoint }), {
+await assert.rejects(listen(mustNotCall(), { alpn, sni, endpoint }), {
   code: 'ERR_INVALID_STATE',
 });
 // Buffer is not detached.
diff --git a/test/parallel/test-quic-internal-endpoint-stats-state.mjs b/test/parallel/test-quic-internal-endpoint-stats-state.mjs
index 2f4ce6ccc141..e348fd0feb65 100644
--- a/test/parallel/test-quic-internal-endpoint-stats-state.mjs
+++ b/test/parallel/test-quic-internal-endpoint-stats-state.mjs
@@ -172,7 +172,13 @@ assert.strictEqual(sessionState.isHandshakeCompleted, false);
 assert.strictEqual(sessionState.isHandshakeConfirmed, false);
 assert.strictEqual(sessionState.isStreamOpenAllowed, false);
 assert.strictEqual(sessionState.isPrioritySupported, false);
-assert.strictEqual(sessionState.headersSupported, 0);
+// No application has been installed on this session, so everything an
+// application populates reads as undefined rather than as a stand-in value.
+assert.strictEqual(sessionState.headersSupported, undefined);
+assert.strictEqual(sessionState.streamCallbacksSupported, undefined);
+assert.strictEqual(sessionState.noErrorCode, undefined);
+assert.strictEqual(sessionState.internalErrorCode, undefined);
+assert.strictEqual(sessionState.requestRejectedCode, undefined);
 assert.strictEqual(sessionState.isWrapped, false);
 assert.strictEqual(sessionState.maxDatagramSize, 0);
 assert.strictEqual(sessionState.lastDatagramId, 0n);
diff --git a/test/parallel/test-quic-session-application-options.mjs b/test/parallel/test-quic-session-application-options.mjs
index b119207bcc1f..60e28597c6c2 100644
--- a/test/parallel/test-quic-session-application-options.mjs
+++ b/test/parallel/test-quic-session-application-options.mjs
@@ -1,9 +1,9 @@
 // Flags: --experimental-quic --experimental-stream-iter --no-warnings
 
 // Test: session.applicationOptions
-// Verifies that applicationOptions is available after ALPN negotiation
-// completes (i.e., once the application has been selected), returns a
-// null-prototype object, and reflects the configured values.
+// Verifies that the settings an HTTP/3 session was given are reported back by
+// applicationOptions as a null-prototype object on both peers, and become
+// null once the session is gone.
 
 import { hasQuic, skip, mustCall } from '../common/index.mjs';
 import assert from 'node:assert';
@@ -13,8 +13,9 @@ if (!hasQuic) {
 }
 
 const { listen, connect } = await import('../common/quic.mjs');
+const { Http3Session } = await import('node:quic');
 
-const customAppOptions = {
+const customSettings = {
   maxHeaderPairs: 50n,
   maxHeaderLength: 8192n,
   maxFieldSectionSize: 16384n,
@@ -25,79 +26,71 @@ const customAppOptions = {
   enableDatagrams: false,
 };
 
-const serverDone = Promise.withResolvers();
-
-const serverEndpoint = await listen(mustCall((serverSession) => {
-  serverSession.onstream = mustCall(async (stream) => {
-    // After the stream arrives, the handshake and ALPN negotiation are
-    // complete, so applicationOptions should be available.
-    const opts = serverSession.applicationOptions;
-
-    assert.ok(opts != null, 'server applicationOptions should be available after handshake');
-    assert.strictEqual(typeof opts, 'object');
-    assert.strictEqual(Object.getPrototypeOf(opts), null);
+// Both peers advertise the same settings, so the values stay put when the
+// peer's SETTINGS frame is applied on top of them.
+function check(settings, side) {
+  assert.ok(settings != null, `${side} settings should be available`);
+  assert.strictEqual(typeof settings, 'object');
+  assert.strictEqual(Object.getPrototypeOf(settings), null);
+  assert.strictEqual(settings.maxHeaderPairs, customSettings.maxHeaderPairs);
+  assert.strictEqual(settings.maxHeaderLength, customSettings.maxHeaderLength);
+  assert.strictEqual(settings.maxFieldSectionSize,
+                     customSettings.maxFieldSectionSize);
+  assert.strictEqual(settings.qpackMaxDtableCapacity,
+                     customSettings.qpackMaxDTableCapacity);
+  assert.strictEqual(settings.qpackEncoderMaxDtableCapacity,
+                     customSettings.qpackEncoderMaxDTableCapacity);
+  assert.strictEqual(settings.qpackBlockedStreams,
+                     customSettings.qpackBlockedStreams);
+  assert.strictEqual(settings.enableConnectProtocol,
+                     customSettings.enableConnectProtocol);
+  assert.strictEqual(settings.enableDatagrams, customSettings.enableDatagrams);
+}
 
-    // Verify configured values are reflected.
-    assert.strictEqual(opts.maxHeaderPairs, BigInt(customAppOptions.maxHeaderPairs));
-    assert.strictEqual(opts.maxHeaderLength, BigInt(customAppOptions.maxHeaderLength));
-    assert.strictEqual(opts.maxFieldSectionSize,
-                       BigInt(customAppOptions.maxFieldSectionSize));
-    assert.strictEqual(opts.qpackMaxDtableCapacity,
-                       BigInt(customAppOptions.qpackMaxDTableCapacity));
-    assert.strictEqual(opts.qpackEncoderMaxDtableCapacity,
-                       BigInt(customAppOptions.qpackEncoderMaxDTableCapacity));
-    assert.strictEqual(opts.qpackBlockedStreams,
-                       BigInt(customAppOptions.qpackBlockedStreams));
-    assert.strictEqual(opts.enableConnectProtocol,
-                       customAppOptions.enableConnectProtocol);
-    assert.strictEqual(opts.enableDatagrams, customAppOptions.enableDatagrams);
+const serverDone = Promise.withResolvers();
 
-    stream.writer.endSync();
+const serverEndpoint = await listen(mustCall((quicSession) => {
+  const server = new Http3Session(quicSession, { settings: customSettings });
+  quicSession.onstream = mustCall(async (stream) => {
+    check(quicSession.applicationOptions, 'server');
     await stream.closed;
-    serverSession.close();
+    server.close();
     serverDone.resolve();
   });
 }), {
-  application: customAppOptions,
+  alpn: ['h3'],
+  onheaders: mustCall(function() {
+    this.sendHeaders({ ':status': '200' });
+    this.writer.endSync();
+  }),
 });
 
-const clientSession = await connect(serverEndpoint.address, {
-  application: customAppOptions,
+const client = new Http3Session(
+  await connect(serverEndpoint.address, { alpn: 'h3' }),
+  { settings: customSettings });
+
+// The settings are in effect from the attach onwards: before the handshake
+// completes, and before any SETTINGS frame from the peer can have arrived.
+check(client.quicSession.applicationOptions, 'client');
+await client.opened;
+check(client.quicSession.applicationOptions, 'client');
+
+// Exchange a request to let the server side run its assertions.
+const stream = await client.createBidirectionalStream({
+  headers: {
+    ':method': 'GET',
+    ':path': '/',
+    ':scheme': 'https',
+    ':authority': 'localhost',
+  },
+  onheaders: mustCall(),
 });
-await clientSession.opened;
-
-// After opened, ALPN negotiation is complete and applicationOptions
-// should be available on the client session.
-const clientOpts = clientSession.applicationOptions;
-assert.ok(clientOpts != null, 'client applicationOptions should be available after handshake');
-assert.strictEqual(typeof clientOpts, 'object');
-assert.strictEqual(Object.getPrototypeOf(clientOpts), null);
-
-// Verify configured values on the client side.
-assert.strictEqual(clientOpts.maxHeaderPairs, BigInt(customAppOptions.maxHeaderPairs));
-assert.strictEqual(clientOpts.maxHeaderLength, BigInt(customAppOptions.maxHeaderLength));
-assert.strictEqual(clientOpts.maxFieldSectionSize,
-                   customAppOptions.maxFieldSectionSize);
-assert.strictEqual(clientOpts.qpackMaxDtableCapacity,
-                   customAppOptions.qpackMaxDTableCapacity);
-assert.strictEqual(clientOpts.qpackEncoderMaxDtableCapacity,
-                   customAppOptions.qpackEncoderMaxDTableCapacity);
-assert.strictEqual(clientOpts.qpackBlockedStreams,
-                   customAppOptions.qpackBlockedStreams);
-assert.strictEqual(clientOpts.enableConnectProtocol,
-                   customAppOptions.enableConnectProtocol);
-assert.strictEqual(clientOpts.enableDatagrams, customAppOptions.enableDatagrams);
-
-// Exchange data to let the server side run its assertions.
-const stream = await clientSession.createBidirectionalStream();
-stream.writer.endSync();
 
 // eslint-disable-next-line no-unused-vars
 for await (const _ of stream) { /* drain */ }
 await Promise.all([stream.closed, serverDone.promise]);
 
-// After close, applicationOptions should return null.
-await clientSession.close();
-assert.strictEqual(clientSession.applicationOptions, null);
+await client.close();
+assert.strictEqual(client.quicSession.applicationOptions, null);
 
 await serverEndpoint.close();
diff --git a/test/parallel/test-quic-session-emit-ordering.mjs b/test/parallel/test-quic-session-emit-ordering.mjs
index 1b2d972ad7db..ac5707cee4c2 100644
--- a/test/parallel/test-quic-session-emit-ordering.mjs
+++ b/test/parallel/test-quic-session-emit-ordering.mjs
@@ -31,9 +31,9 @@ const serverEndpoint = await listen(mustCall((serverSession) => {
   assert.notStrictEqual(params, null);
   assert.ok(params.initialMaxStreamsBidi >= 0n);
 
-  // ALPN negotiation has completed: headers support is resolved (2 =
-  // unsupported, confirming non-h3 test ALPN)
-  assert.strictEqual(getQuicSessionState(serverSession).headersSupported, 2);
+  // ALPN negotiation completed, but no application has been installed yet
+  // (type 0): the window to attach one is still open in this frame.
+  assert.strictEqual(getQuicSessionState(serverSession).applicationType, 0);
 
   sessionSeen.resolve();
 }));
diff --git a/test/parallel/test-quic-session-stream-lifecycle.mjs b/test/parallel/test-quic-session-stream-lifecycle.mjs
index 3c24810bd9a6..54419ad1006c 100644
--- a/test/parallel/test-quic-session-stream-lifecycle.mjs
+++ b/test/parallel/test-quic-session-stream-lifecycle.mjs
@@ -31,7 +31,7 @@ const serverEndpoint = await quic.listen(mustCall(async (serverSession) => {
 
   serverDone.resolve();
   serverSession.close();
-}), { sni: { '*': { keys, certs } } });
+}), { alpn: ['quic-test'], sni: { '*': { keys, certs } } });
 
 assert.strictEqual(serverEndpoint.busy, false);
 assert.strictEqual(serverEndpoint.closing, false);
@@ -50,6 +50,7 @@ assert.ok(epStats.createdAt > 0n);
 
 // Connect with a client
 const clientSession = await quic.connect(serverEndpoint.address, {
+  alpn: 'quic-test',
   verifyPeer: 'manual',
 });
 
@@ -59,7 +60,7 @@ assert.strictEqual(clientSession.stats.isConnected, true);
 
 const clientInfo = await clientSession.opened;
 assert.strictEqual(clientInfo.servername, 'localhost');
-assert.strictEqual(clientInfo.protocol, 'h3');
+assert.strictEqual(clientInfo.protocol, 'quic-test');
 assert.strictEqual(clientInfo.cipherVersion, 'TLSv1.3');
 assert.ok(clientInfo.local !== undefined);
 assert.ok(clientInfo.remote !== undefined);
diff --git a/test/parallel/test-quic-zero-rtt-disabled-server.mjs b/test/parallel/test-quic-zero-rtt-disabled-server.mjs
index c2164d7c8b35..abc983ecf688 100644
--- a/test/parallel/test-quic-zero-rtt-disabled-server.mjs
+++ b/test/parallel/test-quic-zero-rtt-disabled-server.mjs
@@ -6,7 +6,7 @@
 // The connection should still succeed (fallback to 1-RTT), and
 // earlyDataAccepted should be false.
 
-import { hasQuic, skip, mustNotCall } from '../common/index.mjs';
+import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs';
 import assert from 'node:assert';
 import * as fixtures from '../common/fixtures.mjs';
 
@@ -78,6 +78,7 @@ const cs2 = await connect(serverEndpoint2.address, {
   verifyPeer: 'manual',
   sessionTicket: savedTicket,
   token: savedToken,
+  onearlyrejected: mustCall(),
 });
 
 // The deferred handshake needs a send to trigger. Use sendDatagram

From 206f63652d7d6b1150d8e24946674a70c59c3f21 Mon Sep 17 00:00:00 2001
From: Tim Perry <pimterry@gmail.com>
Date: Mon, 21 Sep 2026 15:42:18 +0200
Subject: [PATCH 2/9] fixup! quic: add Http3Session, so you can explicitly pick
 the app protocol

First pass of the simple mechanical changes from review
---
 doc/api/quic.md                       | 15 ++++++++----
 lib/internal/quic/http3.js            | 33 ++++++++++++++++----------
 lib/internal/quic/quic.js             | 34 ++++++++++++---------------
 lib/internal/quic/state.js            | 12 +++++-----
 lib/internal/quic/symbols.js          |  2 --
 src/quic/application.h                |  9 +------
 src/quic/session.cc                   | 13 +++++-----
 src/quic/session.h                    |  8 ++++++-
 test/parallel/test-quic-h3-attach.mjs |  5 ++--
 9 files changed, 68 insertions(+), 63 deletions(-)

diff --git a/doc/api/quic.md b/doc/api/quic.md
index 832bfafd0f30..0c58e61792f8 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -4315,8 +4315,8 @@ Only what this side does is listed, because nothing the peer sends can arrive
 any earlier: its streams and datagrams need keys that are only unlocked once
 the session is already active.
 
-In practice this means a server session should be attached synchronously
-inside the [`quic.listen()`][] callback, and a client session should be
+In practice this means a server session must be attached synchronously
+inside the [`quic.listen()`][] callback, and a client session must be
 attached synchronously when the [`session.opened`][] promise resolves (or
 before), and in both cases before anything is sent on the session.
 
@@ -4334,6 +4334,11 @@ underlying [`QuicSession`][]: `alpnProtocol`, `certificate`, `close()`,
 `closed`, `destroy()`, `destroyed`, `ephemeralKeyInfo`, `onerror`, `opened`,
 `peerCertificate`, `servername`, and `stats`.
 
+Any callback set through the `Http3Session` - `onerror`, `onstream`, and the
+HTTP/3-specific ones below - is invoked with the `Http3Session` as `this`. The
+same callback set directly on the `QuicSession` is invoked with the
+`QuicSession`.
+
 ### `http3session.createBidirectionalStream([options])`
 
 <!-- YAML
@@ -4345,8 +4350,8 @@ added: REPLACEME
 Opens an HTTP/3 request stream. Equivalent to
 [`session.createBidirectionalStream()`][] on the underlying session.
 
-HTTP/3 has no server-initiated request streams, so calling this on a server
-session throws `ERR_INVALID_STATE`.
+HTTP/3 has no server-initiated request streams, so on a server session the
+returned promise is rejected with `ERR_INVALID_STATE`.
 
 ### `http3session.ongoaway`
 
@@ -4409,7 +4414,7 @@ added: REPLACEME
 
 The HTTP/3 settings in effect, including any update received from the peer's
 SETTINGS frame, which may arrive after the session opens. `null` once the
-session is destroyed.
+session is destroyed. Read only.
 
 ## Performance measurement
 
diff --git a/lib/internal/quic/http3.js b/lib/internal/quic/http3.js
index 4d321345d6aa..410ea5925b28 100644
--- a/lib/internal/quic/http3.js
+++ b/lib/internal/quic/http3.js
@@ -21,10 +21,10 @@ if (!process.features.quic || !getOptionValue('--experimental-quic')) {
 // streams are HTTP/3 request streams.
 
 const {
-  QuicSession,
+  createApplicationStream,
+  getQuicSessionHandle,
   getQuicSessionState,
-  kCreateStream,
-  kSessionHandle,
+  isQuicSession,
 } = require('internal/quic/quic');
 
 const {
@@ -105,7 +105,7 @@ function prepareH3Settings(settings) {
 function checkAttachable(session, state) {
   if (session.destroyed ||
     state.applicationType === undefined ||
-    session[kSessionHandle] === undefined) {
+    getQuicSessionHandle(session) === undefined) {
     throw new ERR_INVALID_STATE(
       'An application cannot be attached to a destroyed QUIC session');
   }
@@ -133,7 +133,7 @@ class Http3Session {
    * @param {Function} [options.onsettings]
    */
   constructor(session, options = kEmptyObject) {
-    if (!(session instanceof QuicSession)) {
+    if (!isQuicSession(session)) {
       throw new ERR_INVALID_ARG_TYPE('session', 'QuicSession', session);
     }
     validateObject(options, 'options');
@@ -154,13 +154,22 @@ class Http3Session {
     // Reading settings could call getters and go into JS, so do this after:
     checkAttachable(session, state);
 
-    const handle = session[kSessionHandle];
+    const handle = getQuicSessionHandle(session);
     if (preparedSettings !== undefined) handle[kHttp3Settings] = preparedSettings;
     state.applicationType = QUIC_APPLICATION_HTTP3 | QUIC_APPLICATION_PENDING;
     this.#session = session;
-    if (ongoaway !== undefined) this.ongoaway = ongoaway;
-    if (onorigin !== undefined) this.onorigin = onorigin;
-    if (onsettings !== undefined) this.onsettings = onsettings;
+    if (ongoaway !== undefined) {
+      this.#ongoaway = ongoaway;
+      session.ongoaway = this.#bind(ongoaway);
+    }
+    if (onorigin !== undefined) {
+      this.#onorigin = onorigin;
+      session.onorigin = this.#bind(onorigin);
+    }
+    if (onsettings !== undefined) {
+      this.#onsettings = onsettings;
+      session.onapplication = this.#bind(onsettings);
+    }
   }
 
   /**
@@ -250,13 +259,13 @@ class Http3Session {
    * Opens a request stream.
    * @returns {Promise<QuicStream>}
    */
-  createBidirectionalStream(options) {
+  async createBidirectionalStream(options) {
     if (getQuicSessionState(this.#session).isServer) {
       throw new ERR_INVALID_STATE(
         'Server sessions cannot open HTTP/3 request streams');
     }
-    return this.#session[kCreateStream](
-      kStreamDirectionBidirectional, options);
+    return await createApplicationStream(
+      this.#session, kStreamDirectionBidirectional, options);
   }
 
   close(options) { return this.#session.close(options); }
diff --git a/lib/internal/quic/quic.js b/lib/internal/quic/quic.js
index 89dbec99667a..13f966d0eb8a 100644
--- a/lib/internal/quic/quic.js
+++ b/lib/internal/quic/quic.js
@@ -213,7 +213,6 @@ const {
   kPrivateConstructor,
   kReset,
   kSendHeaders,
-  kCreateStream,
   kSessionApplication,
   kSessionTicket,
   kStopSending,
@@ -283,9 +282,6 @@ const {
 
 const kNilDatagramId = 0n;
 
-// Internal-only symbol to expose the session #handle to applications
-const kSessionHandle = Symbol('kSessionHandle');
-
 // 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.
@@ -1569,6 +1565,8 @@ let assertEndpointNotClosedOrClosing;
 let assertEndpointIsNotBusy;
 let isQuicStream;
 let isQuicSession;
+let getQuicSessionHandle;
+let createApplicationStream;
 let isQuicEndpoint;
 
 function maybeGetCloseError(context, status, pendingError) {
@@ -2911,6 +2909,16 @@ class QuicSession {
       }
     };
 
+    getQuicSessionHandle = (session) => {
+      assertIsQuicSession(session);
+      return session.#handle;
+    };
+
+    createApplicationStream = (session, direction, options) => {
+      assertIsQuicSession(session);
+      return session.#createStream(direction, options);
+    };
+
     getQuicSessionState = function(session) {
       assertIsQuicSession(session);
       return session.#inner.state;
@@ -2959,15 +2967,6 @@ class QuicSession {
     return this.#handle.applicationOptions();
   }
 
-  /**
-   * Handle accessor to allow applications to reach the session handle.
-   * Returns undefined once destroyed.
-   * @type {object|undefined}
-   */
-  get [kSessionHandle]() {
-    assertIsQuicSession(this);
-    return this.#handle;
-  }
 
   get localTransportParams() {
     if (this.#inner.localTransportParams !== undefined) {
@@ -3564,10 +3563,6 @@ class QuicSession {
     }
   }
 
-  async [kCreateStream](direction, options) {
-    return await this.#createStream(direction, options);
-  }
-
   /**
    * Send a datagram. The id of the sent datagram will be returned. The status
    * of the sent datagram will be reported via the datagram-status event if
@@ -5775,8 +5770,9 @@ module.exports = {
   DEFAULT_CIPHERS,
   DEFAULT_GROUPS,
   // Internal only, for the HTTP/3 layer's integration with node:quic.
-  kCreateStream,
-  kSessionHandle,
+  createApplicationStream,
+  getQuicSessionHandle,
+  isQuicSession,
   // These are exported only for internal testing purposes.
   getQuicStreamState,
   getQuicSessionState,
diff --git a/lib/internal/quic/state.js b/lib/internal/quic/state.js
index 2b6a52a03951..fbd3bffaf109 100644
--- a/lib/internal/quic/state.js
+++ b/lib/internal/quic/state.js
@@ -498,7 +498,7 @@ class QuicSessionState {
    */
   get headersSupported() {
     const handle = this.#handle;
-    if (handle === undefined || !this.#hasApplication) return undefined;
+    if (handle === undefined || !this.hasApplication) return undefined;
     return DataViewPrototypeGetUint8(handle, this.#offset + IDX_STATE_SESSION_HEADERS_SUPPORTED);
   }
 
@@ -510,7 +510,7 @@ class QuicSessionState {
    */
   get streamCallbacksSupported() {
     const handle = this.#handle;
-    if (handle === undefined || !this.#hasApplication) return undefined;
+    if (handle === undefined || !this.hasApplication) return undefined;
     return DataViewPrototypeGetUint8(
       handle, this.#offset + IDX_STATE_SESSION_STREAM_CALLBACKS_SUPPORTED);
   }
@@ -541,7 +541,7 @@ class QuicSessionState {
   }
 
   // True once an application has actually been attached (not just requested)
-  get #hasApplication() {
+  get hasApplication() {
     const handle = this.#handle;
     if (handle === undefined) return false;
     const type = DataViewPrototypeGetUint8(
@@ -566,7 +566,7 @@ class QuicSessionState {
    */
   get noErrorCode() {
     const handle = this.#handle;
-    if (handle === undefined || !this.#hasApplication) return undefined;
+    if (handle === undefined || !this.hasApplication) return undefined;
     return DataViewPrototypeGetBigUint64(
       handle, this.#offset + IDX_STATE_SESSION_NO_ERROR_CODE, kIsLittleEndian);
   }
@@ -582,14 +582,14 @@ class QuicSessionState {
    */
   get internalErrorCode() {
     const handle = this.#handle;
-    if (handle === undefined || !this.#hasApplication) return undefined;
+    if (handle === undefined || !this.hasApplication) return undefined;
     return DataViewPrototypeGetBigUint64(
       handle, this.#offset + IDX_STATE_SESSION_INTERNAL_ERROR_CODE, kIsLittleEndian);
   }
 
   get requestRejectedCode() {
     const handle = this.#handle;
-    if (handle === undefined || !this.#hasApplication) return undefined;
+    if (handle === undefined || !this.hasApplication) return undefined;
     return DataViewPrototypeGetBigUint64(
       handle, this.#offset + IDX_STATE_SESSION_REQUEST_REJECTED_CODE, kIsLittleEndian);
   }
diff --git a/lib/internal/quic/symbols.js b/lib/internal/quic/symbols.js
index ded5e7280a6e..1ed44ebe2b13 100644
--- a/lib/internal/quic/symbols.js
+++ b/lib/internal/quic/symbols.js
@@ -48,7 +48,6 @@ const kNewSession = Symbol('kNewSession');
 const kNewStream = Symbol('kNewStream');
 const kNewToken = Symbol('kNewToken');
 const kStreamCallbacks = Symbol('kStreamCallbacks');
-const kCreateStream = Symbol('kCreateStream');
 const kOrigin = Symbol('kOrigin');
 const kOwner = Symbol('kOwner');
 const kPathValidation = Symbol('kPathValidation');
@@ -83,7 +82,6 @@ module.exports = {
   kKeyObjectHandle,
   kListen,
   kNewSession,
-  kCreateStream,
   kNewStream,
   kNewToken,
   kStreamCallbacks,
diff --git a/src/quic/application.h b/src/quic/application.h
index 54f7d1a7ee70..e110ccc19690 100644
--- a/src/quic/application.h
+++ b/src/quic/application.h
@@ -35,14 +35,7 @@ class Session::Application : public MemoryRetainer {
   // options passed at construction time since some options can be negotiated.
   virtual const Options& options() const = 0;
 
-  // The type of Application, exposed via the session state so JS can observe
-  // which Application the session ended up with. This is used primarily for
-  // testing/debugging.
-  enum class Type : uint8_t {
-    NONE = 0,     // None installed yet
-    DEFAULT = 1,  // DefaultApplication (raw QUIC streams)
-    HTTP3 = 2,    // Http3ApplicationImpl
-  };
+  using Type = ApplicationType;
 
   // Set alongside a Type in the session's shared application_type state to
   // mean "requested but not yet attached". JavaScript sets it to trigger the
diff --git a/src/quic/session.cc b/src/quic/session.cc
index 84d3e9a8b961..e0eab8cab90f 100644
--- a/src/quic/session.cc
+++ b/src/quic/session.cc
@@ -1235,8 +1235,7 @@ struct Session::Impl final : public MemoryRetainer {
     if (!session->has_application()) {
       // Not installed yet. If an attach has been scheduled, its settings are
       // already known and can be reported before the install happens.
-      if ((session->application_type() & ~Application::kTypePending) !=
-          static_cast<uint8_t>(Application::Type::HTTP3)) {
+      if (session->application_type() != Application::Type::HTTP3) {
         return args.GetReturnValue().SetUndefined();
       }
       if (Http3SettingsFromHandle(*session).ToObject(env).ToLocal(&obj)) {
@@ -2599,9 +2598,10 @@ bool Session::has_application() const {
   return !is_destroyed() && impl_->application_ != nullptr;
 }
 
-uint8_t Session::application_type() const {
-  if (is_destroyed()) return 0;
-  return impl_->state()->application_type;
+Session::ApplicationType Session::application_type() const {
+  if (is_destroyed()) return Application::Type::NONE;
+  return static_cast<Application::Type>(impl_->state()->application_type &
+                                        ~Application::kTypePending);
 }
 
 Session::Application& Session::application() const {
@@ -2631,8 +2631,7 @@ bool Session::EnsureApplication() {
   if (impl_->application_) [[likely]]
     return true;
 
-  if ((impl_->state()->application_type & ~Application::kTypePending) ==
-      static_cast<uint8_t>(Application::Type::HTTP3)) {
+  if (application_type() == Application::Type::HTTP3) {
     SetApplication(CreateHttp3Application(this));
   } else {
     SetApplication(
diff --git a/src/quic/session.h b/src/quic/session.h
index 0ffe1f822adb..07799df28ab5 100644
--- a/src/quic/session.h
+++ b/src/quic/session.h
@@ -106,6 +106,12 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
   // of a QUIC Session.
   class Application;
 
+  enum class ApplicationType : uint8_t {
+    NONE = 0,     // None installed yet
+    DEFAULT = 1,  // DefaultApplication (raw QUIC streams)
+    HTTP3 = 2,    // Http3ApplicationImpl
+  };
+
   // A block of pending outbound stream data, passed between the application
   // layer (which fills it via GetStreamData) and the send pump (which hands
   // it to ngtcp2_conn_writev_stream and commits the accepted length).
@@ -348,7 +354,7 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
   const Config& config() const;
   const Options& options() const;
 
-  uint8_t application_type() const;
+  ApplicationType application_type() const;
   const SocketAddress& remote_address() const;
   const SocketAddress& local_address() const;
 
diff --git a/test/parallel/test-quic-h3-attach.mjs b/test/parallel/test-quic-h3-attach.mjs
index 0759a3852a47..798e5b4aefae 100644
--- a/test/parallel/test-quic-h3-attach.mjs
+++ b/test/parallel/test-quic-h3-attach.mjs
@@ -254,11 +254,10 @@ const tooLate = {
   const refused = Promise.withResolvers();
   const endpoint = await listen(mustCall((quicSession) => {
     const server = new Http3Session(quicSession);
-    assert.throws(() => server.createBidirectionalStream(), {
+    refused.resolve(assert.rejects(server.createBidirectionalStream(), {
       code: 'ERR_INVALID_STATE',
       message: /Server sessions cannot open HTTP\/3 request streams/,
-    });
-    refused.resolve();
+    }));
   }), serverOpts);
   const client = new Http3Session(await connect(endpoint.address, clientOpts));
   await refused.promise;

From 5c71be56e8e8eef175510b00d23d63bdd9b46131 Mon Sep 17 00:00:00 2001
From: Tim Perry <pimterry@gmail.com>
Date: Mon, 21 Sep 2026 16:19:19 +0200
Subject: [PATCH 3/9] quic: add kInspect & AsyncDispose to Http3Session

---
 lib/internal/quic/http3.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/lib/internal/quic/http3.js b/lib/internal/quic/http3.js
index 410ea5925b28..ada38ea3b23c 100644
--- a/lib/internal/quic/http3.js
+++ b/lib/internal/quic/http3.js
@@ -4,6 +4,7 @@ const {
   BigInt,
   FunctionPrototypeBind,
   NumberIsInteger,
+  SymbolAsyncDispose,
 } = primordials;
 
 const {
@@ -27,6 +28,9 @@ const {
   isQuicSession,
 } = require('internal/quic/quic');
 
+const { kInspect } = require('internal/quic/symbols');
+const { inspect } = require('internal/util/inspect');
+
 const {
   QUIC_APPLICATION_HTTP3,
   QUIC_APPLICATION_PENDING,
@@ -271,6 +275,24 @@ class Http3Session {
   close(options) { return this.#session.close(options); }
 
   destroy(error, options) { return this.#session.destroy(error, options); }
+
+  async [SymbolAsyncDispose]() { await this.close(); }
+
+  [kInspect](depth, options) {
+    if (depth < 0) {
+      return 'Http3Session { }';
+    }
+    const opts = {
+      __proto__: null,
+      ...options,
+      depth: options.depth == null ? null : options.depth - 1,
+    };
+    return `Http3Session ${inspect({
+      quicSession: this.#session,
+      settings: this.settings,
+      destroyed: this.destroyed,
+    }, opts)}`;
+  }
 }
 
 module.exports = {

From 66626f7e53e1035d4a4ef4fa00334a0b79ca4441 Mon Sep 17 00:00:00 2001
From: Tim Perry <pimterry@gmail.com>
Date: Thu, 24 Sep 2026 16:08:12 +0200
Subject: [PATCH 4/9] quic: replace PENDING application type flag with a
 separate state bit

---
 lib/internal/quic/http3.js |  3 +--
 lib/internal/quic/quic.js  |  4 +---
 lib/internal/quic/state.js | 41 +++++++++++++++++++-------------------
 src/quic/application.h     |  7 -------
 src/quic/session.cc        |  7 +++----
 5 files changed, 26 insertions(+), 36 deletions(-)

diff --git a/lib/internal/quic/http3.js b/lib/internal/quic/http3.js
index ada38ea3b23c..e715c04737cc 100644
--- a/lib/internal/quic/http3.js
+++ b/lib/internal/quic/http3.js
@@ -33,7 +33,6 @@ const { inspect } = require('internal/util/inspect');
 
 const {
   QUIC_APPLICATION_HTTP3,
-  QUIC_APPLICATION_PENDING,
   STREAM_DIRECTION_BIDIRECTIONAL: kStreamDirectionBidirectional,
   kHttp3Settings,
 } = internalBinding('quic');
@@ -160,7 +159,7 @@ class Http3Session {
 
     const handle = getQuicSessionHandle(session);
     if (preparedSettings !== undefined) handle[kHttp3Settings] = preparedSettings;
-    state.applicationType = QUIC_APPLICATION_HTTP3 | QUIC_APPLICATION_PENDING;
+    state.applicationType = QUIC_APPLICATION_HTTP3;
     this.#session = session;
     if (ongoaway !== undefined) {
       this.#ongoaway = ongoaway;
diff --git a/lib/internal/quic/quic.js b/lib/internal/quic/quic.js
index 13f966d0eb8a..ec0747f3a788 100644
--- a/lib/internal/quic/quic.js
+++ b/lib/internal/quic/quic.js
@@ -68,7 +68,6 @@ const {
   STREAM_DIRECTION_BIDIRECTIONAL: kStreamDirectionBidirectional,
   STREAM_DIRECTION_UNIDIRECTIONAL: kStreamDirectionUnidirectional,
   QUIC_APPLICATION_DEFAULT: kApplicationTypeDefault,
-  QUIC_APPLICATION_PENDING: kApplicationTypePending,
   CLOSECONTEXT_CLOSE: kCloseContextClose,
   CLOSECONTEXT_BIND_FAILURE: kCloseContextBindFailure,
   CLOSECONTEXT_LISTEN_FAILURE: kCloseContextListenFailure,
@@ -3554,8 +3553,7 @@ class QuicSession {
   // and will generally stall or crash. Once an application is attached, the
   // application owns all stream creation.
   #assertOwnsStreams() {
-    const type = this.#inner.state.applicationType & ~kApplicationTypePending;
-    if (type > kApplicationTypeDefault) {
+    if (this.#inner.state.applicationType > kApplicationTypeDefault) {
       throw new ERR_INVALID_STATE(
         'Raw QUIC streams cannot be created on a session with a non-default ' +
         'application attached. Create streams through the application ' +
diff --git a/lib/internal/quic/state.js b/lib/internal/quic/state.js
index fbd3bffaf109..64745114426a 100644
--- a/lib/internal/quic/state.js
+++ b/lib/internal/quic/state.js
@@ -81,6 +81,7 @@ const {
   IDX_STATE_SESSION_WRAPPED,
   IDX_STATE_SESSION_IS_SERVER,
   IDX_STATE_SESSION_APPLICATION_TYPE,
+  IDX_STATE_SESSION_APPLICATION_INSTALLED,
   IDX_STATE_SESSION_NO_ERROR_CODE,
   IDX_STATE_SESSION_INTERNAL_ERROR_CODE,
   IDX_STATE_SESSION_REQUEST_REJECTED_CODE,
@@ -114,7 +115,6 @@ const {
   IDX_STATE_STREAM_BUDGET,
   IDX_STATE_STREAM_RESET_CODE,
   IDX_STATE_STREAM_SIZE,
-  QUIC_APPLICATION_PENDING,
 } = internalBinding('quic');
 
 assert(IDX_STATE_SESSION_LISTENER_FLAGS !== undefined);
@@ -131,6 +131,7 @@ assert(IDX_STATE_SESSION_STREAM_CALLBACKS_SUPPORTED !== undefined);
 assert(IDX_STATE_SESSION_WRAPPED !== undefined);
 assert(IDX_STATE_SESSION_IS_SERVER !== undefined);
 assert(IDX_STATE_SESSION_APPLICATION_TYPE !== undefined);
+assert(IDX_STATE_SESSION_APPLICATION_INSTALLED !== undefined);
 assert(IDX_STATE_SESSION_NO_ERROR_CODE !== undefined);
 assert(IDX_STATE_SESSION_INTERNAL_ERROR_CODE !== undefined);
 assert(IDX_STATE_SESSION_REQUEST_REJECTED_CODE !== undefined);
@@ -492,9 +493,10 @@ class QuicSessionState {
   }
 
   /**
-   * Whether the negotiated application protocol supports headers.
-   * Returns 0 (unknown), 1 (supported), or 2 (not supported).
-   * @type {number}
+   * Whether the installed application protocol supports headers.
+   * Returns 1 (supported) or 2 (not supported), or undefined until an
+   * application is installed.
+   * @type {number|undefined}
    */
   get headersSupported() {
     const handle = this.#handle;
@@ -503,10 +505,11 @@ class QuicSessionState {
   }
 
   /**
-   * Whether the negotiated application dispatches the session-level
+   * Whether the installed application dispatches the session-level
    * stream callbacks (onheaders et al) for incoming streams.
-   * Returns 0 (unknown), 1 (supported), or 2 (not supported).
-   * @type {number}
+   * Returns 1 (supported) or 2 (not supported), or undefined until an
+   * application is installed.
+   * @type {number|undefined}
    */
   get streamCallbacksSupported() {
     const handle = this.#handle;
@@ -524,8 +527,8 @@ class QuicSessionState {
 
   /**
    * The application the session is running, as an `Application::Type` value,
-   * or 0 for none. The `QUIC_APPLICATION_PENDING` flag will be set if the
-   * application attach has been requested but not yet completed.
+   * or 0 for none. Set as soon as an application is requested, before it is
+   * installed.
    * @type {number|undefined}
    */
   get applicationType() {
@@ -544,9 +547,8 @@ class QuicSessionState {
   get hasApplication() {
     const handle = this.#handle;
     if (handle === undefined) return false;
-    const type = DataViewPrototypeGetUint8(
-      handle, this.#offset + IDX_STATE_SESSION_APPLICATION_TYPE);
-    return type !== 0 && (type & QUIC_APPLICATION_PENDING) === 0;
+    return DataViewPrototypeGetUint8(
+      handle, this.#offset + IDX_STATE_SESSION_APPLICATION_INSTALLED) !== 0;
   }
 
   /** @type {boolean|undefined} */
@@ -558,10 +560,9 @@ class QuicSessionState {
   }
 
   /**
-   * The negotiated application protocol's "no error" code, populated
-   * by the C++ layer when the application is selected during ALPN
-   * negotiation. For raw QUIC this is `0n`; for HTTP/3 this is
-   * `0x100n` (`H3_NO_ERROR`).
+   * The application protocol's "no error" code, populated by the C++
+   * layer when the application is installed. For raw QUIC this is `0n`;
+   * for HTTP/3 this is `0x100n` (`H3_NO_ERROR`).
    * @type {bigint}
    */
   get noErrorCode() {
@@ -572,10 +573,10 @@ class QuicSessionState {
   }
 
   /**
-   * The negotiated application protocol's "internal error" code,
-   * populated by the C++ layer when the application is selected
-   * during ALPN negotiation. Used as the wire code for `RESET_STREAM`
-   * frames when a stream is aborted without a more specific code.
+   * The application protocol's "internal error" code, populated by
+   * the C++ layer when the application is installed. Used as the wire
+   * code for `RESET_STREAM` frames when a stream is aborted without a
+   * more specific code.
    * For raw QUIC this is `0x1n` (NGTCP2_INTERNAL_ERROR); for HTTP/3
    * this is `0x102n` (`H3_INTERNAL_ERROR`).
    * @type {bigint}
diff --git a/src/quic/application.h b/src/quic/application.h
index e110ccc19690..7a698bacc910 100644
--- a/src/quic/application.h
+++ b/src/quic/application.h
@@ -36,13 +36,6 @@ class Session::Application : public MemoryRetainer {
   virtual const Options& options() const = 0;
 
   using Type = ApplicationType;
-
-  // Set alongside a Type in the session's shared application_type state to
-  // mean "requested but not yet attached". JavaScript sets it to trigger the
-  // application attach later, SetApplication clears it by writing the bare
-  // Type. Keeping type & pending/installed in one place avoids duplicating
-  // type definition and simplifies application checks.
-  static constexpr uint8_t kTypePending = 0x80;
   virtual Type type() const = 0;
 
   virtual bool Start();
diff --git a/src/quic/session.cc b/src/quic/session.cc
index e0eab8cab90f..051b16e89804 100644
--- a/src/quic/session.cc
+++ b/src/quic/session.cc
@@ -141,6 +141,7 @@ uint64_t MaxDatagramPayload(uint64_t max_frame_size) {
   V(WRAPPED, wrapped, uint8_t)                                                 \
   V(IS_SERVER, is_server, uint8_t)                                             \
   V(APPLICATION_TYPE, application_type, uint8_t)                               \
+  V(APPLICATION_INSTALLED, application_installed, uint8_t)                     \
   V(NO_ERROR_CODE, no_error_code, error_code)                                  \
   V(INTERNAL_ERROR_CODE, internal_error_code, error_code)                      \
   V(REQUEST_REJECTED_CODE, request_rejected_code, error_code)                  \
@@ -2600,8 +2601,7 @@ bool Session::has_application() const {
 
 Session::ApplicationType Session::application_type() const {
   if (is_destroyed()) return Application::Type::NONE;
-  return static_cast<Application::Type>(impl_->state()->application_type &
-                                        ~Application::kTypePending);
+  return static_cast<Application::Type>(impl_->state()->application_type);
 }
 
 Session::Application& Session::application() const {
@@ -2666,6 +2666,7 @@ void Session::SetApplication(std::unique_ptr<Application> app) {
   impl_->state()->internal_error_code = app->GetInternalErrorCode();
   impl_->state()->request_rejected_code = app->GetRequestRejectedCode();
   impl_->application_ = std::move(app);
+  impl_->state()->application_installed = 1;
 }
 
 const SocketAddress& Session::remote_address() const {
@@ -4454,14 +4455,12 @@ void Session::InitPerContext(Realm* realm, Local<Object> target) {
       static_cast<uint8_t>(Direction::UNIDIRECTIONAL);
   static constexpr auto QUIC_APPLICATION_DEFAULT =
       static_cast<uint8_t>(Application::Type::DEFAULT);
-  static constexpr auto QUIC_APPLICATION_PENDING = Application::kTypePending;
   static constexpr auto QUIC_PROTO_MAX = NGTCP2_PROTO_VER_MAX;
   static constexpr auto QUIC_PROTO_MIN = NGTCP2_PROTO_VER_MIN;
 
   NODE_DEFINE_CONSTANT(target, STREAM_DIRECTION_BIDIRECTIONAL);
   NODE_DEFINE_CONSTANT(target, STREAM_DIRECTION_UNIDIRECTIONAL);
   NODE_DEFINE_CONSTANT(target, QUIC_APPLICATION_DEFAULT);
-  NODE_DEFINE_CONSTANT(target, QUIC_APPLICATION_PENDING);
   NODE_DEFINE_CONSTANT(target, DEFAULT_MAX_HEADER_LIST_PAIRS);
   NODE_DEFINE_CONSTANT(target, DEFAULT_MAX_HEADER_LENGTH);
   NODE_DEFINE_CONSTANT(target, QUIC_PROTO_MAX);

From 4e87ed84e3e1fcd7c5e30db998da6e6e6ddbecb6 Mon Sep 17 00:00:00 2001
From: Tim Perry <pimterry@gmail.com>
Date: Mon, 28 Sep 2026 15:29:46 +0200
Subject: [PATCH 5/9] quic: extract and validate Http3Settings separately into
 a fixed shape

---
 lib/internal/quic/http3.js | 101 ++++++++++++++++++++-----------------
 1 file changed, 54 insertions(+), 47 deletions(-)

diff --git a/lib/internal/quic/http3.js b/lib/internal/quic/http3.js
index e715c04737cc..608a27e1236f 100644
--- a/lib/internal/quic/http3.js
+++ b/lib/internal/quic/http3.js
@@ -38,6 +38,7 @@ const {
 } = internalBinding('quic');
 
 const {
+  validateBoolean,
   validateFunction,
   validateObject,
 } = require('internal/validators');
@@ -53,56 +54,62 @@ const {
 const kEmptyObject = { __proto__: null };
 const kMaxUint64 = (1n << 64n) - 1n;
 
-const kNumericSettings = [
-  'maxHeaderPairs',
-  'maxHeaderLength',
-  'maxFieldSectionSize',
-  'qpackMaxDTableCapacity',
-  'qpackEncoderMaxDTableCapacity',
-  'qpackBlockedStreams',
-];
-const kBooleanSettings = [
-  'enableConnectProtocol',
-  'enableDatagrams',
-];
-
-// Validate settings and return them as a plain null-proto object:
-function prepareH3Settings(settings) {
-  const out = { __proto__: null };
-  for (let n = 0; n < kNumericSettings.length; n++) {
-    const name = kNumericSettings[n];
-    const value = settings[name];
-    if (value === undefined) continue;
-    let big;
-    if (typeof value === 'bigint') {
-      big = value;
-    } else if (typeof value === 'number') {
-      if (!NumberIsInteger(value)) {
-        throw new ERR_OUT_OF_RANGE(`options.settings.${name}`, 'an integer',
-                                   value);
-      }
-      big = BigInt(value);
-    } else {
-      throw new ERR_INVALID_ARG_TYPE(`options.settings.${name}`,
-                                     ['number', 'bigint'], value);
-    }
-    if (big < 0n || big > kMaxUint64) {
-      throw new ERR_OUT_OF_RANGE(`options.settings.${name}`,
-                                 `>= 0 && <= ${kMaxUint64}`, value);
+function validateUint64Setting(value, name) {
+  if (value === undefined) return undefined;
+  let big;
+  if (typeof value === 'bigint') {
+    big = value;
+  } else if (typeof value === 'number') {
+    if (!NumberIsInteger(value)) {
+      throw new ERR_OUT_OF_RANGE(`options.settings.${name}`, 'an integer',
+                                 value);
     }
-    out[name] = big;
+    big = BigInt(value);
+  } else {
+    throw new ERR_INVALID_ARG_TYPE(`options.settings.${name}`,
+                                   ['number', 'bigint'], value);
   }
-  for (let n = 0; n < kBooleanSettings.length; n++) {
-    const name = kBooleanSettings[n];
-    const value = settings[name];
-    if (value === undefined) continue;
-    if (typeof value !== 'boolean') {
-      throw new ERR_INVALID_ARG_TYPE(`options.settings.${name}`, 'boolean',
-                                     value);
-    }
-    out[name] = value;
+  if (big < 0n || big > kMaxUint64) {
+    throw new ERR_OUT_OF_RANGE(`options.settings.${name}`,
+                               `>= 0 && <= ${kMaxUint64}`, value);
   }
-  return out;
+  return big;
+}
+
+function validateBooleanSetting(value, name) {
+  if (value !== undefined) validateBoolean(value, `options.settings.${name}`);
+  return value;
+}
+
+// Read each setting just once (they may be getters), then validate and return
+// them as a plain null-proto object:
+function prepareH3Settings(settings) {
+  const {
+    maxHeaderPairs,
+    maxHeaderLength,
+    maxFieldSectionSize,
+    qpackMaxDTableCapacity,
+    qpackEncoderMaxDTableCapacity,
+    qpackBlockedStreams,
+    enableConnectProtocol,
+    enableDatagrams,
+  } = settings;
+  return {
+    __proto__: null,
+    maxHeaderPairs: validateUint64Setting(maxHeaderPairs, 'maxHeaderPairs'),
+    maxHeaderLength: validateUint64Setting(maxHeaderLength, 'maxHeaderLength'),
+    maxFieldSectionSize:
+      validateUint64Setting(maxFieldSectionSize, 'maxFieldSectionSize'),
+    qpackMaxDTableCapacity:
+      validateUint64Setting(qpackMaxDTableCapacity, 'qpackMaxDTableCapacity'),
+    qpackEncoderMaxDTableCapacity: validateUint64Setting(
+      qpackEncoderMaxDTableCapacity, 'qpackEncoderMaxDTableCapacity'),
+    qpackBlockedStreams:
+      validateUint64Setting(qpackBlockedStreams, 'qpackBlockedStreams'),
+    enableConnectProtocol:
+      validateBooleanSetting(enableConnectProtocol, 'enableConnectProtocol'),
+    enableDatagrams: validateBooleanSetting(enableDatagrams, 'enableDatagrams'),
+  };
 }
 
 function checkAttachable(session, state) {

From b1591aab13c70ba0b40b7f18d9fa56386949c609 Mon Sep 17 00:00:00 2001
From: Tim Perry <pimterry@gmail.com>
Date: Mon, 28 Sep 2026 19:11:53 +0200
Subject: [PATCH 6/9] quic: move HTTP/3 events to Http3Session, use .from() to
 attach

Signed-off-by: Tim Perry <pimterry@gmail.com>
---
 benchmark/quic/h3-request.js                  |  17 +-
 benchmark/quic/handshake.js                   |   8 +-
 doc/api/quic.md                               | 172 +++++++++---------
 lib/internal/quic/http3.js                    |  53 ++++--
 lib/internal/quic/quic.js                     | 132 +++++---------
 src/quic/README.md                            |   2 +-
 src/quic/http3.h                              |   1 -
 .../test-quic-early-selection-order.mjs       |  12 +-
 test/parallel/test-quic-h3-attach.mjs         | 140 +++++++++++---
 .../parallel/test-quic-h3-callback-errors.mjs |  79 ++++++--
 test/parallel/test-quic-h3-close-behavior.mjs |   9 +-
 .../test-quic-h3-concurrent-requests.mjs      |   9 +-
 test/parallel/test-quic-h3-datagram.mjs       |  12 +-
 test/parallel/test-quic-h3-error-codes.mjs    |  16 +-
 .../test-quic-h3-flow-control-volume.mjs      |   9 +-
 test/parallel/test-quic-h3-goaway-non-h3.mjs  |  63 -------
 test/parallel/test-quic-h3-goaway.mjs         |   7 +-
 .../test-quic-h3-handshake-failure.mjs        |   9 +-
 .../parallel/test-quic-h3-header-interest.mjs |   8 +-
 .../test-quic-h3-header-validation.mjs        |  16 +-
 .../test-quic-h3-informational-headers.mjs    |   9 +-
 ...-maxstreamdata-external-buffer-failure.mjs |   9 +-
 test/parallel/test-quic-h3-origin.mjs         |  14 +-
 test/parallel/test-quic-h3-pending-stream.mjs |   9 +-
 .../parallel/test-quic-h3-post-filehandle.mjs |   9 +-
 test/parallel/test-quic-h3-post-request.mjs   |   9 +-
 test/parallel/test-quic-h3-priority.mjs       |  16 +-
 test/parallel/test-quic-h3-qpack-settings.mjs |  12 +-
 .../test-quic-h3-request-rejected.mjs         |   9 +-
 .../test-quic-h3-request-response.mjs         |   9 +-
 test/parallel/test-quic-h3-settings.mjs       |  20 +-
 .../test-quic-h3-status-code-type.mjs         |   9 +-
 test/parallel/test-quic-h3-stream-credit.mjs  |   9 +-
 ...st-quic-h3-stream-destroy-no-resurrect.mjs |   9 +-
 ...st-quic-h3-stream-destroy-with-headers.mjs |   9 +-
 .../test-quic-h3-stream-idle-timeout.mjs      |  23 +--
 .../test-quic-h3-stream-without-onstream.mjs  |  38 ++--
 .../test-quic-h3-trailing-headers.mjs         |   9 +-
 ...quic-h3-uni-stream-limit-start-failure.mjs |  40 ----
 ...est-quic-h3-zero-rtt-rejected-settings.mjs |  12 +-
 test/parallel/test-quic-h3-zero-rtt.mjs       |  13 +-
 .../test-quic-session-application-options.mjs |   9 +-
 42 files changed, 538 insertions(+), 541 deletions(-)
 delete mode 100644 test/parallel/test-quic-h3-goaway-non-h3.mjs
 delete mode 100644 test/parallel/test-quic-h3-uni-stream-limit-start-failure.mjs

diff --git a/benchmark/quic/h3-request.js b/benchmark/quic/h3-request.js
index 88fca0225f0e..cbb4f8491fbf 100644
--- a/benchmark/quic/h3-request.js
+++ b/benchmark/quic/h3-request.js
@@ -22,7 +22,7 @@ const bench = common.createBenchmark(main, {
              '--no-warnings'] });
 
 async function main({ mode, n }) {
-  const { listen, connect, Http3Session } = require('node:quic');
+  const { listen, connect } = require('node:quic');
   const { bytes } = require('stream/iter');
 
   const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
@@ -37,8 +37,7 @@ async function main({ mode, n }) {
     ':authority': 'localhost',
   };
 
-  const endpoint = await listen((quicSession) => {
-    const session = new Http3Session(quicSession);
+  const endpoint = await listen((session) => {
     session.opened.catch(() => {});
     session.closed.catch(() => {});
     session.onstream = (stream) => { stream.closed.catch(() => {}); };
@@ -65,12 +64,12 @@ async function main({ mode, n }) {
   // A full handshake, one request, one response. When resume is supplied the
   // request goes out in the first flight, before the handshake completes.
   async function exchange(resume) {
-    const session = new Http3Session(await connect(address, {
+    const session = await connect(address, {
       servername: 'localhost',
       verifyPeer: 'manual',
       alpn: 'h3',
       ...resume,
-    }));
+    });
     const stream = await session.createBidirectionalStream({
       headers: request,
       onheaders,
@@ -91,7 +90,7 @@ async function main({ mode, n }) {
     const { promise, resolve } = Promise.withResolvers();
     let ticket;
     let token;
-    const session = new Http3Session(await connect(address, {
+    const session = await connect(address, {
       servername: 'localhost',
       verifyPeer: 'manual',
       alpn: 'h3',
@@ -103,7 +102,7 @@ async function main({ mode, n }) {
         token ??= value;
         if (ticket !== undefined) resolve();
       },
-    }));
+    });
     await session.opened;
     await promise;
     session.close();
@@ -117,12 +116,12 @@ async function main({ mode, n }) {
   // otherwise a ticket the server stopped accepting would quietly turn this
   // into a measurement of the 1-RTT path.
   async function checkEarlyDataAccepted() {
-    const session = new Http3Session(await connect(address, {
+    const session = await connect(address, {
       servername: 'localhost',
       verifyPeer: 'manual',
       alpn: 'h3',
       ...resume,
-    }));
+    });
     const stream = await session.createBidirectionalStream({
       headers: request,
       onheaders,
diff --git a/benchmark/quic/handshake.js b/benchmark/quic/handshake.js
index 430e6a6e198f..2f886a54815d 100644
--- a/benchmark/quic/handshake.js
+++ b/benchmark/quic/handshake.js
@@ -19,15 +19,14 @@ const bench = common.createBenchmark(main, {
 }, { flags: ['--experimental-quic', '--no-warnings'] });
 
 async function main({ protocol, concurrency, n }) {
-  const { listen, connect, Http3Session } = require('node:quic');
+  const { listen, connect } = require('node:quic');
 
   const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
   const cert = fixtures.readKey('agent1-cert.pem');
   const http3 = protocol === 'h3';
   const alpn = http3 ? 'h3' : 'quic-bench';
 
-  const endpoint = await listen((quicSession) => {
-    const session = http3 ? new Http3Session(quicSession) : quicSession;
+  const endpoint = await listen((session) => {
     // A benchmark peer never reads these; swallow so a torn-down session
     // cannot produce an unhandled rejection.
     session.opened.catch(() => {});
@@ -48,12 +47,11 @@ async function main({ protocol, concurrency, n }) {
   const address = endpoint.address;
 
   async function handshake() {
-    const quicSession = await connect(address, {
+    const session = await connect(address, {
       servername: 'localhost',
       verifyPeer: 'manual',
       alpn,
     });
-    const session = http3 ? new Http3Session(quicSession) : quicSession;
     await session.opened;
     session.close();
     await session.closed.catch(() => {});
diff --git a/doc/api/quic.md b/doc/api/quic.md
index 0c58e61792f8..7f6b452fa93e 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -966,8 +966,8 @@ added:
 The current application-level options for this session. These include settings
 that are specific to the installed application protocol (e.g. HTTP/3) and may
 be negotiated separately from the transport parameters. `undefined` until an
-application is installed. Read only.
-You can use the callback [`session.onapplication`][] to be informed, when settings
+application is attached. Read only.
+You can use the callback [`http3session.onsettings`][] to be informed, when settings
 from the remote arrive.
 
 ### `session.close([options])`
@@ -1107,18 +1107,6 @@ added: v23.8.0
 The endpoint that created this session. Returns `null` if the session
 has been destroyed. Read only.
 
-### `session.onapplication`
-
-<!-- YAML
-added:
- - v26.4.0
- - v24.20.0
--->
-
-* Type: {quic.OnApplicationCallback}
-
-The callback to invoke when new application options, e.g. HTTP/3 settings arrived.
-
 ### `session.onerror`
 
 <!-- YAML
@@ -1149,6 +1137,10 @@ added: v23.8.0
 
 The callback to invoke when a new stream is initiated by a remote peer. Read/write.
 
+Setting this on a `QuicSession`, including via the `onstream` option in
+[`quic.connect()`][] or [`quic.listen()`][], selects raw QUIC for the session,
+so HTTP/3 can no longer be attached to it.
+
 If no `onstream` callback is set and the stream has no other consumer, an
 incoming stream is destroyed on arrival and a warning is emitted. An
 `onheaders` callback counts as a consumer when the negotiated application
@@ -1251,47 +1243,6 @@ The callback to invoke when a NEW\_TOKEN token is received from the server.
 The token can be passed as the `token` option on a future connection to
 the same server to skip address validation. Read/write.
 
-### `session.onorigin`
-
-<!-- YAML
-added:
- - v26.2.0
- - v24.20.0
--->
-
-* Type: {quic.OnOriginCallback}
-
-The callback to invoke when an ORIGIN frame (RFC 9412) is received from
-the server, indicating which origins the server is authoritative for.
-Read/write.
-
-### `session.ongoaway`
-
-<!-- YAML
-added:
- - v26.2.0
- - v24.20.0
--->
-
-* Type: {Function}
-
-The callback to invoke when the peer sends an HTTP/3 GOAWAY frame,
-indicating it is initiating a graceful shutdown. The callback receives
-`(lastStreamId)` where `lastStreamId` is a `{bigint}`:
-
-* When `lastStreamId` is `-1n`, the peer sent a shutdown notice (intent
-  to close) without specifying a stream boundary. All existing streams
-  may still be processed.
-* When `lastStreamId` is `>= 0n`, it is the highest stream ID the peer
-  may have processed. Streams with IDs above this value were NOT
-  processed and can be safely retried on a new connection.
-
-After GOAWAY is received, `session.createBidirectionalStream()` will
-throw `ERR_INVALID_STATE`. Existing streams continue until they
-complete or the session closes.
-
-This callback is only relevant for HTTP/3 sessions. Read/write.
-
 ### `session.onkeylog`
 
 <!-- YAML
@@ -1473,7 +1424,8 @@ 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.
+(via the `enableDatagrams` setting of [`Http3Session.from()`][]) 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).
@@ -2707,7 +2659,7 @@ added:
 * Type: {Object}
 
 The application specific options, configured for HTTP/3 with
-[`new Http3Session()`][].
+[`Http3Session.from()`][].
 
 #### `applicationOptions.maxHeaderPairs`
 
@@ -3843,11 +3795,11 @@ with that error:
 
 * Stream callbacks (`onblocked`, `onreset`, `onstopsending`, `onheaders`,
   `ontrailers`, `oninfo`, `onwanttrailers`): the stream is destroyed.
-* Session callbacks (`onapplication`, `onstream`, `ondatagram`,
-  `ondatagramstatus`, `onpathvalidation`, `onsessionticket`,
-  `onnewtoken`, `onversionnegotiation`, `onorigin`, `ongoaway`,
-  `onhandshake`, `onkeylog`, `onqlog`): the session is destroyed along
-  with all of its streams.
+* Session callbacks (`onstream`, `ondatagram`, `ondatagramstatus`,
+  `onpathvalidation`, `onsessionticket`, `onnewtoken`,
+  `onversionnegotiation`, `onhandshake`, `onkeylog`, `onqlog`, and the
+  [`Http3Session`][] callbacks `onsettings`, `onorigin` and `ongoaway`): the
+  session is destroyed along with all of its streams.
 
 Before destruction, the optional [`session.onerror`][] or
 [`stream.onerror`][] callback is invoked (if set), giving the application a
@@ -3911,7 +3863,7 @@ added: v23.8.0
 added: v23.8.0
 -->
 
-* `this` {quic.QuicSession}
+* `this` {quic.Http3Session}
 * `applicationoption` {quic.QuicSession}
 
 The callback function that is invoked when application options change.
@@ -4005,7 +3957,7 @@ added:
  - v24.20.0
 -->
 
-* `this` {quic.QuicSession}
+* `this` {quic.Http3Session}
 * `origins` {string\[]} The list of origins the server is authoritative for.
 
 ### Callback: `OnKeylogCallback`
@@ -4137,10 +4089,10 @@ applications:
 * **ORIGIN frame (RFC 9412)** — servers automatically advertise the
   hostnames in their [`sessionOptions.sni`][] map (entries with
   `authoritative: true`); clients receive the list via
-  [`session.onorigin`][].
+  [`http3session.onorigin`][].
 * **GOAWAY** — graceful shutdown. The server emits `GOAWAY` as part
   of [`session.close()`][]; the client observes it via
-  [`session.ongoaway`][] and stops opening new bidirectional streams.
+  [`http3session.ongoaway`][] and stops opening new bidirectional streams.
 * **Extended CONNECT settings (RFC 9220)** — the
   `SETTINGS_ENABLE_CONNECT_PROTOCOL` setting can be enabled via
   [`application.enableConnectProtocol`][]. The setting is exchanged
@@ -4155,7 +4107,7 @@ applications:
 import { connect, Http3Session } from 'node:quic';
 import process from 'node:process';
 
-const session = new Http3Session(await connect('example.com:443', {
+const session = Http3Session.from(await connect('example.com:443', {
   alpn: 'h3',
   servername: 'example.com',
 }));
@@ -4210,7 +4162,7 @@ const encoder = new TextEncoder();
 const endpoint = await listen((quicSession) => {
   // Attaching HTTP/3 has to happen here, synchronously, before the
   // callback returns.
-  const session = new Http3Session(quicSession);
+  const session = Http3Session.from(quicSession);
 
   // The session.onstream callback fires for each new client-initiated
   // stream. It is optional here: with `onheaders` configured below,
@@ -4289,9 +4241,13 @@ streams cannot be opened on the QUIC session directly:
 [`session.createBidirectionalStream()`][] and
 [`session.createUnidirectionalStream()`][] will throw `ERR_INVALID_STATE`,
 and request streams should be opened with
-[`http3session.createBidirectionalStream()`][] instead.
+[`http3session.createBidirectionalStream()`][] instead. Similarly, incoming
+streams are then only reported through [`http3session.onstream`][]: setting
+`onstream` on the QUIC session throws `ERR_INVALID_STATE`. Errors are the
+exception: they are transport-level, so they reach [`session.onerror`][] and
+then [`http3session.onerror`][], each of which may be set independently.
 
-### `new Http3Session(session[, options])`
+### `Http3Session.from(session[, options])`
 
 <!-- YAML
 added: REPLACEME
@@ -4302,8 +4258,9 @@ added: REPLACEME
   * `settings` {quic.ApplicationOptions} The HTTP/3 settings to use.
     Defaults apply to anything left out.
   * `ongoaway` {Function} See [`http3session.ongoaway`][].
-  * `onorigin` {Function} See [`session.onorigin`][].
+  * `onorigin` {Function} See [`http3session.onorigin`][].
   * `onsettings` {Function} See [`http3session.onsettings`][].
+* Returns: {quic.Http3Session}
 
 HTTP/3 can only be attached before the session becomes **active**. A session
 becomes active when: a stream is created on it; a datagram is sent with
@@ -4321,7 +4278,8 @@ attached synchronously when the [`session.opened`][] promise resolves (or
 before), and in both cases before anything is sent on the session.
 
 Attaching to a session that is already active throws `ERR_INVALID_STATE`, and
-leaves the session untouched.
+leaves the session untouched. The same applies once [`session.onstream`][] has
+been set, as that selects raw QUIC for the session.
 
 ### Members forwarded to the QUIC session
 
@@ -4331,13 +4289,29 @@ added: REPLACEME
 
 Each of the following behaves exactly as the member of the same name on the
 underlying [`QuicSession`][]: `alpnProtocol`, `certificate`, `close()`,
-`closed`, `destroy()`, `destroyed`, `ephemeralKeyInfo`, `onerror`, `opened`,
+`closed`, `destroy()`, `destroyed`, `ephemeralKeyInfo`, `opened`,
 `peerCertificate`, `servername`, and `stats`.
 
-Any callback set through the `Http3Session` - `onerror`, `onstream`, and the
-HTTP/3-specific ones below - is invoked with the `Http3Session` as `this`. The
-same callback set directly on the `QuicSession` is invoked with the
-`QuicSession`.
+Any callback set through the `Http3Session` - `onerror` and the
+HTTP/3-specific ones below - is invoked with the `Http3Session` as `this`.
+
+### `http3session.onerror`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {Function|undefined}
+
+The HTTP/3 session's error handler, invoked with the error the session is
+destroyed with. Setting this alone is enough: like [`session.onerror`][], it
+marks the session's promises as handled, and a throw or rejection here
+surfaces as an uncaught exception.
+
+The underlying `QuicSession`'s [`session.onerror`][] is separate, for code
+that wants to observe transport errors regardless of the application. When
+both are set, it is invoked first, with the same error, and one throwing does
+not prevent the other from running. Read/write.
 
 ### `http3session.createBidirectionalStream([options])`
 
@@ -4361,7 +4335,20 @@ added: REPLACEME
 
 * Type: {Function}
 
-See [`session.ongoaway`][].
+The callback to invoke when the peer sends an HTTP/3 GOAWAY frame,
+indicating it is initiating a graceful shutdown. The callback receives
+`(lastStreamId)` where `lastStreamId` is a `{bigint}`:
+
+* When `lastStreamId` is `-1n`, the peer sent a shutdown notice (intent
+  to close) without specifying a stream boundary. All existing streams
+  may still be processed.
+* When `lastStreamId` is `>= 0n`, it is the highest stream ID the peer
+  may have processed. Streams with IDs above this value were NOT
+  processed and can be safely retried on a new connection.
+
+After GOAWAY is received, `http3session.createBidirectionalStream()` will
+reject with `ERR_INVALID_STATE`. Existing streams continue until they
+complete or the session closes. Read/write.
 
 ### `http3session.onorigin`
 
@@ -4371,28 +4358,32 @@ added: REPLACEME
 
 * Type: {quic.OnOriginCallback}
 
-See [`session.onorigin`][].
+The callback to invoke when an ORIGIN frame (RFC 9412) is received from
+the server, indicating which origins the server is authoritative for.
+Read/write.
 
-### `http3session.onsettings`
+### `http3session.onstream`
 
 <!-- YAML
 added: REPLACEME
 -->
 
-* Type: {quic.OnApplicationCallback}
+* Type: {Function}
 
-See [`session.onapplication`][].
+Called as `onstream(stream)` with each request stream the client opens.
+HTTP/3 has no server-initiated requests, so this is never called on a client
+session. See [`session.onstream`][]. Read/write.
 
-### `http3session.onstream`
+### `http3session.onsettings`
 
 <!-- YAML
 added: REPLACEME
 -->
 
-* Type: {Function}
+* Type: {quic.OnApplicationCallback}
 
-Called with each request stream the peer opens, as a {quic.QuicStream}. See
-[`session.onstream`][].
+The callback to invoke when the peer's HTTP/3 SETTINGS arrive, which may be
+after the session opens. See [`http3session.settings`][]. Read/write.
 
 ### `http3session.quicSession`
 
@@ -4951,6 +4942,7 @@ throughput issues caused by flow control.
 [RFC 9369]: https://www.rfc-editor.org/rfc/rfc9369
 [RFC 9412]: https://www.rfc-editor.org/rfc/rfc9412
 [RFC 9443]: https://www.rfc-editor.org/rfc/rfc9443
+[`Http3Session.from()`]: #http3sessionfromsession-options
 [`Http3Session`]: #class-http3session
 [`PerformanceEntry`]: perf_hooks.md#class-performanceentry
 [`PerformanceObserver`]: perf_hooks.md#class-performanceobserver
@@ -4980,12 +4972,15 @@ throughput issues caused by flow control.
 [`error.errorCode`]: #errorerrorcode
 [`fs.promises.open(path, 'r')`]: fs.md#fspromisesopenpath-flags-mode
 [`http3session.createBidirectionalStream()`]: #http3sessioncreatebidirectionalstreamoptions
+[`http3session.onerror`]: #http3sessiononerror
 [`http3session.ongoaway`]: #http3sessionongoaway
+[`http3session.onorigin`]: #http3sessiononorigin
 [`http3session.onsettings`]: #http3sessiononsettings
+[`http3session.onstream`]: #http3sessiononstream
 [`http3session.quicSession`]: #http3sessionquicsession
+[`http3session.settings`]: #http3sessionsettings
 [`maxDatagramFrameSize`]: #transportparamsmaxdatagramframesize
 [`net.BlockList`]: net.md#class-netblocklist
-[`new Http3Session()`]: #new-http3sessionsession-options
 [`quic.connect()`]: #quicconnectaddress-options
 [`quic.listen()`]: #quiclistenonsession-options
 [`session.close()`]: #sessioncloseoptions
@@ -4993,15 +4988,12 @@ throughput issues caused by flow control.
 [`session.createUnidirectionalStream()`]: #sessioncreateunidirectionalstreamoptions
 [`session.destroy()`]: #sessiondestroyerror-options
 [`session.maxPendingDatagrams`]: #sessionmaxpendingdatagrams
-[`session.onapplication`]: #sessiononapplication
 [`session.ondatagram`]: #sessionondatagram
 [`session.ondatagramstatus`]: #sessionondatagramstatus
 [`session.onearlyrejected`]: #sessiononearlyrejected
 [`session.onerror`]: #sessiononerror
-[`session.ongoaway`]: #sessionongoaway
 [`session.onkeylog`]: #sessiononkeylog
 [`session.onnewtoken`]: #sessiononnewtoken
-[`session.onorigin`]: #sessiononorigin
 [`session.onqlog`]: #sessiononqlog
 [`session.onsessionticket`]: #sessiononsessionticket
 [`session.onstream`]: #sessiononstream
diff --git a/lib/internal/quic/http3.js b/lib/internal/quic/http3.js
index 608a27e1236f..d54a832dd58a 100644
--- a/lib/internal/quic/http3.js
+++ b/lib/internal/quic/http3.js
@@ -26,9 +26,14 @@ const {
   getQuicSessionHandle,
   getQuicSessionState,
   isQuicSession,
+  setApplicationCallback,
 } = require('internal/quic/quic');
 
-const { kInspect } = require('internal/quic/symbols');
+const {
+  kInspect,
+  kPrivateConstructor,
+} = require('internal/quic/symbols');
+const { kEmptyObject } = require('internal/util');
 const { inspect } = require('internal/util/inspect');
 
 const {
@@ -45,13 +50,13 @@ const {
 
 const {
   codes: {
+    ERR_ILLEGAL_CONSTRUCTOR,
     ERR_INVALID_ARG_TYPE,
     ERR_INVALID_STATE,
     ERR_OUT_OF_RANGE,
   },
 } = require('internal/errors');
 
-const kEmptyObject = { __proto__: null };
 const kMaxUint64 = (1n << 64n) - 1n;
 
 function validateUint64Setting(value, name) {
@@ -113,9 +118,7 @@ function prepareH3Settings(settings) {
 }
 
 function checkAttachable(session, state) {
-  if (session.destroyed ||
-    state.applicationType === undefined ||
-    getQuicSessionHandle(session) === undefined) {
+  if (session.destroyed) {
     throw new ERR_INVALID_STATE(
       'An application cannot be attached to a destroyed QUIC session');
   }
@@ -141,8 +144,16 @@ class Http3Session {
    * @param {Function} [options.ongoaway]
    * @param {Function} [options.onorigin]
    * @param {Function} [options.onsettings]
+   * @returns {Http3Session}
    */
-  constructor(session, options = kEmptyObject) {
+  static from(session, options) {
+    return new Http3Session(kPrivateConstructor, session, options);
+  }
+
+  constructor(privateSymbol, session, options = kEmptyObject) {
+    if (privateSymbol !== kPrivateConstructor) {
+      throw new ERR_ILLEGAL_CONSTRUCTOR();
+    }
     if (!isQuicSession(session)) {
       throw new ERR_INVALID_ARG_TYPE('session', 'QuicSession', session);
     }
@@ -170,15 +181,15 @@ class Http3Session {
     this.#session = session;
     if (ongoaway !== undefined) {
       this.#ongoaway = ongoaway;
-      session.ongoaway = this.#bind(ongoaway);
+      setApplicationCallback(session, 'ongoaway', this.#bind(ongoaway));
     }
     if (onorigin !== undefined) {
       this.#onorigin = onorigin;
-      session.onorigin = this.#bind(onorigin);
+      setApplicationCallback(session, 'onorigin', this.#bind(onorigin));
     }
     if (onsettings !== undefined) {
       this.#onsettings = onsettings;
-      session.onapplication = this.#bind(onsettings);
+      setApplicationCallback(session, 'onapplication', this.#bind(onsettings));
     }
   }
 
@@ -219,40 +230,50 @@ class Http3Session {
   }
 
   /**
-   * Called with each request stream the peer opens.
+   * Called with each request stream the client opens. HTTP/3 has no
+   * server-initiated requests, so this never fires on a client session.
    * @type {Function|undefined}
    */
   get onstream() { return this.#onstream; }
   set onstream(fn) {
-    this.#session.onstream = this.#bind(fn);
+    if (fn !== undefined) validateFunction(fn, 'onstream');
+    setApplicationCallback(this.#session, 'onstream', this.#bind(fn));
     this.#onstream = fn;
   }
 
   /** @type {Function|undefined} */
   get ongoaway() { return this.#ongoaway; }
   set ongoaway(fn) {
-    this.#session.ongoaway = this.#bind(fn);
+    if (fn !== undefined) validateFunction(fn, 'ongoaway');
+    setApplicationCallback(this.#session, 'ongoaway', this.#bind(fn));
     this.#ongoaway = fn;
   }
 
   /** @type {Function|undefined} */
   get onorigin() { return this.#onorigin; }
   set onorigin(fn) {
-    this.#session.onorigin = this.#bind(fn);
+    if (fn !== undefined) validateFunction(fn, 'onorigin');
+    setApplicationCallback(this.#session, 'onorigin', this.#bind(fn));
     this.#onorigin = fn;
   }
 
   /** @type {Function|undefined} */
   get onsettings() { return this.#onsettings; }
   set onsettings(fn) {
-    this.#session.onapplication = this.#bind(fn);
+    if (fn !== undefined) validateFunction(fn, 'onsettings');
+    setApplicationCallback(this.#session, 'onapplication', this.#bind(fn));
     this.#onsettings = fn;
   }
 
-  /** @type {Function|undefined} */
+  /**
+   * Called with a session error after the QUIC session's own onerror, which
+   * stays the transport-level handler. Either may be set independently.
+   * @type {Function|undefined}
+   */
   get onerror() { return this.#onerror; }
   set onerror(fn) {
-    this.#session.onerror = this.#bind(fn);
+    if (fn !== undefined) validateFunction(fn, 'onerror');
+    setApplicationCallback(this.#session, 'onapperror', this.#bind(fn));
     this.#onerror = fn;
   }
 
diff --git a/lib/internal/quic/quic.js b/lib/internal/quic/quic.js
index ec0747f3a788..be9cc64b5323 100644
--- a/lib/internal/quic/quic.js
+++ b/lib/internal/quic/quic.js
@@ -463,11 +463,8 @@ const endpointRegistry = new SafeSet();
  * @property {OnVersionNegotiationCallback} [onversionnegotiation] Version negotiation callback.
  * @property {OnHandshakeCallback} [onhandshake] Handshake-completed callback.
  * @property {OnNewTokenCallback} [onnewtoken] NEW_TOKEN frame callback (client only).
- * @property {OnOriginCallback} [onorigin] ORIGIN frame callback (client only).
- * @property {OnGoawayCallback} [ongoaway] GOAWAY frame callback.
  * @property {OnKeylogCallback} [onkeylog] TLS key-log callback.
  * @property {OnQlogCallback} [onqlog] qlog data callback.
- * @property {OnApplicationCallback} [onapplication] application options callback.
  * @property {OnHeadersCallback} [onheaders] Default per-stream initial-headers callback.
  * @property {OnTrailersCallback} [ontrailers] Default per-stream trailing-headers callback.
  * @property {OnInfoCallback} [oninfo] Default per-stream informational-headers callback.
@@ -1339,11 +1336,8 @@ function applyCallbacks(session, cbs) {
   if (cbs.onhandshake) session.onhandshake = cbs.onhandshake;
   if (cbs.onnewtoken) session.onnewtoken = cbs.onnewtoken;
   if (cbs.onearlyrejected) session.onearlyrejected = cbs.onearlyrejected;
-  if (cbs.onorigin) session.onorigin = cbs.onorigin;
-  if (cbs.ongoaway) session.ongoaway = cbs.ongoaway;
   if (cbs.onkeylog) session.onkeylog = cbs.onkeylog;
   if (cbs.onqlog) session.onqlog = cbs.onqlog;
-  if (cbs.onapplication) session.onapplication = cbs.onapplication;
   if (cbs.onheaders || cbs.ontrailers || cbs.oninfo || cbs.onwanttrailers) {
     session[kStreamCallbacks] = {
       __proto__: null,
@@ -1566,6 +1560,7 @@ let isQuicStream;
 let isQuicSession;
 let getQuicSessionHandle;
 let createApplicationStream;
+let setApplicationCallback;
 let isQuicEndpoint;
 
 function maybeGetCloseError(context, status, pendingError) {
@@ -2865,6 +2860,8 @@ class QuicSession {
     stats: undefined,
     streams: new SafeSet(),
     onerror: undefined,
+    // The attached application's own error handler, told after onerror.
+    onapperror: undefined,
     onstream: undefined,
     ondatagram: undefined,
     ondatagramstatus: undefined,
@@ -2918,6 +2915,21 @@ class QuicSession {
       return session.#createStream(direction, options);
     };
 
+    // For the attached application, which owns these callbacks and passes
+    // them in already validated and bound:
+    setApplicationCallback = (session, name, fn) => {
+      assertIsQuicSession(session);
+      const inner = session.#inner;
+      inner[name] = fn;
+      if (name === 'onorigin') {
+        inner.state.hasOriginListener = fn !== undefined;
+      } else if (name === 'onapplication') {
+        inner.state.hasApplicationListener = fn !== undefined;
+      } else if (name === 'onapperror' && fn !== undefined) {
+        session.#markErrorsHandled();
+      }
+    };
+
     getQuicSessionState = function(session) {
       assertIsQuicSession(session);
       return session.#inner.state;
@@ -2966,7 +2978,6 @@ class QuicSession {
     return this.#handle.applicationOptions();
   }
 
-
   get localTransportParams() {
     if (this.#inner.localTransportParams !== undefined) {
       return this.#inner.localTransportParams;
@@ -3029,14 +3040,19 @@ class QuicSession {
       // as handled so that rejections from destroy(error) don't surface
       // as unhandled rejections. The onerror callback is the
       // application's error handler for this session.
-      markPromiseAsHandled(inner.pendingClose.promise);
-      markPromiseAsHandled(inner.pendingOpen.promise);
-      // Also mark existing streams' closed promises. Stream rejections
-      // during session destruction are expected collateral when the
-      // session has an error handler.
-      for (const stream of inner.streams) {
-        markPromiseAsHandled(stream.closed);
-      }
+      this.#markErrorsHandled();
+    }
+  }
+
+  #markErrorsHandled() {
+    const inner = this.#inner;
+    markPromiseAsHandled(inner.pendingClose.promise);
+    markPromiseAsHandled(inner.pendingOpen.promise);
+    // Mark existing streams' closed promises. Stream rejections
+    // during session destruction are expected collateral when the
+    // session has an error handler.
+    for (const stream of inner.streams) {
+      markPromiseAsHandled(stream.closed);
     }
   }
 
@@ -3048,12 +3064,24 @@ class QuicSession {
 
   set onstream(fn) {
     assertIsQuicSession(this);
+    // Once an application is attached, incoming streams are reported
+    // through it:
+    if (this.#inner.state.applicationType > kApplicationTypeDefault) {
+      throw new ERR_INVALID_STATE(
+        'onstream cannot be set on a session with a non-default ' +
+        'application attached. Set it through the application interface ' +
+        '(e.g. Http3Session) instead');
+    }
     const inner = this.#inner;
     if (fn === undefined) {
       inner.onstream = undefined;
     } else {
       validateFunction(fn, 'onstream');
       inner.onstream = FunctionPrototypeBind(fn, this);
+      // Listening for raw streams means committing to raw QUIC:
+      if (inner.state.applicationType === 0) {
+        inner.state.applicationType = kApplicationTypeDefault;
+      }
     }
   }
 
@@ -3209,25 +3237,6 @@ class QuicSession {
     }
   }
 
-  /** @type {Function|undefined} */
-  get onapplication() {
-    assertIsQuicSession(this);
-    return this.#inner.onapplication;
-  }
-
-  set onapplication(fn) {
-    assertIsQuicSession(this);
-    const inner = this.#inner;
-    if (fn === undefined) {
-      inner.onapplication = undefined;
-      inner.state.hasApplicationListener = false;
-    } else {
-      validateFunction(fn, 'onapplication');
-      inner.onapplication = FunctionPrototypeBind(fn, this);
-      inner.state.hasApplicationListener = true;
-    }
-  }
-
   /** @type {Function|undefined} */
   get onversionnegotiation() {
     assertIsQuicSession(this);
@@ -3298,42 +3307,6 @@ class QuicSession {
     }
   }
 
-  /** @type {Function|undefined} */
-  get onorigin() {
-    assertIsQuicSession(this);
-    return this.#inner.onorigin;
-  }
-
-  set onorigin(fn) {
-    assertIsQuicSession(this);
-    const inner = this.#inner;
-    if (fn === undefined) {
-      inner.onorigin = undefined;
-      inner.state.hasOriginListener = false;
-    } else {
-      validateFunction(fn, 'onorigin');
-      inner.onorigin = FunctionPrototypeBind(fn, this);
-      inner.state.hasOriginListener = true;
-    }
-  }
-
-  /** @type {Function|undefined} */
-  get ongoaway() {
-    assertIsQuicSession(this);
-    return this.#inner.ongoaway;
-  }
-
-  set ongoaway(fn) {
-    assertIsQuicSession(this);
-    const inner = this.#inner;
-    if (fn === undefined) {
-      inner.ongoaway = undefined;
-    } else {
-      validateFunction(fn, 'ongoaway');
-      inner.ongoaway = FunctionPrototypeBind(fn, this);
-    }
-  }
-
   /**
    * The maximum datagram size the peer will accept, or 0 if datagrams
    * are not supported or the handshake has not yet completed.
@@ -3769,6 +3742,10 @@ class QuicSession {
       if (typeof inner.onerror === 'function') {
         invokeOnerror(inner.onerror, error);
       }
+      // The transport is told first, then the application layered on top:
+      if (typeof inner.onapperror === 'function') {
+        invokeOnerror(inner.onapperror, error);
+      }
     }
 
     // First, forcefully and immediately destroy all open streams, if any.
@@ -3841,6 +3818,7 @@ class QuicSession {
     }
 
     inner.onerror = undefined;
+    inner.onapperror = undefined;
     inner.onstream = undefined;
     inner.ondatagram = undefined;
     inner.ondatagramstatus = undefined;
@@ -4703,11 +4681,8 @@ class QuicEndpoint {
       onhandshake,
       onnewtoken,
       onearlyrejected,
-      onorigin,
-      ongoaway,
       onkeylog,
       onqlog,
-      onapplication,
       // Stream-level callbacks applied to each incoming stream.
       onheaders,
       ontrailers,
@@ -4733,11 +4708,8 @@ class QuicEndpoint {
       onhandshake,
       onnewtoken,
       onearlyrejected,
-      onorigin,
-      ongoaway,
       onkeylog,
       onqlog,
-      onapplication,
       onheaders,
       ontrailers,
       oninfo,
@@ -5513,12 +5485,8 @@ function processSessionOptions(options, config = kEmptyObject) {
     onhandshake,
     onnewtoken,
     onearlyrejected,
-    onorigin,
-    ongoaway,
     onkeylog,
     onqlog,
-    onapplication,
-    // Application level options changed, e.g. HTTP/3 settings related
     // Stream-level callbacks.
     onheaders,
     ontrailers,
@@ -5641,11 +5609,8 @@ function processSessionOptions(options, config = kEmptyObject) {
     onhandshake,
     onnewtoken,
     onearlyrejected,
-    onorigin,
-    ongoaway,
     onkeylog,
     onqlog,
-    onapplication,
     onheaders,
     ontrailers,
     oninfo,
@@ -5771,6 +5736,7 @@ module.exports = {
   createApplicationStream,
   getQuicSessionHandle,
   isQuicSession,
+  setApplicationCallback,
   // These are exported only for internal testing purposes.
   getQuicStreamState,
   getQuicSessionState,
diff --git a/src/quic/README.md b/src/quic/README.md
index c8daf0bade5f..9d2d51f8d1b4 100644
--- a/src/quic/README.md
+++ b/src/quic/README.md
@@ -146,7 +146,7 @@ protocol-specific behavior to. Two implementations exist:
   prioritization. Manages unidirectional control streams internally.
 
 A Session starts without an Application. JavaScript schedules an attach (that
-is what `new Http3Session(session)` does) by writing to the shared state, and
+is what `Http3Session.from(session)` does) by writing to the shared state, and
 the Session attaches it - or the `DefaultApplication` - when it becomes active,
 meaning the first time an Application is needed.
 
diff --git a/src/quic/http3.h b/src/quic/http3.h
index 257d24180bf2..3097b8e85c54 100644
--- a/src/quic/http3.h
+++ b/src/quic/http3.h
@@ -8,7 +8,6 @@
 #include "session.h"
 
 namespace node {
-class ExternalReferenceRegistry;
 class Realm;
 namespace quic {
 
diff --git a/test/parallel/test-quic-early-selection-order.mjs b/test/parallel/test-quic-early-selection-order.mjs
index 3d7c39a3e1eb..f7cc89fb04c0 100644
--- a/test/parallel/test-quic-early-selection-order.mjs
+++ b/test/parallel/test-quic-early-selection-order.mjs
@@ -13,7 +13,6 @@ if (!hasQuic) {
 }
 
 const { listen, connect } = await import('../common/quic.mjs');
-const { Http3Session } = await import('node:quic');
 const { bytes } = await import('stream/iter');
 
 const encoder = new TextEncoder();
@@ -28,8 +27,7 @@ const decoder = new TextDecoder();
   const gotTicket = Promise.withResolvers();
   const gotToken = Promise.withResolvers();
 
-  const endpoint = await listen(mustCall((quicSession) => {
-    const ss = new Http3Session(quicSession);
+  const endpoint = await listen(mustCall((ss) => {
     // No streams initially, stream must arrive in the onstream event, for
     // both the normal and the 0RTT sessions:
     assert.strictEqual(ss.stats.bidiInStreamCount, 0n);
@@ -54,12 +52,12 @@ const decoder = new TextDecoder();
   };
 
   // Open a 1st session, send a request, get session ticket & token:
-  const cs1 = new Http3Session(await connect(endpoint.address, {
+  const cs1 = await connect(endpoint.address, {
     servername: 'localhost',
     alpn: 'h3',
     onsessionticket: mustCall((t) => { ticket = t; gotTicket.resolve(); }, 2),
     onnewtoken: mustCall((t) => { token = t; gotToken.resolve(); }),
-  }));
+  });
   await cs1.opened;
   await Promise.all([gotTicket.promise, gotToken.promise]);
   const s1 = await cs1.createBidirectionalStream({
@@ -70,12 +68,12 @@ const decoder = new TextDecoder();
   await Promise.all([s1.closed, cs1.closed]);
 
   // Open 2nd session, reusing the ticket & token:
-  const cs2 = new Http3Session(await connect(endpoint.address, {
+  const cs2 = await connect(endpoint.address, {
     servername: 'localhost',
     alpn: 'h3',
     sessionTicket: ticket,
     token,
-  }));
+  });
 
   // Send a 0RTT request immediately, before the handshake completes:
   const s2 = await cs2.createBidirectionalStream({
diff --git a/test/parallel/test-quic-h3-attach.mjs b/test/parallel/test-quic-h3-attach.mjs
index 798e5b4aefae..f51170829469 100644
--- a/test/parallel/test-quic-h3-attach.mjs
+++ b/test/parallel/test-quic-h3-attach.mjs
@@ -19,41 +19,68 @@ const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
 const cert = fixtures.readKey('agent1-cert.pem');
 const serverOpts = {
   alpn: ['h3'],
+  autoWrap: false,
   sni: { '*': { keys: [key], certs: [cert] } },
 };
 const clientOpts = {
   alpn: 'h3',
+  autoWrap: false,
   servername: 'localhost',
   verifyPeer: 'manual',
 };
 const enc = new TextEncoder();
 const dec = new TextDecoder();
 
-// Only a QuicSession can carry an HTTP/3 session.
-assert.throws(() => new Http3Session({}), { code: 'ERR_INVALID_ARG_TYPE' });
+// Only a QuicSession can carry an HTTP/3 session, attached with from():
+assert.throws(() => Http3Session.from({}), { code: 'ERR_INVALID_ARG_TYPE' });
+assert.throws(() => new Http3Session(), { code: 'ERR_ILLEGAL_CONSTRUCTOR' });
 
 // Both peers attached after the session already exists, and the attach
 // itself validated.
 {
   const endpoint = await listen(mustCall((quicSession) => {
-    const session = new Http3Session(quicSession);
+    const session = Http3Session.from(quicSession);
     assert.strictEqual(session.quicSession, quicSession);
 
     // Can only attach once:
-    assert.throws(() => new Http3Session(quicSession),
+    assert.throws(() => Http3Session.from(quicSession),
                   { code: 'ERR_INVALID_STATE' });
+
+    // HTTP/3 frames every stream, so raw streams can no longer be opened:
+    const rawRefused = {
+      code: 'ERR_INVALID_STATE',
+      message: /Raw QUIC streams cannot be created/,
+    };
+    assert.rejects(quicSession.createUnidirectionalStream(), rawRefused)
+      .then(mustCall());
+    assert.rejects(quicSession.createBidirectionalStream(), rawRefused)
+      .then(mustCall());
+
+    // Incoming streams are now reported through the Http3Session only:
+    assert.throws(() => { quicSession.onstream = () => {}; }, {
+      code: 'ERR_INVALID_STATE',
+      message: /cannot be set on a session/,
+    });
+    // And the HTTP/3-only callbacks exist only there:
+    for (const name of ['ongoaway', 'onorigin', 'onapplication']) {
+      assert.strictEqual(name in quicSession, false);
+    }
+    // The onerror callback stays transport-level, so both sides keep their own:
+    quicSession.onerror = () => {};
+    session.onerror = () => {};
+    assert.notStrictEqual(quicSession.onerror, session.onerror);
   }), serverOpts);
 
   const quicClient = await connect(endpoint.address, clientOpts);
 
   // Options are validated before anything is recorded, so the session is
   // still attachable after these failures:
-  assert.throws(() => new Http3Session(quicClient, null),
+  assert.throws(() => Http3Session.from(quicClient, null),
                 { code: 'ERR_INVALID_ARG_TYPE' });
-  assert.throws(() => new Http3Session(quicClient, { ongoaway: 5 }),
+  assert.throws(() => Http3Session.from(quicClient, { ongoaway: 5 }),
                 { code: 'ERR_INVALID_ARG_TYPE' });
 
-  const client = new Http3Session(quicClient);
+  const client = Http3Session.from(quicClient);
   await client.opened;
 
   assert.strictEqual(client.alpnProtocol, 'h3');
@@ -69,12 +96,41 @@ const tooLate = {
   message: /already has an application/,
 };
 
+// HTTP/3-only callbacks can't be passed as QuicSession options, so they
+// can't be registered before the application exists:
+for (const name of ['ongoaway', 'onorigin', 'onapplication']) {
+  const expected = {
+    code: 'ERR_INVALID_ARG_VALUE',
+    message: new RegExp(`options\\.${name}.*Http3Session`),
+  };
+  const callback = { [name]: () => {} };
+  await assert.rejects(listen(() => {}, { ...serverOpts, ...callback }),
+                       expected);
+  await assert.rejects(connect('127.0.0.1:1', { ...clientOpts, ...callback }),
+                       expected);
+}
+
+// Setting onstream claims the session for raw QUIC, so HTTP/3 can't be
+// attached afterwards, whether it is set directly or passed as an option.
+{
+  const endpoint = await listen(mustCall((quicSession) => {
+    quicSession.onstream = () => {};
+    assert.throws(() => Http3Session.from(quicSession), tooLate);
+  }), serverOpts);
+  const client = await connect(endpoint.address,
+                               { ...clientOpts, onstream: () => {} });
+  assert.throws(() => Http3Session.from(client), tooLate);
+  await client.opened;
+  await client.close();
+  await endpoint.close();
+}
+
 // Server: an attach deferred past the session callback is rejected.
 {
   const done = Promise.withResolvers();
   const endpoint = await listen(mustCall((quicSession) => {
     setImmediate(mustCall(() => {
-      assert.throws(() => new Http3Session(quicSession), tooLate);
+      assert.throws(() => Http3Session.from(quicSession), tooLate);
       done.resolve();
     }));
   }), serverOpts);
@@ -89,7 +145,7 @@ const tooLate = {
 // `opened`, so the negotiated ALPN can be read and acted on before attaching.
 {
   const endpoint = await listen(mustCall((quicSession) => {
-    new Http3Session(quicSession);
+    Http3Session.from(quicSession);
   }), serverOpts);
   const client = await connect(endpoint.address, clientOpts);
   const info = await client.opened;
@@ -97,7 +153,7 @@ const tooLate = {
   assert.strictEqual(client.alpnProtocol, 'h3');
   // Further already-settled awaits are still the same checkpoint.
   await null;
-  const http3 = new Http3Session(client);
+  const http3 = Http3Session.from(client);
   assert.strictEqual(http3.alpnProtocol, 'h3');
   await http3.close();
   await endpoint.close();
@@ -108,13 +164,13 @@ const tooLate = {
 // some other reason.
 {
   const endpoint = await listen(mustCall((quicSession) => {
-    new Http3Session(quicSession);
+    Http3Session.from(quicSession);
   }), serverOpts);
   const client = await connect(endpoint.address, clientOpts);
   await client.opened;
   await new Promise(setImmediate);
-  assert.throws(() => new Http3Session(client), tooLate);
-  assert.throws(() => new Http3Session(client), tooLate);
+  assert.throws(() => Http3Session.from(client), tooLate);
+  assert.throws(() => Http3Session.from(client), tooLate);
 
   await client.close();
   await endpoint.close();
@@ -132,7 +188,7 @@ const tooLate = {
   }), serverOpts);
   const client = await connect(endpoint.address, clientOpts);
   const raw = await client.createUnidirectionalStream({ body: enc.encode('x') });
-  assert.throws(() => new Http3Session(client), tooLate);
+  assert.throws(() => Http3Session.from(client), tooLate);
   await client.opened;
   await serverGot.promise;
   await raw.closed;
@@ -149,7 +205,40 @@ const tooLate = {
   const client = await connect(endpoint.address, { ...clientOpts, ...dgramOpts });
   await client.opened;
   await client.sendDatagram(enc.encode('x'));
-  assert.throws(() => new Http3Session(client), tooLate);
+  assert.throws(() => Http3Session.from(client), tooLate);
+  await client.close();
+  await endpoint.close();
+}
+
+// Settings are validated before anything is recorded, so a rejected value
+// names the property at fault and leaves the session still attachable.
+{
+  const endpoint = await listen(mustCall((quicSession) => {
+    Http3Session.from(quicSession);
+  }), serverOpts);
+  const client = await connect(endpoint.address, clientOpts);
+  for (const settings of [42, true, 'nope', null]) {
+    assert.throws(() => Http3Session.from(client, { settings }),
+                  { code: 'ERR_INVALID_ARG_TYPE', message: /options\.settings/ });
+  }
+  const badType = { code: 'ERR_INVALID_ARG_TYPE' };
+  const badRange = { code: 'ERR_OUT_OF_RANGE' };
+  for (const [settings, expected] of [
+    [{ maxHeaderPairs: 'lots' }, badType],
+    [{ maxHeaderPairs: 1.5 }, badRange],
+    [{ qpackBlockedStreams: 1n << 65n }, badRange],
+    [{ enableDatagrams: 1 }, badType],
+  ]) {
+    assert.throws(() => Http3Session.from(client, { settings }), (err) => {
+      assert.strictEqual(err.code, expected.code);
+      assert.match(err.message, /options\.settings\./);
+      return true;
+    });
+  }
+  // Numbers are accepted for bigint settings:
+  const http3 = Http3Session.from(client, { settings: { maxHeaderPairs: 12 } });
+  assert.strictEqual(http3.settings.maxHeaderPairs, 12n);
+  await http3.opened;
   await client.close();
   await endpoint.close();
 }
@@ -164,9 +253,9 @@ const tooLate = {
     enableConnectProtocol: false,
   };
   const endpoint = await listen(mustCall((quicSession) => {
-    new Http3Session(quicSession);
+    Http3Session.from(quicSession);
   }), serverOpts);
-  const client = new Http3Session(
+  const client = Http3Session.from(
     await connect(endpoint.address, clientOpts), { settings });
 
   await client.opened;
@@ -189,7 +278,7 @@ const tooLate = {
     const settings = {
       get maxHeaderPairs() { quicSession.destroy(); return 10n; },
     };
-    assert.throws(() => new Http3Session(quicSession, { settings }), {
+    assert.throws(() => Http3Session.from(quicSession, { settings }), {
       code: 'ERR_INVALID_STATE',
       message: /destroyed/,
     });
@@ -217,7 +306,7 @@ const tooLate = {
       return 10n;
     },
   };
-  assert.throws(() => new Http3Session(client, { settings }), tooLate);
+  assert.throws(() => Http3Session.from(client, { settings }), tooLate);
   await (await raw).closed;
   await client.close();
   await endpoint.close();
@@ -226,20 +315,20 @@ const tooLate = {
   // Client: the getter attaches another Http3Session. That inner attach is
   // the one that sticks; the outer one finds the session already claimed.
   const endpoint = await listen(mustCall((quicSession) => {
-    new Http3Session(quicSession);
+    Http3Session.from(quicSession);
   }), serverOpts);
 
   const client = await connect(endpoint.address, clientOpts);
   let inner;
   const settings = {
-    get maxHeaderPairs() { inner = new Http3Session(client); return 10n; },
+    get maxHeaderPairs() { inner = Http3Session.from(client); return 10n; },
   };
-  assert.throws(() => new Http3Session(client, { settings }), {
+  assert.throws(() => Http3Session.from(client, { settings }), {
     code: 'ERR_INVALID_STATE',
     message: /already has an application/,
   });
   assert.ok(inner instanceof Http3Session);
-  assert.throws(() => new Http3Session(client), {
+  assert.throws(() => Http3Session.from(client), {
     code: 'ERR_INVALID_STATE',
     message: /already has an application/,
   });
@@ -253,14 +342,15 @@ const tooLate = {
 {
   const refused = Promise.withResolvers();
   const endpoint = await listen(mustCall((quicSession) => {
-    const server = new Http3Session(quicSession);
+    const server = Http3Session.from(quicSession);
     refused.resolve(assert.rejects(server.createBidirectionalStream(), {
       code: 'ERR_INVALID_STATE',
       message: /Server sessions cannot open HTTP\/3 request streams/,
     }));
   }), serverOpts);
-  const client = new Http3Session(await connect(endpoint.address, clientOpts));
+  const client = Http3Session.from(await connect(endpoint.address, clientOpts));
   await refused.promise;
+  await client.opened;
   await client.close();
   await endpoint.close();
 }
diff --git a/test/parallel/test-quic-h3-callback-errors.mjs b/test/parallel/test-quic-h3-callback-errors.mjs
index 9fbd64ab0a44..67f8dcc6daa5 100644
--- a/test/parallel/test-quic-h3-callback-errors.mjs
+++ b/test/parallel/test-quic-h3-callback-errors.mjs
@@ -2,6 +2,7 @@
 
 // Test: HTTP/3 callback error handling.
 // Sync throw in onorigin callback destroys the session
+// Session errors reach the QuicSession's onerror, then the Http3Session's
 // Sync throw in onheaders callback destroys the stream
 // Async rejection in onheaders callback destroys the stream
 // Sync throw in ontrailers callback destroys the stream
@@ -24,8 +25,7 @@ const encoder = new TextEncoder();
 
 async function makeServer(onheadersHandler, extraOpts = {}) {
   const done = Promise.withResolvers();
-  const ep = await listen(mustCall(async (quicSession) => {
-    const ss = new Http3Session(quicSession);
+  const ep = await listen(mustCall(async (ss) => {
     ss.onstream = mustCall((stream) => {
       // The server completes its response before the client's
       // callback throws, so the server stream always resolves.
@@ -53,12 +53,12 @@ async function makeServer(onheadersHandler, extraOpts = {}) {
     }),
   );
 
-  const c = new Http3Session(await connect(ep.address, {
+  const c = await connect(ep.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
     transportParams: { maxIdleTimeout: 1 },
-  }));
+  });
   await c.opened;
 
   const s = await c.createBidirectionalStream({
@@ -94,12 +94,12 @@ async function makeServer(onheadersHandler, extraOpts = {}) {
     }),
   );
 
-  const c = new Http3Session(await connect(ep.address, {
+  const c = await connect(ep.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
     transportParams: { maxIdleTimeout: 1 },
-  }));
+  });
   await c.opened;
 
   const s = await c.createBidirectionalStream({
@@ -140,12 +140,12 @@ async function makeServer(onheadersHandler, extraOpts = {}) {
     },
   );
 
-  const c = new Http3Session(await connect(ep.address, {
+  const c = await connect(ep.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
     transportParams: { maxIdleTimeout: 1 },
-  }));
+  });
   await c.opened;
 
   const s = await c.createBidirectionalStream({
@@ -176,8 +176,7 @@ async function makeServer(onheadersHandler, extraOpts = {}) {
 
 // Sync throw in onorigin callback destroys the session.
 {
-  const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const ss = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall(async (ss) => {
     await ss.closed;
   }), {
     alpn: ['h3'],
@@ -194,17 +193,19 @@ async function makeServer(onheadersHandler, extraOpts = {}) {
 
   const quicSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
+    autoWrap: false,
     servername: 'example.com',
     verifyPeer: 'manual',
     transportParams: { maxIdleTimeout: 1 },
     onerror: mustCall(function(error) {
       assert.strictEqual(error.message, 'onorigin error');
     }),
+  });
+  const clientSession = Http3Session.from(quicSession, {
     onorigin: mustCall(function() {
       throw new Error('onorigin error');
     }),
   });
-  const clientSession = new Http3Session(quicSession);
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
@@ -235,8 +236,7 @@ async function makeServer(onheadersHandler, extraOpts = {}) {
   const serverStreamRejected = Promise.withResolvers();
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const ss = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall(async (ss) => {
     ss.onstream = mustCall(async (stream) => {
       // The server stream rejects because onwanttrailers threw.
       await assert.rejects(stream.closed, mustCall((err) => {
@@ -261,12 +261,12 @@ async function makeServer(onheadersHandler, extraOpts = {}) {
     }),
   });
 
-  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  const clientSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
     transportParams: { maxIdleTimeout: 1 },
-  }));
+  });
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
@@ -290,3 +290,52 @@ async function makeServer(onheadersHandler, extraOpts = {}) {
   await Promise.all([stream.closed, serverDone.promise]);
   await serverEndpoint.close();
 }
+
+// A session error reaches the QuicSession's onerror first, then the
+// Http3Session's, with the same error. A throw in one does not stop the
+// other, and surfaces as an uncaught exception like any onerror throw.
+{
+  const order = [];
+  const serverEndpoint = await listen(mustCall(async (quicSession) => {
+    quicSession.onerror = () => {};
+    await quicSession.closed.catch(() => {});
+  }), {
+    alpn: ['h3'],
+    sni: { '*': { keys: [key], certs: [cert] } },
+  });
+
+  const uncaught = Promise.withResolvers();
+  process.once('uncaughtException', (err) => uncaught.resolve(err));
+
+  const quicSession = await connect(serverEndpoint.address, {
+    alpn: 'h3',
+    autoWrap: false,
+    servername: 'localhost',
+    verifyPeer: 'manual',
+    onerror: mustCall(function(err) {
+      order.push(['transport', this, err]);
+      throw new Error('transport handler failed');
+    }),
+  });
+  const clientSession = Http3Session.from(quicSession, {});
+  clientSession.onerror = mustCall(function(err) {
+    order.push(['application', this, err]);
+  });
+  await clientSession.opened;
+
+  const boom = new Error('boom');
+  quicSession.destroy(boom);
+  assert.deepStrictEqual(order.map(([who]) => who),
+                         ['transport', 'application']);
+  assert.strictEqual(order[0][1], quicSession);
+  assert.strictEqual(order[1][1], clientSession);
+  assert.strictEqual(order[0][2], boom);
+  assert.strictEqual(order[1][2], boom);
+
+  const err = await uncaught.promise;
+  assert.strictEqual(err.error.message, 'transport handler failed');
+  assert.strictEqual(err.suppressed, boom);
+
+  await assert.rejects(clientSession.closed, boom);
+  await serverEndpoint.close();
+}
diff --git a/test/parallel/test-quic-h3-close-behavior.mjs b/test/parallel/test-quic-h3-close-behavior.mjs
index 20292ffb8ca1..293520bae4f9 100644
--- a/test/parallel/test-quic-h3-close-behavior.mjs
+++ b/test/parallel/test-quic-h3-close-behavior.mjs
@@ -12,7 +12,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -27,8 +27,7 @@ const decoder = new TextDecoder();
   let requestCount = 0;
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const ss = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall(async (ss) => {
     serverSession = ss;
     ss.onstream = mustCall(2);
   }), {
@@ -50,11 +49,11 @@ const decoder = new TextDecoder();
     }, 2),
   });
 
-  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  const clientSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  }));
+  });
   await clientSession.opened;
 
   const stream1 = await clientSession.createBidirectionalStream({
diff --git a/test/parallel/test-quic-h3-concurrent-requests.mjs b/test/parallel/test-quic-h3-concurrent-requests.mjs
index 5ec48540dfe6..d5a6c3154ffa 100644
--- a/test/parallel/test-quic-h3-concurrent-requests.mjs
+++ b/test/parallel/test-quic-h3-concurrent-requests.mjs
@@ -16,7 +16,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -29,8 +29,7 @@ const REQUEST_COUNT = 5;
 let serverStreamsCompleted = 0;
 const serverDone = Promise.withResolvers();
 
-const serverEndpoint = await listen(mustCall(async (quicSession) => {
-  const serverSession = new Http3Session(quicSession);
+const serverEndpoint = await listen(mustCall(async (serverSession) => {
   serverSession.onstream = mustCall((stream) => {
     stream.closed.then(mustCall(() => {
       if (++serverStreamsCompleted === REQUEST_COUNT) {
@@ -54,11 +53,11 @@ const serverEndpoint = await listen(mustCall(async (quicSession) => {
   }, REQUEST_COUNT),
 });
 
-const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+const clientSession = await connect(serverEndpoint.address, {
   alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-}));
+});
 await clientSession.opened;
 
 // Open all requests concurrently.
diff --git a/test/parallel/test-quic-h3-datagram.mjs b/test/parallel/test-quic-h3-datagram.mjs
index 55eb13e107b6..b30eb10e728f 100644
--- a/test/parallel/test-quic-h3-datagram.mjs
+++ b/test/parallel/test-quic-h3-datagram.mjs
@@ -32,7 +32,7 @@ const decoder = new TextDecoder();
   const serverDone = Promise.withResolvers();
 
   const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const ss = new Http3Session(quicSession, {
+    const ss = Http3Session.from(quicSession, {
       settings: { enableDatagrams: true },
     });
     ss.onstream = mustCall(async (stream) => {
@@ -44,6 +44,7 @@ const decoder = new TextDecoder();
     serverDone.resolve();
   }), {
     alpn: ['h3'],
+    autoWrap: false,
     sni: { '*': { keys: [key], certs: [cert] } },
     transportParams: { maxDatagramFrameSize: 100 },
     // Server echoes received datagram back to client.
@@ -66,6 +67,7 @@ const decoder = new TextDecoder();
 
   const quicSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
+    autoWrap: false,
     servername: 'localhost',
     verifyPeer: 'manual',
     transportParams: { maxDatagramFrameSize: 100 },
@@ -79,7 +81,7 @@ const decoder = new TextDecoder();
       clientGotDatagram.resolve();
     }),
   });
-  const clientSession = new Http3Session(quicSession, { settings: { enableDatagrams: true } });
+  const clientSession = Http3Session.from(quicSession, { settings: { enableDatagrams: true } });
   await clientSession.opened;
 
   // Datagrams work alongside H3 request/response.
@@ -120,7 +122,7 @@ const decoder = new TextDecoder();
 
   const serverEndpoint = await listen(mustCall(async (quicSession) => {
     // Server explicitly disables H3 datagrams.
-    const ss = new Http3Session(quicSession, {
+    const ss = Http3Session.from(quicSession, {
       settings: { enableDatagrams: false },
     });
     ss.onstream = mustCall(async (stream) => {
@@ -130,6 +132,7 @@ const decoder = new TextDecoder();
     });
   }), {
     alpn: ['h3'],
+    autoWrap: false,
     sni: { '*': { keys: [key], certs: [cert] } },
     // But transport-level datagrams ARE supported.
     transportParams: { maxDatagramFrameSize: 100 },
@@ -144,11 +147,12 @@ const decoder = new TextDecoder();
 
   const quicSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
+    autoWrap: false,
     servername: 'localhost',
     verifyPeer: 'manual',
     transportParams: { maxDatagramFrameSize: 100 },
   });
-  const clientSession = new Http3Session(quicSession, { settings: { enableDatagrams: true } });
+  const clientSession = Http3Session.from(quicSession, { settings: { enableDatagrams: true } });
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
diff --git a/test/parallel/test-quic-h3-error-codes.mjs b/test/parallel/test-quic-h3-error-codes.mjs
index 12d3a7043255..82d087555339 100644
--- a/test/parallel/test-quic-h3-error-codes.mjs
+++ b/test/parallel/test-quic-h3-error-codes.mjs
@@ -12,7 +12,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -25,8 +25,7 @@ const decoder = new TextDecoder();
 {
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const ss = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall(async (ss) => {
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       // Close with an explicit H3 application error code.
@@ -43,11 +42,11 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  const clientSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  }));
+  });
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
@@ -80,8 +79,7 @@ const decoder = new TextDecoder();
 {
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const ss = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall(async (ss) => {
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       ss.close();
@@ -97,11 +95,11 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  const clientSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  }));
+  });
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
diff --git a/test/parallel/test-quic-h3-flow-control-volume.mjs b/test/parallel/test-quic-h3-flow-control-volume.mjs
index ebe8cf58a8e0..5015d1b3b709 100644
--- a/test/parallel/test-quic-h3-flow-control-volume.mjs
+++ b/test/parallel/test-quic-h3-flow-control-volume.mjs
@@ -24,7 +24,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { makePayload, hashBytes } = await import('../common/quic.mjs');
 const { bytes } = await import('stream/iter');
@@ -48,8 +48,7 @@ assert.notStrictEqual(requestHash, responseHash);
 
 const serverDone = Promise.withResolvers();
 
-const serverEndpoint = await listen(mustCall(async (quicSession) => {
-  const serverSession = new Http3Session(quicSession);
+const serverEndpoint = await listen(mustCall(async (serverSession) => {
   serverSession.onstream = mustCall(async (stream) => {
     // Read the large request body. This is the path where DATA payload
     // credit is deferred until consumption.
@@ -80,7 +79,7 @@ const serverEndpoint = await listen(mustCall(async (quicSession) => {
   }),
 });
 
-const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+const clientSession = await connect(serverEndpoint.address, {
   alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
@@ -90,7 +89,7 @@ const clientSession = new Http3Session(await connect(serverEndpoint.address, {
   },
   maxStreamWindow: kStreamWindow,
   maxWindow: kConnWindow,
-}));
+});
 
 const info = await clientSession.opened;
 assert.strictEqual(info.protocol, 'h3');
diff --git a/test/parallel/test-quic-h3-goaway-non-h3.mjs b/test/parallel/test-quic-h3-goaway-non-h3.mjs
deleted file mode 100644
index f61df78da9e8..000000000000
--- a/test/parallel/test-quic-h3-goaway-non-h3.mjs
+++ /dev/null
@@ -1,63 +0,0 @@
-// Flags: --experimental-quic --experimental-stream-iter --no-warnings
-
-// Test: Non-H3 session close does not fire ongoaway.
-// GOAWAY is an HTTP/3 concept. When a non-H3 session closes, the
-// ongoaway callback must not fire.
-
-import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs';
-import assert from 'node:assert';
-import { setImmediate } from 'node:timers/promises';
-import * as fixtures from '../common/fixtures.mjs';
-
-if (!hasQuic) {
-  skip('QUIC is not enabled');
-}
-
-const { listen, connect } = await import('node:quic');
-const { createPrivateKey } = await import('node:crypto');
-const { bytes } = await import('stream/iter');
-
-const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
-const cert = fixtures.readKey('agent1-cert.pem');
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
-
-const serverDone = Promise.withResolvers();
-
-const serverEndpoint = await listen(mustCall(async (ss) => {
-  ss.onstream = mustCall(async (stream) => {
-    // Read client data, send response, close stream.
-    const data = await bytes(stream);
-    assert.strictEqual(decoder.decode(data), 'ping');
-    stream.writer.writeSync('pong');
-    stream.writer.endSync();
-    await stream.closed;
-    ss.close();
-    serverDone.resolve();
-  });
-}), {
-  sni: { '*': { keys: [key], certs: [cert] } },
-  alpn: 'quic-test',
-});
-
-const clientSession = await connect(serverEndpoint.address, {
-  servername: 'localhost',
-  verifyPeer: 'manual',
-  alpn: 'quic-test',
-  // Ongoaway must NOT fire for non-H3 sessions.
-  ongoaway: mustNotCall(),
-});
-await clientSession.opened;
-
-const stream = await clientSession.createBidirectionalStream({
-  body: encoder.encode('ping'),
-});
-
-const response = await bytes(stream);
-assert.strictEqual(decoder.decode(response), 'pong');
-await Promise.all([stream.closed, serverDone.promise]);
-
-// Wait a tick for any deferred callbacks to fire.
-await setImmediate();
-await clientSession.close();
-await serverEndpoint.close();
diff --git a/test/parallel/test-quic-h3-goaway.mjs b/test/parallel/test-quic-h3-goaway.mjs
index cc1a625c882d..41a1976ddaa8 100644
--- a/test/parallel/test-quic-h3-goaway.mjs
+++ b/test/parallel/test-quic-h3-goaway.mjs
@@ -42,8 +42,7 @@ dc.subscribe('quic.session.goaway', mustCall((msg) => {
   const bothHeadersReceived = Promise.withResolvers();
   let clientHeaderCount = 0;
 
-  const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const ss = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall(async (ss) => {
     serverSession = ss;
     ss.onstream = mustCall(2);
   }), {
@@ -70,15 +69,17 @@ dc.subscribe('quic.session.goaway', mustCall((msg) => {
 
   const quicSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
+    autoWrap: false,
     servername: 'localhost',
     verifyPeer: 'manual',
+  });
+  const clientSession = Http3Session.from(quicSession, {
     // Ongoaway fires when the peer sends GOAWAY.
     ongoaway: mustCall(function(lastStreamId) {
       assert.strictEqual(lastStreamId, -1n);
       goawayReceived.resolve();
     }),
   });
-  const clientSession = new Http3Session(quicSession);
   await clientSession.opened;
 
   const onClientHeaders = mustCall(function(headers) {
diff --git a/test/parallel/test-quic-h3-handshake-failure.mjs b/test/parallel/test-quic-h3-handshake-failure.mjs
index 351e738f32b9..05fd7b344be1 100644
--- a/test/parallel/test-quic-h3-handshake-failure.mjs
+++ b/test/parallel/test-quic-h3-handshake-failure.mjs
@@ -20,14 +20,13 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 
 const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
 const cert = fixtures.readKey('agent1-cert.pem');
 
-const serverEndpoint = await listen(async (quicSession) => {
-  const serverSession = new Http3Session(quicSession);
+const serverEndpoint = await listen(async (serverSession) => {
   await serverSession.closed;
 }, {
   alpn: ['h3'],
@@ -38,13 +37,13 @@ const serverEndpoint = await listen(async (quicSession) => {
 // Connect then immediately close the session before the handshake completes.
 // This exercises the H3 shutdown path on the server while the H3 application
 // exists but hasn't started (control streams not yet bound).
-const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+const clientSession = await connect(serverEndpoint.address, {
   alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
   // h3 ALPN — must match the server so the H3 application is selected
   // on the server side before we tear it down.
-}));
+});
 
 // Close immediately — don't wait for handshake.
 await clientSession.close();
diff --git a/test/parallel/test-quic-h3-header-interest.mjs b/test/parallel/test-quic-h3-header-interest.mjs
index 7aa5162bd4c9..e221c2ed2853 100644
--- a/test/parallel/test-quic-h3-header-interest.mjs
+++ b/test/parallel/test-quic-h3-header-interest.mjs
@@ -12,7 +12,7 @@ if (!hasQuic) {
 }
 
 const { createPrivateKey } = await import('node:crypto');
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { bytes } = await import('stream/iter');
 
 const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
@@ -21,8 +21,7 @@ const encoder = new TextEncoder();
 const decoder = new TextDecoder();
 const serverDone = Promise.withResolvers();
 
-const serverEndpoint = await listen(mustCall(async (quicSession) => {
-  const serverSession = new Http3Session(quicSession);
+const serverEndpoint = await listen(mustCall(async (serverSession) => {
   serverSession.onstream = mustCall(async (stream) => {
     await stream.closed;
     serverSession.close();
@@ -44,12 +43,11 @@ const serverEndpoint = await listen(mustCall(async (quicSession) => {
   }),
 });
 
-const quicSession = await connect(serverEndpoint.address, {
+const clientSession = await connect(serverEndpoint.address, {
   alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
 });
-const clientSession = new Http3Session(quicSession);
 await clientSession.opened;
 
 const infoReceived = Promise.withResolvers();
diff --git a/test/parallel/test-quic-h3-header-validation.mjs b/test/parallel/test-quic-h3-header-validation.mjs
index 3ea5965a942c..a8ca20adbebf 100644
--- a/test/parallel/test-quic-h3-header-validation.mjs
+++ b/test/parallel/test-quic-h3-header-validation.mjs
@@ -21,7 +21,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -35,8 +35,7 @@ const decoder = new TextDecoder();
 {
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const ss = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall(async (ss) => {
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       ss.close();
@@ -74,11 +73,11 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  const clientSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  }));
+  });
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
@@ -117,8 +116,7 @@ const decoder = new TextDecoder();
 {
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const ss = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall(async (ss) => {
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       ss.close();
@@ -139,11 +137,11 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  const clientSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  }));
+  });
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
diff --git a/test/parallel/test-quic-h3-informational-headers.mjs b/test/parallel/test-quic-h3-informational-headers.mjs
index a5b1c9ad3330..ac052834755e 100644
--- a/test/parallel/test-quic-h3-informational-headers.mjs
+++ b/test/parallel/test-quic-h3-informational-headers.mjs
@@ -19,7 +19,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -45,8 +45,7 @@ dc.subscribe('quic.stream.headers', mustCall((msg) => {
 
 const serverDone = Promise.withResolvers();
 
-const serverEndpoint = await listen(mustCall(async (quicSession) => {
-  const serverSession = new Http3Session(quicSession);
+const serverEndpoint = await listen(mustCall(async (serverSession) => {
   serverSession.onstream = mustCall(async (stream) => {
     await stream.closed;
     serverSession.close();
@@ -74,11 +73,11 @@ const serverEndpoint = await listen(mustCall(async (quicSession) => {
   }),
 });
 
-const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+const clientSession = await connect(serverEndpoint.address, {
   alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-}));
+});
 await clientSession.opened;
 
 const clientInfoReceived = Promise.withResolvers();
diff --git a/test/parallel/test-quic-h3-maxstreamdata-external-buffer-failure.mjs b/test/parallel/test-quic-h3-maxstreamdata-external-buffer-failure.mjs
index 4a7b8a125fe6..65f135dafffd 100644
--- a/test/parallel/test-quic-h3-maxstreamdata-external-buffer-failure.mjs
+++ b/test/parallel/test-quic-h3-maxstreamdata-external-buffer-failure.mjs
@@ -11,7 +11,7 @@ import { setTimeout as sleep } from 'node:timers/promises';
 if (!hasQuic) {
   skip('QUIC is not enabled');
 }
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { drainableProtocol } = await import('stream/iter');
 
@@ -30,8 +30,7 @@ const BODY = WINDOW - 11;
 let letServerRead;
 const serverMayRead = new Promise((resolve) => { letServerRead = resolve; });
 
-const endpoint = await listen((quicSession) => {
-  const session = new Http3Session(quicSession);
+const endpoint = await listen((session) => {
   session.onstream = async (stream) => {
     await serverMayRead;
     // eslint-disable-next-line no-unused-vars
@@ -47,11 +46,11 @@ const endpoint = await listen((quicSession) => {
   onheaders() { this.sendHeaders({ ':status': '200' }); },
 });
 
-const session = new Http3Session(await connect(endpoint.address, {
+const session = await connect(endpoint.address, {
   alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-}));
+});
 await session.opened;
 
 // Budget well above the window, so the window is what stops the writer.
diff --git a/test/parallel/test-quic-h3-origin.mjs b/test/parallel/test-quic-h3-origin.mjs
index 970072378806..fe5ceed5da22 100644
--- a/test/parallel/test-quic-h3-origin.mjs
+++ b/test/parallel/test-quic-h3-origin.mjs
@@ -29,8 +29,7 @@ const decoder = new TextDecoder();
   const originReceived = Promise.withResolvers();
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const ss = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall(async (ss) => {
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       ss.close();
@@ -54,8 +53,11 @@ const decoder = new TextDecoder();
 
   const quicSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
+    autoWrap: false,
     servername: 'example.com',
     verifyPeer: 'manual',
+  });
+  const clientSession = Http3Session.from(quicSession, {
     // Client receives ORIGIN frame via onorigin callback.
     onorigin: mustCall(function(origins) {
       assert.ok(Array.isArray(origins));
@@ -70,7 +72,6 @@ const decoder = new TextDecoder();
       originReceived.resolve();
     }),
   });
-  const clientSession = new Http3Session(quicSession);
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
@@ -101,8 +102,7 @@ const decoder = new TextDecoder();
   const originReceived = Promise.withResolvers();
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const ss = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall(async (ss) => {
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       ss.close();
@@ -136,8 +136,11 @@ const decoder = new TextDecoder();
 
   const quicSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
+    autoWrap: false,
     servername: 'custom-port.example.com',
     verifyPeer: 'manual',
+  });
+  const clientSession = Http3Session.from(quicSession, {
     onorigin: mustCall(function(origins) {
       assert.ok(Array.isArray(origins));
 
@@ -170,7 +173,6 @@ const decoder = new TextDecoder();
       originReceived.resolve();
     }),
   });
-  const clientSession = new Http3Session(quicSession);
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
diff --git a/test/parallel/test-quic-h3-pending-stream.mjs b/test/parallel/test-quic-h3-pending-stream.mjs
index 5bec314b9a55..4dea83f980bd 100644
--- a/test/parallel/test-quic-h3-pending-stream.mjs
+++ b/test/parallel/test-quic-h3-pending-stream.mjs
@@ -12,7 +12,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -26,8 +26,7 @@ const decoder = new TextDecoder();
 {
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const ss = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall(async (ss) => {
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       ss.close();
@@ -48,11 +47,11 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  const clientSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  }));
+  });
 
   // Create the stream BEFORE awaiting opened. The stream is pending
   // until the handshake completes and the QUIC stream can be opened.
diff --git a/test/parallel/test-quic-h3-post-filehandle.mjs b/test/parallel/test-quic-h3-post-filehandle.mjs
index 91809031bbf5..20306a6ddc01 100644
--- a/test/parallel/test-quic-h3-post-filehandle.mjs
+++ b/test/parallel/test-quic-h3-post-filehandle.mjs
@@ -17,7 +17,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -35,8 +35,7 @@ writeFileSync(testFile, testContent);
 {
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const serverSession = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall(async (serverSession) => {
     serverSession.onstream = mustCall(async (stream) => {
       const body = await bytes(stream);
       assert.strictEqual(decoder.decode(body), testContent);
@@ -58,11 +57,11 @@ writeFileSync(testFile, testContent);
     }),
   });
 
-  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  const clientSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  }));
+  });
 
   const info = await clientSession.opened;
   assert.strictEqual(info.protocol, 'h3');
diff --git a/test/parallel/test-quic-h3-post-request.mjs b/test/parallel/test-quic-h3-post-request.mjs
index 527200904be8..a1c69e09bda4 100644
--- a/test/parallel/test-quic-h3-post-request.mjs
+++ b/test/parallel/test-quic-h3-post-request.mjs
@@ -17,7 +17,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -30,8 +30,7 @@ const requestBody = 'Hello from the client';
 
 const serverDone = Promise.withResolvers();
 
-const serverEndpoint = await listen(mustCall(async (quicSession) => {
-  const serverSession = new Http3Session(quicSession);
+const serverEndpoint = await listen(mustCall(async (serverSession) => {
   serverSession.onstream = mustCall(async (stream) => {
     // Read the full request body from the client.
     const body = await bytes(stream);
@@ -65,11 +64,11 @@ const serverEndpoint = await listen(mustCall(async (quicSession) => {
   }),
 });
 
-const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+const clientSession = await connect(serverEndpoint.address, {
   alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-}));
+});
 
 const info = await clientSession.opened;
 assert.strictEqual(info.protocol, 'h3');
diff --git a/test/parallel/test-quic-h3-priority.mjs b/test/parallel/test-quic-h3-priority.mjs
index 007a1d475c95..598a18a53739 100644
--- a/test/parallel/test-quic-h3-priority.mjs
+++ b/test/parallel/test-quic-h3-priority.mjs
@@ -17,7 +17,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -30,8 +30,7 @@ const decoder = new TextDecoder();
   let requestCount = 0;
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const ss = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall(async (ss) => {
     ss.onstream = mustCall((stream) => {
       // Server sees priority on the stream.
       const pri = stream.priority;
@@ -52,11 +51,11 @@ const decoder = new TextDecoder();
     }, 4),
   });
 
-  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  const clientSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  }));
+  });
   await clientSession.opened;
 
   // Priority set at creation time via options.
@@ -165,8 +164,7 @@ const decoder = new TextDecoder();
   const serverSawHighPriority = Promise.withResolvers();
   const serverDone = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const ss = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall(async (ss) => {
     ss.onstream = mustCall(async (stream) => {
       // Read the request body — this acts as a signal that the
       // client's PRIORITY_UPDATE has been sent. The control stream
@@ -195,11 +193,11 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  const clientSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  }));
+  });
   await clientSession.opened;
 
   // Create stream with default priority and a body. The body serves
diff --git a/test/parallel/test-quic-h3-qpack-settings.mjs b/test/parallel/test-quic-h3-qpack-settings.mjs
index e965cfac9618..91f27d6b545a 100644
--- a/test/parallel/test-quic-h3-qpack-settings.mjs
+++ b/test/parallel/test-quic-h3-qpack-settings.mjs
@@ -52,12 +52,13 @@ async function makeRequest(clientSession, path) {
 
   const serverEndpoint = await listen(mustCall(async (quicSession) => {
     // Server disables QPACK dynamic table.
-    const ss = new Http3Session(quicSession, {
+    const ss = Http3Session.from(quicSession, {
       settings: { qpackMaxDTableCapacity: 0, qpackBlockedStreams: 0 },
     });
     ss.onstream = mustCall(2);
   }), {
     alpn: ['h3'],
+    autoWrap: false,
     sni: { '*': { keys: [key], certs: [cert] } },
     onheaders: mustCall(function(headers) {
       this.sendHeaders({ ':status': '200' });
@@ -72,10 +73,11 @@ async function makeRequest(clientSession, path) {
   // Client also disables QPACK dynamic table.
   const quicSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
+    autoWrap: false,
     servername: 'localhost',
     verifyPeer: 'manual',
   });
-  const clientSession = new Http3Session(quicSession, {
+  const clientSession = Http3Session.from(quicSession, {
     settings: { qpackMaxDTableCapacity: 0, qpackBlockedStreams: 0 },
   });
   await clientSession.opened;
@@ -96,12 +98,13 @@ async function makeRequest(clientSession, path) {
   let requestCount = 0;
 
   const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const ss = new Http3Session(quicSession, {
+    const ss = Http3Session.from(quicSession, {
       settings: { qpackMaxDTableCapacity: 8192, qpackBlockedStreams: 200 },
     });
     ss.onstream = mustCall(2);
   }), {
     alpn: ['h3'],
+    autoWrap: false,
     sni: { '*': { keys: [key], certs: [cert] } },
     onheaders: mustCall(function(headers) {
       this.sendHeaders({ ':status': '200' });
@@ -115,10 +118,11 @@ async function makeRequest(clientSession, path) {
 
   const quicSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
+    autoWrap: false,
     servername: 'localhost',
     verifyPeer: 'manual',
   });
-  const clientSession = new Http3Session(quicSession, {
+  const clientSession = Http3Session.from(quicSession, {
     settings: { qpackMaxDTableCapacity: 8192, qpackBlockedStreams: 200 },
   });
   await clientSession.opened;
diff --git a/test/parallel/test-quic-h3-request-rejected.mjs b/test/parallel/test-quic-h3-request-rejected.mjs
index 82d6c22945c4..8fe0acceda12 100644
--- a/test/parallel/test-quic-h3-request-rejected.mjs
+++ b/test/parallel/test-quic-h3-request-rejected.mjs
@@ -14,7 +14,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 
 const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
@@ -25,19 +25,18 @@ const H3_REQUEST_REJECTED = 0x10bn;
 
 // The server registers no stream consumer, so an incoming request stream
 // is rejected on arrival.
-const serverEndpoint = await listen(mustCall((quicSession) => {
-  const serverSession = new Http3Session(quicSession);
+const serverEndpoint = await listen(mustCall((serverSession) => {
   serverSession.onerror = () => {};
 }), {
   alpn: ['h3'],
   sni: { '*': { keys: [key], certs: [cert] } },
 });
 
-const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+const clientSession = await connect(serverEndpoint.address, {
   alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-}));
+});
 await clientSession.opened;
 
 const reset = Promise.withResolvers();
diff --git a/test/parallel/test-quic-h3-request-response.mjs b/test/parallel/test-quic-h3-request-response.mjs
index f868629d1456..91404e026df8 100644
--- a/test/parallel/test-quic-h3-request-response.mjs
+++ b/test/parallel/test-quic-h3-request-response.mjs
@@ -17,7 +17,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -34,8 +34,7 @@ const serverDone = Promise.withResolvers();
 // to the stream. A regular function is used so `this` is accessible.
 // safeCallbackInvoke(fn, owner, ...args) consumes the owner for error
 // handling and forwards only ...args to fn.
-const serverEndpoint = await listen(mustCall(async (quicSession) => {
-  const serverSession = new Http3Session(quicSession);
+const serverEndpoint = await listen(mustCall(async (serverSession) => {
   serverSession.onstream = mustCall(async (stream) => {
     await stream.closed;
     serverSession.close();
@@ -72,11 +71,11 @@ const serverEndpoint = await listen(mustCall(async (quicSession) => {
   }),
 });
 
-const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+const clientSession = await connect(serverEndpoint.address, {
   alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-}));
+});
 
 const info = await clientSession.opened;
 assert.strictEqual(info.protocol, 'h3');
diff --git a/test/parallel/test-quic-h3-settings.mjs b/test/parallel/test-quic-h3-settings.mjs
index f74856cfa83c..e17d9baeb260 100644
--- a/test/parallel/test-quic-h3-settings.mjs
+++ b/test/parallel/test-quic-h3-settings.mjs
@@ -31,7 +31,7 @@ const decoder = new TextDecoder();
 
   const serverEndpoint = await listen(mustCall(async (quicSession) => {
     // Allow 5 header pairs: 4 pseudo-headers + 1 custom.
-    const ss = new Http3Session(quicSession, {
+    const ss = Http3Session.from(quicSession, {
       settings: { maxHeaderPairs: 5 },
     });
     ss.onstream = mustCall(async (stream) => {
@@ -41,6 +41,7 @@ const decoder = new TextDecoder();
     });
   }), {
     alpn: ['h3'],
+    autoWrap: false,
     sni: { '*': { keys: [key], certs: [cert] } },
     onheaders: mustCall(function(headers) {
       assert.strictEqual(headers[':method'], 'GET');
@@ -58,11 +59,11 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  const clientSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  }));
+  });
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
@@ -98,7 +99,7 @@ const decoder = new TextDecoder();
   const serverEndpoint = await listen(mustCall(async (quicSession) => {
     // Limit total header bytes. The 4 pseudo-headers fit within 100
     // bytes, but adding x-long (6 + 200 = 206 bytes) exceeds it.
-    const ss = new Http3Session(quicSession, {
+    const ss = Http3Session.from(quicSession, {
       settings: { maxHeaderLength: 100 },
     });
     ss.onstream = mustCall(async (stream) => {
@@ -108,6 +109,7 @@ const decoder = new TextDecoder();
     });
   }), {
     alpn: ['h3'],
+    autoWrap: false,
     sni: { '*': { keys: [key], certs: [cert] } },
     onheaders: mustCall(function(headers) {
       assert.strictEqual(headers[':method'], 'GET');
@@ -121,11 +123,11 @@ const decoder = new TextDecoder();
     }),
   });
 
-  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  const clientSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  }));
+  });
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
@@ -154,7 +156,7 @@ const decoder = new TextDecoder();
   const serverDone = Promise.withResolvers();
 
   const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const ss = new Http3Session(quicSession, {
+    const ss = Http3Session.from(quicSession, {
       settings: { enableConnectProtocol: true, enableDatagrams: true },
       onsettings: mustCall((appopt) => {
         assert.strictEqual(appopt.enableDatagrams, true);
@@ -169,6 +171,7 @@ const decoder = new TextDecoder();
     });
   }), {
     alpn: ['h3'],
+    autoWrap: false,
     sni: { '*': { keys: [key], certs: [cert] } },
     onheaders: mustCall(function(headers) {
       this.sendHeaders({ ':status': '200' });
@@ -179,10 +182,11 @@ const decoder = new TextDecoder();
 
   const quicSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
+    autoWrap: false,
     servername: 'localhost',
     verifyPeer: 'manual',
   });
-  const clientSession = new Http3Session(quicSession, {
+  const clientSession = Http3Session.from(quicSession, {
     settings: { enableConnectProtocol: true, enableDatagrams: true },
   });
   clientSession.onsettings = mustCall((appopt) => {
diff --git a/test/parallel/test-quic-h3-status-code-type.mjs b/test/parallel/test-quic-h3-status-code-type.mjs
index 485f6e7e4b83..886f321e03e3 100644
--- a/test/parallel/test-quic-h3-status-code-type.mjs
+++ b/test/parallel/test-quic-h3-status-code-type.mjs
@@ -11,7 +11,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 
 const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
@@ -21,8 +21,7 @@ const codes = [200, 204, 404];
 let serverResponses = 0;
 const serverDone = Promise.withResolvers();
 
-const serverEndpoint = await listen(mustCall(async (quicSession) => {
-  const ss = new Http3Session(quicSession);
+const serverEndpoint = await listen(mustCall(async (ss) => {
   ss.onstream = mustCall(() => {
     if (++serverResponses === codes.length) {
       ss.close();
@@ -39,11 +38,11 @@ const serverEndpoint = await listen(mustCall(async (quicSession) => {
   }, codes.length),
 });
 
-const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+const clientSession = await connect(serverEndpoint.address, {
   alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-}));
+});
 await clientSession.opened;
 
 for (const expected of codes) {
diff --git a/test/parallel/test-quic-h3-stream-credit.mjs b/test/parallel/test-quic-h3-stream-credit.mjs
index acf24fbd8bd6..16f77e9876ee 100644
--- a/test/parallel/test-quic-h3-stream-credit.mjs
+++ b/test/parallel/test-quic-h3-stream-credit.mjs
@@ -17,7 +17,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -29,8 +29,7 @@ const kRequests = 6;
 let liveServerStreams = 0;
 let peakLiveServerStreams = 0;
 
-const serverEndpoint = await listen(mustCall((quicSession) => {
-  const serverSession = new Http3Session(quicSession);
+const serverEndpoint = await listen(mustCall((serverSession) => {
   serverSession.onstream = mustCall((stream) => {
     liveServerStreams++;
     peakLiveServerStreams = Math.max(peakLiveServerStreams, liveServerStreams);
@@ -49,11 +48,11 @@ const serverEndpoint = await listen(mustCall((quicSession) => {
   }, kRequests),
 });
 
-const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+const clientSession = await connect(serverEndpoint.address, {
   alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-}));
+});
 
 const info = await clientSession.opened;
 assert.strictEqual(info.protocol, 'h3');
diff --git a/test/parallel/test-quic-h3-stream-destroy-no-resurrect.mjs b/test/parallel/test-quic-h3-stream-destroy-no-resurrect.mjs
index 1e08a318cd14..4311aafddd5c 100644
--- a/test/parallel/test-quic-h3-stream-destroy-no-resurrect.mjs
+++ b/test/parallel/test-quic-h3-stream-destroy-no-resurrect.mjs
@@ -23,7 +23,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { makePayload } = await import('../common/quic.mjs');
 
@@ -41,8 +41,7 @@ const responseBody = makePayload(kResponseSize, 17);
 assert.ok(kResponseSize * kRequests > kConnWindow * 4,
           'aggregate response data must far exceed the connection window');
 
-const serverEndpoint = await listen(mustCall((quicSession) => {
-  const serverSession = new Http3Session(quicSession);
+const serverEndpoint = await listen(mustCall((serverSession) => {
   serverSession.onstream = mustCall((stream) => {
     // The client destroys these early; the truncated write is expected.
     stream.onerror = () => {};
@@ -56,7 +55,7 @@ const serverEndpoint = await listen(mustCall((quicSession) => {
   }, kRequests),
 });
 
-const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+const clientSession = await connect(serverEndpoint.address, {
   alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
@@ -64,7 +63,7 @@ const clientSession = new Http3Session(await connect(serverEndpoint.address, {
     initialMaxData: kConnWindow,
     initialMaxStreamDataBidiLocal: kResponseSize * 2,
   },
-}));
+});
 
 // The client opens every stream itself; the server opens none. Any onstream
 // here is a destroyed request stream being resurrected and misreported as
diff --git a/test/parallel/test-quic-h3-stream-destroy-with-headers.mjs b/test/parallel/test-quic-h3-stream-destroy-with-headers.mjs
index d0ac441891e3..402bbe3d06ff 100644
--- a/test/parallel/test-quic-h3-stream-destroy-with-headers.mjs
+++ b/test/parallel/test-quic-h3-stream-destroy-with-headers.mjs
@@ -12,7 +12,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 
 const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
@@ -20,8 +20,7 @@ const cert = fixtures.readKey('agent1-cert.pem');
 
 const serverDone = Promise.withResolvers();
 
-const serverEndpoint = await listen(mustCall(async (quicSession) => {
-  const ss = new Http3Session(quicSession);
+const serverEndpoint = await listen(mustCall(async (ss) => {
   // The server may or may not see the stream depending on timing.
   // Either way, it should not crash.
   await ss.closed;
@@ -31,11 +30,11 @@ const serverEndpoint = await listen(mustCall(async (quicSession) => {
   sni: { '*': { keys: [key], certs: [cert] } },
 });
 
-const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+const clientSession = await connect(serverEndpoint.address, {
   alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-}));
+});
 await clientSession.opened;
 
 // Create a stream with headers, then immediately destroy it.
diff --git a/test/parallel/test-quic-h3-stream-idle-timeout.mjs b/test/parallel/test-quic-h3-stream-idle-timeout.mjs
index 553f95485aaf..59ef9d6a01be 100644
--- a/test/parallel/test-quic-h3-stream-idle-timeout.mjs
+++ b/test/parallel/test-quic-h3-stream-idle-timeout.mjs
@@ -17,7 +17,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 
 const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
@@ -29,8 +29,7 @@ const encoder = new TextEncoder();
 {
   const streamDestroyed = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const serverSession = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall(async (serverSession) => {
     serverSession.onstream = mustCall(async (stream) => {
       // Don't read — let the stream sit idle after the initial headers.
       // The stream idle timeout should destroy it, rejecting stream.closed.
@@ -48,12 +47,12 @@ const encoder = new TextEncoder();
     },
   });
 
-  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  const clientSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
     transportParams: { maxIdleTimeout: 1 },
-  }));
+  });
 
   await clientSession.opened;
 
@@ -89,8 +88,7 @@ const encoder = new TextEncoder();
 {
   const serverGotData = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const serverSession = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall(async (serverSession) => {
     serverSession.onstream = mustCall(async (stream) => {
       const data = await text(stream);
       assert.strictEqual(data, 'xy');
@@ -108,11 +106,11 @@ const encoder = new TextEncoder();
     }),
   });
 
-  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  const clientSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  }));
+  });
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
@@ -142,8 +140,7 @@ const encoder = new TextEncoder();
 {
   const streamSurvived = Promise.withResolvers();
 
-  const serverEndpoint = await listen(mustCall(async (quicSession) => {
-    const serverSession = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall(async (serverSession) => {
     serverSession.onstream = mustCall(async (stream) => {
       const data = await text(stream);
       assert.strictEqual(data, 'xy');
@@ -161,11 +158,11 @@ const encoder = new TextEncoder();
     }),
   });
 
-  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  const clientSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  }));
+  });
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
diff --git a/test/parallel/test-quic-h3-stream-without-onstream.mjs b/test/parallel/test-quic-h3-stream-without-onstream.mjs
index 20ec0350e6d1..8e96a4d4ba06 100644
--- a/test/parallel/test-quic-h3-stream-without-onstream.mjs
+++ b/test/parallel/test-quic-h3-stream-without-onstream.mjs
@@ -19,7 +19,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { text } = await import('stream/iter');
 
@@ -42,8 +42,7 @@ function failOnConsumerWarning(warning) {
   const serverDone = Promise.withResolvers();
 
   // Note: no `onstream` callback anywhere on this session.
-  const serverEndpoint = await listen(mustCall((quicSession) => {
-    const serverSession = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall((serverSession) => {
     serverSession.onerror = () => {};
   }), {
     alpn: ['h3'],
@@ -61,11 +60,11 @@ function failOnConsumerWarning(warning) {
     }),
   });
 
-  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  const clientSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  }));
+  });
   await clientSession.opened;
 
   const headersReceived = Promise.withResolvers();
@@ -150,19 +149,18 @@ const kNonConsumerCallbacks = ['oninfo', 'ontrailers', 'onwanttrailers'];
   // QuicStream is not exported; obtain its prototype from a stream instance,
   // then offer every `on*` accessor to listen() and see which ones the
   // session actually attaches to a received stream.
-  const bootstrap = await listen(mustCall((quicSession) => {
-    const session = new Http3Session(quicSession);
+  const bootstrap = await listen(mustCall((session) => {
     session.onerror = () => {};
+    session.onstream = () => {};
   }), {
     alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
-    onstream: () => {},
   });
-  const bootSession = new Http3Session(await connect(bootstrap.address, {
+  const bootSession = await connect(bootstrap.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  }));
+  });
   await bootSession.opened;
   const probeStream = await bootSession.createBidirectionalStream();
   probeStream.onerror = () => {};
@@ -175,24 +173,23 @@ const kNonConsumerCallbacks = ['oninfo', 'ontrailers', 'onwanttrailers'];
   for (const name of candidates) probes[name] = () => {};
 
   const applied = Promise.withResolvers();
-  const serverEndpoint = await listen(mustCall((quicSession) => {
-    const session = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall((session) => {
     session.onerror = () => {};
+    session.onstream = mustCall((stream) => {
+      applied.resolve(candidates.filter((n) => typeof stream[n] === 'function'));
+    });
   }), {
     __proto__: null,
     ...probes,
     alpn: ['h3'],
     sni: { '*': { keys: [key], certs: [cert] } },
-    onstream: mustCall((stream) => {
-      applied.resolve(candidates.filter((n) => typeof stream[n] === 'function'));
-    }),
   });
 
-  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  const clientSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  }));
+  });
   await clientSession.opened;
   const stream = await clientSession.createBidirectionalStream({
     headers: {
@@ -227,8 +224,7 @@ for (const callbackName of kNonConsumerCallbacks) {
     }
   });
 
-  const serverEndpoint = await listen(mustCall((quicSession) => {
-    const serverSession = new Http3Session(quicSession);
+  const serverEndpoint = await listen(mustCall((serverSession) => {
     serverSession.onerror = () => {};
   }), {
     alpn: ['h3'],
@@ -236,11 +232,11 @@ for (const callbackName of kNonConsumerCallbacks) {
     [callbackName]: mustNotCall(),
   });
 
-  const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+  const clientSession = await connect(serverEndpoint.address, {
     alpn: 'h3',
     servername: 'localhost',
     verifyPeer: 'manual',
-  }));
+  });
   await clientSession.opened;
 
   const stream = await clientSession.createBidirectionalStream({
diff --git a/test/parallel/test-quic-h3-trailing-headers.mjs b/test/parallel/test-quic-h3-trailing-headers.mjs
index c6e08b5748d9..3224d581277d 100644
--- a/test/parallel/test-quic-h3-trailing-headers.mjs
+++ b/test/parallel/test-quic-h3-trailing-headers.mjs
@@ -18,7 +18,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -47,8 +47,7 @@ dc.subscribe('quic.stream.trailers', mustCall((msg) => {
 
 const serverDone = Promise.withResolvers();
 
-const serverEndpoint = await listen(mustCall(async (quicSession) => {
-  const serverSession = new Http3Session(quicSession);
+const serverEndpoint = await listen(mustCall(async (serverSession) => {
   serverSession.onstream = mustCall(async (stream) => {
     await stream.closed;
     serverSession.close();
@@ -79,11 +78,11 @@ const serverEndpoint = await listen(mustCall(async (quicSession) => {
   }),
 });
 
-const clientSession = new Http3Session(await connect(serverEndpoint.address, {
+const clientSession = await connect(serverEndpoint.address, {
   alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-}));
+});
 await clientSession.opened;
 
 const clientHeadersReceived = Promise.withResolvers();
diff --git a/test/parallel/test-quic-h3-uni-stream-limit-start-failure.mjs b/test/parallel/test-quic-h3-uni-stream-limit-start-failure.mjs
deleted file mode 100644
index bc784d4aa0c9..000000000000
--- a/test/parallel/test-quic-h3-uni-stream-limit-start-failure.mjs
+++ /dev/null
@@ -1,40 +0,0 @@
-// Flags: --experimental-quic --no-warnings
-
-// An HTTP/3 session must cleanly fail if the peer advertises fewer than
-// the 3 unidirectional streams that HTTP/3 needs for control and QPACK.
-
-import { hasQuic, skip, mustNotCall } from '../common/index.mjs';
-import assert from 'node:assert';
-import * as fixtures from '../common/fixtures.mjs';
-
-if (!hasQuic) {
-  skip('QUIC is not enabled');
-}
-
-const { listen, connect, Http3Session } = await import('node:quic');
-const { createPrivateKey } = await import('node:crypto');
-
-const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
-const cert = fixtures.readKey('agent1-cert.pem');
-
-const serverEndpoint = await listen(async (serverSession) => {
-  await serverSession.closed;
-}, {
-  alpn: ['h3'],
-  sni: { '*': { keys: [key], certs: [cert] } },
-  // No uni streams allowed:
-  transportParams: { initialMaxStreamsUni: 0 },
-  onheaders: mustNotCall(),
-});
-
-const clientSession = new Http3Session(await connect(serverEndpoint.address, {
-  alpn: 'h3',
-  servername: 'localhost',
-  verifyPeer: 'manual',
-}));
-
-// Expect the client to cleanly fail & close - not crash the process.
-await assert.rejects(clientSession.closed,
-                     { code: 'ERR_QUIC_TRANSPORT_ERROR' });
-
-await serverEndpoint.close();
diff --git a/test/parallel/test-quic-h3-zero-rtt-rejected-settings.mjs b/test/parallel/test-quic-h3-zero-rtt-rejected-settings.mjs
index e472844656fe..f2c519750b4f 100644
--- a/test/parallel/test-quic-h3-zero-rtt-rejected-settings.mjs
+++ b/test/parallel/test-quic-h3-zero-rtt-rejected-settings.mjs
@@ -34,13 +34,14 @@ async function getTicket({ settings, ...endpointOptions }) {
   const gotToken = Promise.withResolvers();
 
   const ep = await listen(mustCall(async (quicSession) => {
-    const ss = new Http3Session(quicSession, { settings });
+    const ss = Http3Session.from(quicSession, { settings });
     ss.onstream = mustCall(async (stream) => {
       await stream.closed;
       ss.close();
     });
   }), {
     alpn: ['h3'],
+    autoWrap: false,
     sni,
     ...endpointOptions,
     onheaders: mustCall(function(headers) {
@@ -50,8 +51,9 @@ async function getTicket({ settings, ...endpointOptions }) {
     }),
   });
 
-  const cs = new Http3Session(await connect(ep.address, {
+  const cs = Http3Session.from(await connect(ep.address, {
     alpn: 'h3',
+    autoWrap: false,
     servername: 'localhost',
     verifyPeer: 'manual',
     ...endpointOptions,
@@ -96,23 +98,25 @@ async function getTicket({ settings, ...endpointOptions }) {
 async function attemptRejected0RTT({ settings, ...endpointOptions },
                                    ticket, token) {
   const ep = await listen(mustCall(async (quicSession) => {
-    const ss = new Http3Session(quicSession, { settings });
+    const ss = Http3Session.from(quicSession, { settings });
     await ss.closed;
   }), {
     alpn: ['h3'],
+    autoWrap: false,
     sni,
     ...endpointOptions,
   });
 
   const quicSession = await connect(ep.address, {
     alpn: 'h3',
+    autoWrap: false,
     servername: 'localhost',
     verifyPeer: 'manual',
     ...endpointOptions,
     sessionTicket: ticket,
     token,
   });
-  const cs = new Http3Session(quicSession, { settings });
+  const cs = Http3Session.from(quicSession, { settings });
 
   // Trigger the deferred handshake by opening a stream.
   // With 0-RTT, the handshake is deferred until the first stream
diff --git a/test/parallel/test-quic-h3-zero-rtt.mjs b/test/parallel/test-quic-h3-zero-rtt.mjs
index ee2ec0ba7987..65ded2fd4a00 100644
--- a/test/parallel/test-quic-h3-zero-rtt.mjs
+++ b/test/parallel/test-quic-h3-zero-rtt.mjs
@@ -14,7 +14,7 @@ if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 const { bytes } = await import('stream/iter');
 
@@ -31,8 +31,7 @@ const gotToken = Promise.withResolvers();
 let serverSessionCount = 0;
 const secondDone = Promise.withResolvers();
 
-const serverEndpoint = await listen(mustCall((quicSession) => {
-  const ss = new Http3Session(quicSession);
+const serverEndpoint = await listen(mustCall((ss) => {
   const num = ++serverSessionCount;
   ss.onstream = mustCall(async (stream) => {
     if (num === 2) {
@@ -55,7 +54,7 @@ const serverEndpoint = await listen(mustCall((quicSession) => {
 });
 
 // --- First connection: establish H3 session, receive ticket ---
-const cs1 = new Http3Session(await connect(serverEndpoint.address, {
+const cs1 = await connect(serverEndpoint.address, {
   alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
@@ -70,7 +69,7 @@ const cs1 = new Http3Session(await connect(serverEndpoint.address, {
     savedToken = token;
     gotToken.resolve();
   }),
-}));
+});
 
 const info1 = await cs1.opened;
 assert.strictEqual(info1.earlyDataAttempted, false);
@@ -98,13 +97,13 @@ assert.ok(savedTicket);
 assert.ok(savedToken);
 
 // --- Second connection: 0-RTT with H3 ---
-const cs2 = new Http3Session(await connect(serverEndpoint.address, {
+const cs2 = await connect(serverEndpoint.address, {
   alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
   sessionTicket: savedTicket,
   token: savedToken,
-}));
+});
 
 // Send H3 request BEFORE handshake completes — true 0-RTT.
 const s2 = await cs2.createBidirectionalStream({
diff --git a/test/parallel/test-quic-session-application-options.mjs b/test/parallel/test-quic-session-application-options.mjs
index 60e28597c6c2..4523423a7593 100644
--- a/test/parallel/test-quic-session-application-options.mjs
+++ b/test/parallel/test-quic-session-application-options.mjs
@@ -50,8 +50,8 @@ function check(settings, side) {
 const serverDone = Promise.withResolvers();
 
 const serverEndpoint = await listen(mustCall((quicSession) => {
-  const server = new Http3Session(quicSession, { settings: customSettings });
-  quicSession.onstream = mustCall(async (stream) => {
+  const server = Http3Session.from(quicSession, { settings: customSettings });
+  server.onstream = mustCall(async (stream) => {
     check(quicSession.applicationOptions, 'server');
     await stream.closed;
     server.close();
@@ -59,14 +59,15 @@ const serverEndpoint = await listen(mustCall((quicSession) => {
   });
 }), {
   alpn: ['h3'],
+  autoWrap: false,
   onheaders: mustCall(function() {
     this.sendHeaders({ ':status': '200' });
     this.writer.endSync();
   }),
 });
 
-const client = new Http3Session(
-  await connect(serverEndpoint.address, { alpn: 'h3' }),
+const client = Http3Session.from(
+  await connect(serverEndpoint.address, { alpn: 'h3', autoWrap: false }),
   { settings: customSettings });
 
 // The settings are in effect from the attach onwards: before the handshake

From f036f05273fed5cf5aed5d5fcf849e8f67b2c196 Mon Sep 17 00:00:00 2001
From: Tim Perry <pimterry@gmail.com>
Date: Mon, 28 Sep 2026 19:41:52 +0200
Subject: [PATCH 7/9] quic: fix subtle bugs in resume & failed H3 start
 teardown

And a little related cleanup en route

Signed-off-by: Tim Perry <pimterry@gmail.com>
---
 src/quic/endpoint.cc                         |  7 +-
 src/quic/session.cc                          | 22 +++++--
 src/quic/session.h                           |  3 +-
 test/parallel/test-quic-alpn-h3.mjs          |  3 +-
 test/parallel/test-quic-h3-attach.mjs        | 18 ------
 test/parallel/test-quic-h3-start-failure.mjs | 68 ++++++++++++++++++++
 6 files changed, 93 insertions(+), 28 deletions(-)
 create mode 100644 test/parallel/test-quic-h3-start-failure.mjs

diff --git a/src/quic/endpoint.cc b/src/quic/endpoint.cc
index 35dc7f9227f8..ed677b2dbcb5 100644
--- a/src/quic/endpoint.cc
+++ b/src/quic/endpoint.cc
@@ -1997,7 +1997,12 @@ void Endpoint::SocketAddressInfoTraits::Touch(const SocketAddress& address,
 // JavaScript call outs
 
 void Endpoint::EmitNewSession(const BaseObjectPtr<Session>& session) {
-  if (!env()->can_call_into_js()) return;
+  if (!env()->can_call_into_js()) {
+    // Even if we can't call into JS, we need to attach the app to handle
+    // other callbacks before we do proper teardown:
+    session->EnsureApplication();
+    return;
+  }
   CallbackScope<Endpoint> scope(this);
   session->set_wrapped();
   Local<Value> arg = session->object();
diff --git a/src/quic/session.cc b/src/quic/session.cc
index 051b16e89804..00828c58781f 100644
--- a/src/quic/session.cc
+++ b/src/quic/session.cc
@@ -2629,7 +2629,7 @@ bool Session::EnsureApplication() {
   if (is_destroyed()) [[unlikely]]
     return false;
   if (impl_->application_) [[likely]]
-    return true;
+    return !flags_.application_start_failed;
 
   if (application_type() == Application::Type::HTTP3) {
     SetApplication(CreateHttp3Application(this));
@@ -2639,9 +2639,16 @@ bool Session::EnsureApplication() {
   }
 
   // If the keys are already ready, that means we should start immediately.
-  // If application start fails then we can't continue.
+  // If application start fails then we can't continue. Inside an ngtcp2
+  // callback the session can't be closed directly, but the failure sticks,
+  // and HandshakeCompleted() then fails the callback, which closes it.
   if (keys_ready_ && !application().Start()) {
     Debug(this, "Application start failed");
+    flags_.application_start_failed = 1;
+    if (!flags_.in_ngtcp2_callback_scope) {
+      SetLastError(QuicError::ForNgtcp2Error(NGTCP2_ERR_INTERNAL));
+      Close();
+    }
     return false;
   }
   return true;
@@ -2865,7 +2872,7 @@ bool Session::AfterNgtcp2Read(int err) {
         if (is_server() && tls_session().early_selection() ==
                                TLSSession::EarlySelection::kSelected) {
           endpoint().EmitNewSession(BaseObjectPtr<Session>(this));
-          if (!is_destroyed()) ResumeHandshake();
+          if (has_application()) ResumeHandshake();
         }
       }
       return true;
@@ -3408,15 +3415,16 @@ void Session::StreamDataBlocked(stream_id id) {
 
 void Session::CollectSessionTicketAppData(
     SessionTicket::AppData* app_data) const {
-  DCHECK(!is_destroyed());
-  CHECK(has_application());
+  if (!has_application()) [[unlikely]]
+    return;
   application().CollectSessionTicketAppData(app_data);
 }
 
 SessionTicket::AppData::Status Session::ExtractSessionTicketAppData(
     const SessionTicket::AppData& app_data, Flag flag) {
-  DCHECK(!is_destroyed());
-  CHECK(has_application());
+  if (!has_application()) [[unlikely]] {
+    return SessionTicket::AppData::Status::TICKET_IGNORE_RENEW;
+  }
   return application().ExtractSessionTicketAppData(app_data, flag);
 }
 
diff --git a/src/quic/session.h b/src/quic/session.h
index 07799df28ab5..2dbe74ab332c 100644
--- a/src/quic/session.h
+++ b/src/quic/session.h
@@ -11,7 +11,6 @@
 #include <node_sockaddr.h>
 #include <timer_wrap.h>
 #include <util.h>
-#include <memory>
 #include <optional>
 #include <span>
 #include "bindingdata.h"
@@ -741,6 +740,8 @@ class Session final : public AsyncWrap, private SessionTicket::AppData::Source {
     // Set during FlushPendingData to avoid the one-tick latency of
     // async-only sends from the uv_check callback.
     uint8_t prefer_try_send : 1 = 0;
+    // Set if the application couldn't be started, which is fatal to it.
+    uint8_t application_start_failed : 1 = 0;
   };
   Flags flags_;
 
diff --git a/test/parallel/test-quic-alpn-h3.mjs b/test/parallel/test-quic-alpn-h3.mjs
index aaf0bdf85171..e2d620c84eba 100644
--- a/test/parallel/test-quic-alpn-h3.mjs
+++ b/test/parallel/test-quic-alpn-h3.mjs
@@ -49,5 +49,6 @@ assert.throws(() => stream.sendHeaders({ ':status': '200' }), {
   message: /does not support headers/,
 });
 
-clientSession.destroy();
+stream.destroy();
+await clientSession.close();
 await serverEndpoint.close();
diff --git a/test/parallel/test-quic-h3-attach.mjs b/test/parallel/test-quic-h3-attach.mjs
index f51170829469..1369e38d1808 100644
--- a/test/parallel/test-quic-h3-attach.mjs
+++ b/test/parallel/test-quic-h3-attach.mjs
@@ -61,10 +61,6 @@ assert.throws(() => new Http3Session(), { code: 'ERR_ILLEGAL_CONSTRUCTOR' });
       code: 'ERR_INVALID_STATE',
       message: /cannot be set on a session/,
     });
-    // And the HTTP/3-only callbacks exist only there:
-    for (const name of ['ongoaway', 'onorigin', 'onapplication']) {
-      assert.strictEqual(name in quicSession, false);
-    }
     // The onerror callback stays transport-level, so both sides keep their own:
     quicSession.onerror = () => {};
     session.onerror = () => {};
@@ -96,20 +92,6 @@ const tooLate = {
   message: /already has an application/,
 };
 
-// HTTP/3-only callbacks can't be passed as QuicSession options, so they
-// can't be registered before the application exists:
-for (const name of ['ongoaway', 'onorigin', 'onapplication']) {
-  const expected = {
-    code: 'ERR_INVALID_ARG_VALUE',
-    message: new RegExp(`options\\.${name}.*Http3Session`),
-  };
-  const callback = { [name]: () => {} };
-  await assert.rejects(listen(() => {}, { ...serverOpts, ...callback }),
-                       expected);
-  await assert.rejects(connect('127.0.0.1:1', { ...clientOpts, ...callback }),
-                       expected);
-}
-
 // Setting onstream claims the session for raw QUIC, so HTTP/3 can't be
 // attached afterwards, whether it is set directly or passed as an option.
 {
diff --git a/test/parallel/test-quic-h3-start-failure.mjs b/test/parallel/test-quic-h3-start-failure.mjs
new file mode 100644
index 000000000000..113d99805d73
--- /dev/null
+++ b/test/parallel/test-quic-h3-start-failure.mjs
@@ -0,0 +1,68 @@
+// Flags: --experimental-quic --no-warnings
+
+// Test: HTTP/3 can't start when the peer allows fewer than the three
+// unidirectional streams it needs for its control and QPACK streams. That
+// must close the session, rather than leave it running without HTTP/3.
+
+import { hasQuic, skip, mustCall } from '../common/index.mjs';
+import assert from 'node:assert';
+import * as fixtures from '../common/fixtures.mjs';
+
+if (!hasQuic) {
+  skip('QUIC is not enabled');
+}
+
+const { listen, connect } = await import('node:quic');
+const { createPrivateKey } = await import('node:crypto');
+
+const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
+const cert = fixtures.readKey('agent1-cert.pem');
+const headers = {
+  ':method': 'GET',
+  ':path': '/',
+  ':scheme': 'https',
+  ':authority': 'localhost',
+};
+const internalError = {
+  code: 'ERR_QUIC_TRANSPORT_ERROR',
+  message: /INTERNAL_ERROR/,
+};
+
+async function attachToLowUniServer() {
+  const endpoint = await listen(mustCall((quicSession) => {
+    quicSession.onerror = () => {};
+  }), {
+    alpn: ['h3'],
+    sni: { '*': { keys: [key], certs: [cert] } },
+    transportParams: { initialMaxStreamsUni: 2 },
+  });
+  const client = await connect(endpoint.address, {
+    alpn: 'h3',
+    servername: 'localhost',
+    verifyPeer: 'manual',
+  });
+  return { endpoint, client };
+}
+
+// Nothing opened: the session closes when the handshake completes.
+{
+  const { endpoint, client } = await attachToLowUniServer();
+  await assert.rejects(client.closed, internalError);
+  await endpoint.close();
+}
+
+// A request opened as soon as the session opens fails, and the session
+// closes rather than accepting further requests.
+{
+  const { endpoint, client } = await attachToLowUniServer();
+  client.onerror = mustCall((err) => {
+    assert.strictEqual(err.code, internalError.code);
+  });
+  await client.opened;
+  await assert.rejects(client.createBidirectionalStream({ headers }),
+                       { code: 'ERR_QUIC_OPEN_STREAM_FAILED' });
+  await assert.rejects(client.closed, internalError);
+  await assert.rejects(client.createBidirectionalStream({ headers }),
+                       { code: 'ERR_INVALID_STATE' });
+  await endpoint.close();
+}

From 7977f9a56e8b55cb4a156796f8dbc1c88f9d7eba Mon Sep 17 00:00:00 2001
From: Tim Perry <pimterry@gmail.com>
Date: Mon, 28 Sep 2026 21:24:16 +0200
Subject: [PATCH 8/9] quic: add autoWrap option to auto-attach HTTP/3

---
 doc/api/quic.md                               | 48 +++++++----
 lib/internal/quic/quic.js                     | 40 +++++++--
 test/parallel/test-quic-alpn-h3.mjs           |  8 +-
 test/parallel/test-quic-h3-attach.mjs         | 10 ---
 test/parallel/test-quic-h3-autowrap.mjs       | 81 +++++++++++++++++++
 .../test-quic-h3-uni-stream-teardown.mjs      |  6 +-
 6 files changed, 157 insertions(+), 36 deletions(-)
 create mode 100644 test/parallel/test-quic-h3-autowrap.mjs

diff --git a/doc/api/quic.md b/doc/api/quic.md
index 7f6b452fa93e..e72e8174c3f2 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -476,7 +476,8 @@ added: v23.8.0
 
 * `address` {string|net.SocketAddress}
 * `options` {quic.SessionOptions}
-* Returns: {Promise} a promise for a {quic.QuicSession}
+* Returns: {Promise} a promise for a {quic.QuicSession}, or {quic.Http3Session}
+  if [`sessionOptions.autoWrap`][] is enabled and an HTTP/3 ALPN is negotiated.
 
 Initiate a new client-side session.
 
@@ -3061,6 +3062,23 @@ list that the client also supports.
 
 This option is required; omitting it throws `ERR_MISSING_OPTION`.
 
+#### `sessionOptions.autoWrap`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {boolean}
+* **Default:** `true`
+
+If this option is set for [`quic.connect()`][] or [`quic.listen()`][], then
+sessions are automatically exposed as wrapped [`Http3Session`][] instances
+instead of raw [`QuicSession`][], if an HTTP/3 ALPN (`h3` or an `h3-*` draft)
+is negotiated.
+
+Set this to `false` to always receive a raw [`QuicSession`][] and configure
+HTTP/3 yourself with [`Http3Session.from()`][] instead.
+
 #### `sessionOptions.ca`
 
 <!-- YAML
@@ -3816,7 +3834,7 @@ added: v23.8.0
 -->
 
 * `this` {quic.QuicEndpoint}
-* `session` {quic.QuicSession}
+* `session` {quic.QuicSession|quic.Http3Session}
 
 The callback function that is invoked when a new server session is initiated by
 a remote peer. It is called once the peer's TLS `ClientHello` has been
@@ -4063,10 +4081,13 @@ added:
  - v24.20.0
 -->
 
-HTTP/3, backed by `nghttp3`, can run on top of a QUIC session by attaching
-an [`Http3Session`][]. Negotiating the `'h3'` ALPN tells the peer which
-protocol to speak, but does not change how the connection works locally,
-so both are needed. See [`new Http3Session()`][] for more details.
+HTTP/3, backed by `nghttp3`, runs on top of a QUIC session as an
+[`Http3Session`][]. By default, [`quic.listen()`][] and [`quic.connect()`][]
+provide one whenever an HTTP/3 ALPN is negotiated (see
+[`sessionOptions.autoWrap`][]).
+
+HTTP/3 can also be configured manually, by setting `autoWrap: false` and using
+the [`Http3Session.from()`][] API to attach HTTP/3 to an existing QUIC session.
 
 Attaching the HTTP/3 application enables a number of stream- and
 session-level capabilities that are not available to non-HTTP/3
@@ -4104,13 +4125,13 @@ applications:
 ### Minimal HTTP/3 client
 
 ```mjs
-import { connect, Http3Session } from 'node:quic';
+import { connect } from 'node:quic';
 import process from 'node:process';
 
-const session = Http3Session.from(await connect('example.com:443', {
+const session = await connect('example.com:443', {
   alpn: 'h3',
   servername: 'example.com',
-}));
+});
 await session.opened;
 
 const stream = await session.createBidirectionalStream({
@@ -4155,15 +4176,11 @@ A few things to note:
 ### Minimal HTTP/3 server
 
 ```mjs
-import { listen, Http3Session } from 'node:quic';
+import { listen } from 'node:quic';
 
 const encoder = new TextEncoder();
 
-const endpoint = await listen((quicSession) => {
-  // Attaching HTTP/3 has to happen here, synchronously, before the
-  // callback returns.
-  const session = Http3Session.from(quicSession);
-
+const endpoint = await listen((session) => {
   // The session.onstream callback fires for each new client-initiated
   // stream. It is optional here: with `onheaders` configured below,
   // request streams are consumed through that callback.
@@ -4999,6 +5016,7 @@ throughput issues caused by flow control.
 [`session.onstream`]: #sessiononstream
 [`session.opened`]: #sessionopened
 [`session.sendDatagram()`]: #sessionsenddatagramdatagram-encoding
+[`sessionOptions.autoWrap`]: #sessionoptionsautowrap
 [`sessionOptions.cc`]: #sessionoptionscc
 [`sessionOptions.ciphers`]: #sessionoptionsciphers
 [`sessionOptions.datagramDropPolicy`]: #sessionoptionsdatagramdroppolicy
diff --git a/lib/internal/quic/quic.js b/lib/internal/quic/quic.js
index be9cc64b5323..34571f4c605a 100644
--- a/lib/internal/quic/quic.js
+++ b/lib/internal/quic/quic.js
@@ -19,6 +19,7 @@ const {
   PromiseResolve,
   PromiseWithResolvers,
   SafeSet,
+  StringPrototypeStartsWith,
   Symbol,
   SymbolAsyncDispose,
   SymbolAsyncIterator,
@@ -407,6 +408,8 @@ const endpointRegistry = new SafeSet();
  * @property {string|string[]} [alpn] The ALPN protocol identifier(s).
  *   For client sessions, a single string. For server sessions, an array
  *   of protocol names in preference order.
+ * @property {boolean} [autoWrap] Whether to provide the session wrapped in the
+ *   application matching its ALPN (e.g. an Http3Session for 'h3').
  * @property {string} [ciphers] The TLS ciphers
  * @property {string} [groups] The TLS key-exchange groups
  * @property {Array<'zlib'|'brotli'|'zstd'>} [certificateCompression] The
@@ -1320,6 +1323,21 @@ function updateHeaderInterest(handle, inner) {
   );
 }
 
+/**
+ * Wraps a new session in the application matching its ALPN, if any. The
+ * http3 module is loaded lazily, as it depends on this one.
+ * @param {QuicSession} session
+ * @param {string} alpn
+ * @returns {QuicSession|Http3Session}
+ */
+function autoWrapSession(session, alpn) {
+  if (alpn === 'h3' || StringPrototypeStartsWith(alpn, 'h3-')) {
+    const { Http3Session } = require('internal/quic/http3');
+    return Http3Session.from(session);
+  }
+  return session;
+}
+
 /**
  * Applies session and stream callbacks from an options object to a session.
  * @param {QuicSession} session
@@ -4385,6 +4403,7 @@ class QuicEndpoint {
     stats: undefined,
     truncatedReads: undefined,
     onsession: undefined,
+    autoWrap: undefined,
     sessionCallbacks: undefined,
   };
 
@@ -4690,10 +4709,12 @@ class QuicEndpoint {
       onwanttrailers,
       // Stored on the endpoint and applied to each incoming session.
       truncatedReads,
+      autoWrap,
       ...rest
     } = options;
 
     inner.truncatedReads = truncatedReads;
+    inner.autoWrap = autoWrap;
 
     // Store session and stream callbacks to apply to each new incoming session.
     inner.sessionCallbacks = {
@@ -4725,15 +4746,17 @@ class QuicEndpoint {
    * Initiates a session with a remote endpoint.
    * @param {object} address
    * @param {SessionOptions} [options]
-   * @returns {QuicSession}
+   * @param {string} alpn The client's offered ALPN
+   * @returns {QuicSession|Http3Session}
    */
-  [kConnect](address, options) {
+  [kConnect](address, options, alpn) {
     assertEndpointNotClosedOrClosing(this);
     assertEndpointIsNotBusy(this);
     validateObject(options, 'options');
     const {
       sessionTicket,
       truncatedReads,
+      autoWrap,
       ...rest
     } = options;
 
@@ -4750,7 +4773,7 @@ class QuicEndpoint {
     if (options.verifyPeer !== undefined) {
       session[kVerifyPeer] = options.verifyPeer;
     }
-    return session;
+    return autoWrap ? autoWrapSession(session, alpn) : session;
   }
 
   /**
@@ -4984,6 +5007,8 @@ class QuicEndpoint {
     if (inner.sessionCallbacks) {
       applyCallbacks(session, inner.sessionCallbacks);
     }
+    const wrapped = inner.autoWrap ?
+      autoWrapSession(session, session.alpnProtocol) : session;
     if (onEndpointServerSessionChannel.hasSubscribers) {
       onEndpointServerSessionChannel.publish({
         __proto__: null,
@@ -4997,7 +5022,7 @@ class QuicEndpoint {
     // endpoint with the error rather than surfacing as an unhandled
     // exception or unhandled rejection coming out of the C++ -> JS
     // boundary.
-    safeCallbackInvoke(inner.onsession, this, session);
+    safeCallbackInvoke(inner.onsession, this, wrapped);
   }
 
   // Called by the QuicSession when it closes to remove itself from
@@ -5472,6 +5497,7 @@ function processSessionOptions(options, config = kEmptyObject) {
     streamIdleTimeout,
     verifyPeer = 'auto',
     truncatedReads = 'error',
+    autoWrap,
     // Session callbacks that can be set at construction time to avoid
     // race conditions with events that fire during or immediately
     // after the handshake.
@@ -5554,6 +5580,8 @@ function processSessionOptions(options, config = kEmptyObject) {
 
   const tls = processTlsOptions(options, forServer);
 
+  if (autoWrap !== undefined) validateBoolean(autoWrap, 'options.autoWrap');
+
   const actualEndpoint = processEndpointOption(endpoint,
                                                reuseEndpoint,
                                                forServer,
@@ -5584,6 +5612,7 @@ function processSessionOptions(options, config = kEmptyObject) {
     },
     verifyPeer,
     truncatedReads,
+    autoWrap: autoWrap ?? true,
     qlog,
     maxPayloadSize,
     unacknowledgedPacketThreshold,
@@ -5675,7 +5704,8 @@ async function connect(address, options = kEmptyObject) {
     });
   }
 
-  const session = endpoint[kConnect](address[kSocketAddressHandle], rest);
+  const session = endpoint[kConnect](address[kSocketAddressHandle], rest,
+                                     options.alpn);
 
   if (onEndpointClientSessionChannel.hasSubscribers) {
     onEndpointClientSessionChannel.publish({
diff --git a/test/parallel/test-quic-alpn-h3.mjs b/test/parallel/test-quic-alpn-h3.mjs
index e2d620c84eba..e72cf05687df 100644
--- a/test/parallel/test-quic-alpn-h3.mjs
+++ b/test/parallel/test-quic-alpn-h3.mjs
@@ -14,9 +14,9 @@ const { createPrivateKey } = await import('node:crypto');
 const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
 const cert = fixtures.readKey('agent1-cert.pem');
 
-// Negotiating the h3 ALPN does not itself activate HTTP/3. The ALPN is
-// reported as usual, but the session keeps the default application unless it
-// has an Http3Session attached.
+// With autoWrap off, negotiating the h3 ALPN does not activate HTTP/3. The
+// ALPN is reported as usual, but the session keeps the default application
+// unless an Http3Session is attached.
 
 const serverOpened = Promise.withResolvers();
 
@@ -27,6 +27,7 @@ const serverEndpoint = await listen(mustCall(async (serverSession) => {
   serverOpened.resolve();
 }), {
   alpn: ['h3'],
+  autoWrap: false,
   sni: { '*': { keys: [key], certs: [cert] } },
 });
 
@@ -34,6 +35,7 @@ assert.notStrictEqual(serverEndpoint.address, undefined);
 
 const clientSession = await connect(serverEndpoint.address, {
   alpn: 'h3',
+  autoWrap: false,
   servername: 'localhost',
   verifyPeer: 'manual',
 });
diff --git a/test/parallel/test-quic-h3-attach.mjs b/test/parallel/test-quic-h3-attach.mjs
index 1369e38d1808..c09f9e4499e9 100644
--- a/test/parallel/test-quic-h3-attach.mjs
+++ b/test/parallel/test-quic-h3-attach.mjs
@@ -46,16 +46,6 @@ assert.throws(() => new Http3Session(), { code: 'ERR_ILLEGAL_CONSTRUCTOR' });
     assert.throws(() => Http3Session.from(quicSession),
                   { code: 'ERR_INVALID_STATE' });
 
-    // HTTP/3 frames every stream, so raw streams can no longer be opened:
-    const rawRefused = {
-      code: 'ERR_INVALID_STATE',
-      message: /Raw QUIC streams cannot be created/,
-    };
-    assert.rejects(quicSession.createUnidirectionalStream(), rawRefused)
-      .then(mustCall());
-    assert.rejects(quicSession.createBidirectionalStream(), rawRefused)
-      .then(mustCall());
-
     // Incoming streams are now reported through the Http3Session only:
     assert.throws(() => { quicSession.onstream = () => {}; }, {
       code: 'ERR_INVALID_STATE',
diff --git a/test/parallel/test-quic-h3-autowrap.mjs b/test/parallel/test-quic-h3-autowrap.mjs
new file mode 100644
index 000000000000..f4f81d86f058
--- /dev/null
+++ b/test/parallel/test-quic-h3-autowrap.mjs
@@ -0,0 +1,81 @@
+// Flags: --experimental-quic --no-warnings
+
+// Test: sessions arrive wrapped in the application matching their ALPN,
+// unless autoWrap is false. Servers know the negotiated protocol before
+// surfacing a session, and clients offer exactly one.
+
+import { hasQuic, skip, mustCall } from '../common/index.mjs';
+import assert from 'node:assert';
+import * as fixtures from '../common/fixtures.mjs';
+
+if (!hasQuic) {
+  skip('QUIC is not enabled');
+}
+
+const { listen, connect, Http3Session } = await import('node:quic');
+const { createPrivateKey } = await import('node:crypto');
+
+const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
+const cert = fixtures.readKey('agent1-cert.pem');
+const clientOpts = { servername: 'localhost', verifyPeer: 'manual' };
+
+const isHttp3 = (session) => session instanceof Http3Session;
+
+// Both sides wrap by ALPN.
+{
+  const seen = [];
+  const endpoint = await listen(mustCall((session) => {
+    seen.push(isHttp3(session));
+    session.onerror = () => {};
+  }, 3), {
+    alpn: ['h3', 'h3-29', 'other'],
+    sni: { '*': { keys: [key], certs: [cert] } },
+  });
+
+  // One protocol: wrapped up front, before the handshake.
+  const single = await connect(endpoint.address, { ...clientOpts, alpn: 'h3' });
+  assert.ok(isHttp3(single));
+  assert.throws(() => Http3Session.from(single.quicSession),
+                { code: 'ERR_INVALID_STATE' });
+  await single.opened;
+  await single.close();
+
+  // Draft ALPNs count as HTTP/3 too.
+  const draft = await connect(endpoint.address, { ...clientOpts, alpn: 'h3-29' });
+  assert.ok(isHttp3(draft));
+  await draft.opened;
+  await draft.close();
+
+  // A non-HTTP/3 protocol stays a plain QuicSession on both sides.
+  const other = await connect(endpoint.address, { ...clientOpts, alpn: 'other' });
+  assert.ok(!isHttp3(other));
+  await other.opened;
+  await other.close();
+
+  await endpoint.close();
+  assert.deepStrictEqual(seen, [true, true, false]);
+}
+
+// Opting out gives the raw session on either side, to attach yourself.
+{
+  const endpoint = await listen(mustCall((quicSession) => {
+    assert.ok(!isHttp3(quicSession));
+    Http3Session.from(quicSession);
+  }), {
+    alpn: ['h3'],
+    autoWrap: false,
+    sni: { '*': { keys: [key], certs: [cert] } },
+  });
+  const quicSession = await connect(endpoint.address,
+                                    { ...clientOpts, alpn: 'h3', autoWrap: false });
+  assert.ok(!isHttp3(quicSession));
+  const session = Http3Session.from(quicSession);
+  await session.opened;
+  await session.close();
+  await endpoint.close();
+}
+
+for (const autoWrap of [1, 'yes', null]) {
+  await assert.rejects(connect('127.0.0.1:1', { ...clientOpts, alpn: 'h3', autoWrap }),
+                       { code: 'ERR_INVALID_ARG_TYPE', message: /options\.autoWrap/ });
+}
diff --git a/test/parallel/test-quic-h3-uni-stream-teardown.mjs b/test/parallel/test-quic-h3-uni-stream-teardown.mjs
index 62aebd804c02..e6fb49e6ea77 100644
--- a/test/parallel/test-quic-h3-uni-stream-teardown.mjs
+++ b/test/parallel/test-quic-h3-uni-stream-teardown.mjs
@@ -15,7 +15,7 @@ if (!hasQuic) {
 }
 
 const { createPrivateKey } = await import('node:crypto');
-const { listen, connect, Http3Session } = await import('node:quic');
+const { listen, connect } = await import('node:quic');
 
 const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
 const cert = fixtures.readKey('agent1-cert.pem');
@@ -25,11 +25,11 @@ const endpoint = await listen(mustNotCall(), {
   sni: { '*': { keys: [key], certs: [cert] } },
 });
 
-const session = new Http3Session(await connect(endpoint.address, {
+const session = await connect(endpoint.address, {
   alpn: 'h3',
   servername: 'localhost',
   verifyPeer: 'manual',
-}));
+});
 
 const refused = {
   code: 'ERR_INVALID_STATE',

From 8a3b18394eefb311f2ea470959aaf6718524f00e Mon Sep 17 00:00:00 2001
From: Tim Perry <pimterry@gmail.com>
Date: Mon, 28 Sep 2026 23:38:01 +0200
Subject: [PATCH 9/9] quic: move pure-QUIC fields back from Http3Session to
 QuicSession

---
 doc/api/quic.md                       | 14 +++++++-------
 lib/internal/quic/http3.js            | 18 +++---------------
 test/parallel/test-quic-h3-attach.mjs | 10 ++++++----
 3 files changed, 16 insertions(+), 26 deletions(-)

diff --git a/doc/api/quic.md b/doc/api/quic.md
index e72e8174c3f2..5221e53fba16 100644
--- a/doc/api/quic.md
+++ b/doc/api/quic.md
@@ -4248,10 +4248,11 @@ session should be used instead of the raw QUIC session for all HTTP/3
 interactions. The streams that this session exposes are still `QuicStream`
 instances, but they gain HTTP/3 APIs and functionality from the application.
 
-The HTTP/3 session API exposes all key HTTP/3 session details: the settings,
-statistics, TLS identity, and HTTP/3-level events. The QUIC transport details
-underneath (e.g. paths, transport parameters, and key updates) remain on the
-QUIC session, accessible as [`http3session.quicSession`][].
+The HTTP/3 session API exposes the HTTP/3 session details: the settings,
+statistics, and HTTP/3-level events. The connection details underneath (e.g.
+the TLS identity and negotiated ALPN, paths, transport parameters, and key
+updates) remain on the QUIC session, accessible as
+[`http3session.quicSession`][].
 
 HTTP/3 frames every stream on the connection, so once this is attached,
 streams cannot be opened on the QUIC session directly:
@@ -4305,9 +4306,8 @@ added: REPLACEME
 -->
 
 Each of the following behaves exactly as the member of the same name on the
-underlying [`QuicSession`][]: `alpnProtocol`, `certificate`, `close()`,
-`closed`, `destroy()`, `destroyed`, `ephemeralKeyInfo`, `opened`,
-`peerCertificate`, `servername`, and `stats`.
+underlying [`QuicSession`][]: `close()`, `closed`, `closing`, `destroy()`,
+`destroyed`, `opened`, and `stats`.
 
 Any callback set through the `Http3Session` - `onerror` and the
 HTTP/3-specific ones below - is invoked with the `Http3Session` as `this`.
diff --git a/lib/internal/quic/http3.js b/lib/internal/quic/http3.js
index d54a832dd58a..2cfabfa787dd 100644
--- a/lib/internal/quic/http3.js
+++ b/lib/internal/quic/http3.js
@@ -206,21 +206,6 @@ class Http3Session {
    */
   get settings() { return this.#session.applicationOptions; }
 
-  /** @type {string|undefined} */
-  get servername() { return this.#session.servername; }
-
-  /** @type {string|undefined} */
-  get alpnProtocol() { return this.#session.alpnProtocol; }
-
-  /** @type {object|undefined} */
-  get certificate() { return this.#session.certificate; }
-
-  /** @type {object|undefined} */
-  get peerCertificate() { return this.#session.peerCertificate; }
-
-  /** @type {object|undefined} */
-  get ephemeralKeyInfo() { return this.#session.ephemeralKeyInfo; }
-
   /** @type {quic.QuicSession.Stats} */
   get stats() { return this.#session.stats; }
 
@@ -283,6 +268,9 @@ class Http3Session {
   /** @type {Promise<void>} */
   get closed() { return this.#session.closed; }
 
+  /** @type {boolean} */
+  get closing() { return this.#session.closing; }
+
   /** @type {boolean} */
   get destroyed() { return this.#session.destroyed; }
 
diff --git a/test/parallel/test-quic-h3-attach.mjs b/test/parallel/test-quic-h3-attach.mjs
index c09f9e4499e9..788cecc57aa5 100644
--- a/test/parallel/test-quic-h3-attach.mjs
+++ b/test/parallel/test-quic-h3-attach.mjs
@@ -69,10 +69,12 @@ assert.throws(() => new Http3Session(), { code: 'ERR_ILLEGAL_CONSTRUCTOR' });
   const client = Http3Session.from(quicClient);
   await client.opened;
 
-  assert.strictEqual(client.alpnProtocol, 'h3');
-  assert.strictEqual(client.servername, 'localhost');
+  // Connection details, TLS included, stay on the QUIC session:
+  assert.strictEqual(client.quicSession.alpnProtocol, 'h3');
+  assert.strictEqual(client.quicSession.servername, 'localhost');
+  assert.strictEqual('peerCertificate' in client, false);
   assert.strictEqual(typeof client.stats.createdAt, 'bigint');
-  assert.strictEqual(typeof client.ephemeralKeyInfo, 'object');
+  assert.strictEqual(client.closing, client.quicSession.closing);
   await client.close();
   await endpoint.close();
 }
@@ -126,7 +128,7 @@ const tooLate = {
   // Further already-settled awaits are still the same checkpoint.
   await null;
   const http3 = Http3Session.from(client);
-  assert.strictEqual(http3.alpnProtocol, 'h3');
+  assert.strictEqual(http3.quicSession, client);
   await http3.close();
   await endpoint.close();
 }