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 9cbff24bc086..8ad0c183a2a1 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
@@ -498,7 +498,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])`
@@ -520,7 +523,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
@@ -954,8 +957,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.
 
@@ -2665,7 +2669,8 @@ added:
 
 * Type: {Object}
 
-The application specific options.
+The application specific options, configured for HTTP/3 with
+[`new Http3Session()`][].
 
 #### `applicationOptions.maxHeaderPairs`
 
@@ -3065,36 +3070,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`
 
@@ -3492,6 +3468,7 @@ contain:
 
 ```mjs
 const endpoint = await listen(callback, {
+  alpn: ['h3'],
   sni: {
     '*': { keys: [defaultKey], certs: [defaultCert] },
     'api.example.com': { keys: [apiKey], certs: [apiCert], port: 8443 },
@@ -4073,13 +4050,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:
 
@@ -4115,13 +4091,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({
@@ -4166,17 +4142,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`,
@@ -4225,6 +4205,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
@@ -4760,13 +4885,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
@@ -4786,8 +4913,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
@@ -4807,6 +4939,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 95288775d42a..1de4cabc350a 100644
--- a/lib/internal/quic/quic.js
+++ b/lib/internal/quic/quic.js
@@ -68,6 +68,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,
@@ -112,6 +114,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,
@@ -211,6 +214,7 @@ const {
   kPrivateConstructor,
   kReset,
   kSendHeaders,
+  kCreateStream,
   kSessionApplication,
   kSessionTicket,
   kStopSending,
@@ -280,6 +284,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 {number} [minVersion] The minimum acceptable QUIC version
  * @property {'use'|'ignore'|'default'} [preferredAddressPolicy] The preferred address policy
  * @property {'strict'|'auto'|'manual'} [verifyPeer='auto'] Peer certificate verification policy (client only)
- * @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).
@@ -2894,6 +2900,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;
@@ -3458,6 +3474,7 @@ class QuicSession {
    */
   async createBidirectionalStream(options = kEmptyObject) {
     assertIsQuicSession(this);
+    this.#assertOwnsStreams();
     return await this.#createStream(kStreamDirectionBidirectional, options);
   }
 
@@ -3469,9 +3486,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
@@ -5178,7 +5214,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 ?
@@ -5211,6 +5246,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) {
@@ -5401,9 +5439,6 @@ function processSessionOptions(options, config = kEmptyObject) {
     maxDatagramSendAttempts = 5,
     streamIdleTimeout,
     verifyPeer = 'auto',
-    // 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.
@@ -5485,6 +5520,8 @@ function processSessionOptions(options, config = kEmptyObject) {
     }
   }
 
+  const tls = processTlsOptions(options, forServer);
+
   const actualEndpoint = processEndpointOption(endpoint,
                                                reuseEndpoint,
                                                forServer,
@@ -5502,7 +5539,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.
@@ -5529,7 +5566,6 @@ function processSessionOptions(options, config = kEmptyObject) {
     drainingPeriodMultiplier,
     maxDatagramSendAttempts,
     streamIdleTimeout,
-    application,
     onerror,
     onstream,
     ondatagram,
@@ -5666,6 +5702,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 21db0f0e3d59..19e6df496352 100644
--- a/lib/internal/quic/state.js
+++ b/lib/internal/quic/state.js
@@ -74,6 +74,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,
@@ -107,6 +108,7 @@ const {
   IDX_STATE_STREAM_WRITE_DESIRED_SIZE,
   IDX_STATE_STREAM_BUDGET,
   IDX_STATE_STREAM_RESET_CODE,
+  QUIC_APPLICATION_PENDING,
 } = internalBinding('quic');
 
 assert(IDX_STATE_SESSION_LISTENER_FLAGS !== undefined);
@@ -121,6 +123,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);
@@ -489,7 +492,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);
   }
 
@@ -501,7 +504,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);
   }
@@ -513,13 +516,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
@@ -529,7 +560,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);
   }
@@ -545,14 +576,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 60d9d7084a01..309cd93e5ac7 100644
--- a/lib/internal/quic/symbols.js
+++ b/lib/internal/quic/symbols.js
@@ -47,6 +47,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');
@@ -80,6 +81,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 2cefc8d74e1a..c50df603e98f 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 1e78b7931ce1..e742ea9a44ef 100644
--- a/src/quic/application.cc
+++ b/src/quic/application.cc
@@ -269,9 +269,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 0ae4ab53ab7e..af42577ac74e 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 e56c861261ad..c2aaf3f14e5d 100644
--- a/src/quic/bindingdata.h
+++ b/src/quic/bindingdata.h
@@ -328,6 +328,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;
 
@@ -351,6 +353,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 43ead1b8164e..4cd57e7f5fbb 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 {
@@ -1567,10 +1567,46 @@ class Http3ApplicationImpl final : public Session::Application {
       on_stream_close};
 };
 
-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 1c159d763521..63de1e6d5e88 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",
@@ -1592,6 +1589,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;
     }
@@ -1638,6 +1636,9 @@ struct Session::Impl final : public MemoryRetainer {
     if (session->impl_->application_) {
       session->application().EarlyDataRejected();
     }
+    if (!session->is_destroyed()) {
+      session->EmitEarlyDataRejected();
+    }
     return NGTCP2_SUCCESS;
   }
 
@@ -1779,7 +1780,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();
   }
 }
@@ -2015,7 +2016,7 @@ void Session::SendPendingData() {
     }
 
     // The stream_data is the next block of data from the application stream.
-    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;
@@ -2260,12 +2261,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.
@@ -2429,15 +2425,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.
@@ -2446,8 +2433,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.
@@ -2466,7 +2455,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()) {
@@ -2598,38 +2587,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) {
@@ -2639,8 +2610,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
@@ -2651,7 +2649,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();
@@ -3010,13 +3008,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) {
@@ -3093,6 +3089,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);
 
@@ -3199,6 +3198,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
@@ -3401,16 +3403,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);
 }
 
@@ -3694,7 +3694,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
@@ -3882,6 +3881,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;
 }
 
@@ -4237,9 +4242,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;
   }
@@ -4442,11 +4446,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 6cc3db4c86f4..1873abbc82b5 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);
@@ -523,6 +519,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-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-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