nodejs
diff --git a/‎doc/api/quic.md‎
Lines changed: 6 additions & 0 deletions b/‎doc/api/quic.md‎
Lines changed: 6 additions & 0 deletions
diff --git a/‎lib/internal/quic/quic.js‎
Lines changed: 27 additions & 2 deletions b/‎lib/internal/quic/quic.js‎
Lines changed: 27 additions & 2 deletions
diff --git a/‎test/parallel/test-quic-session-stream-lifecycle.mjs‎
Lines changed: 98 additions & 0 deletions b/‎test/parallel/test-quic-session-stream-lifecycle.mjs‎
Lines changed: 98 additions & 0 deletions
@@ -204,6 +204,12 @@ added: v23.8.0
 
 True if `endpoint.destroy()` has been called. Read only.
 
+### `endpoint.listening`
+
+* Type: {boolean}
+
+True if the endpoint is actively listening for incoming connections. Read only.
+
 ### `endpoint.setSNIContexts(entries[, options])`
 
 <!-- YAML
 
@@ -720,7 +720,25 @@ class QuicStream {
   }
 
   /**
-   * @param {ArrayBuffer|ArrayBufferView|Blob} outbound
+   * Immediately destroys the stream. Any queued data is discarded. If an
+   * error is given, the closed promise will be rejected with that error.
+   * If no error is given, the closed promise will be resolved.
+   * @param {any} error
+   */
+  destroy(error) {
+    if (this.destroyed) return;
+    const handle = this.#handle;
+    this[kFinishClose](error);
+    handle.destroy();
+  }
+
+  /**
+   * Sets the outbound data source for the stream. This can only be called
+   * once and must be called before any data will be sent. The body can be
+   * an ArrayBuffer, a TypedArray or DataView, or a Blob. If the stream
+   * is destroyed or already has an outbound data source, an error will
+   * be thrown.
+   * @param {ArrayBuffer|SharedArrayBuffer|ArrayBufferView|Blob} outbound
    */
   setOutbound(outbound) {
     if (this.destroyed) {
@@ -1748,7 +1766,14 @@ class QuicEndpoint {
   get closing() { return this.#isPendingClose; }
 
   /** @type {boolean} */
-  get destroyed() { return this.#handle === undefined; }
+  get listening() {
+    return this.#listening;
+  }
+
+  /** @type {boolean} */
+  get destroyed() {
+    return this.#handle === undefined;
+  }
 
   /**
    * Forcefully terminates the endpoint by immediately destroying all sessions
 
@@ -0,0 +1,98 @@
+// Flags: --experimental-quic --no-warnings
+
+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');
+}
+
+// Import after the hasQuic check
+const quic = await import('node:quic');
+const { createPrivateKey } = await import('node:crypto');
+
+const keys = createPrivateKey(fixtures.readKey('agent1-key.pem'));
+const certs = fixtures.readKey('agent1-cert.pem');
+
+const serverDone = Promise.withResolvers();
+const clientDone = Promise.withResolvers();
+
+// Create a server endpoint
+const serverEndpoint = await quic.listen(mustCall((serverSession) => {
+  serverSession.opened.then((info) => {
+    assert.ok(serverSession.endpoint !== null);
+    assert.strictEqual(serverSession.destroyed, false);
+
+    const stats = serverSession.stats;
+    assert.strictEqual(stats.isConnected, true);
+    assert.ok(stats.handshakeCompletedAt > 0n);
+    assert.ok(stats.handshakeConfirmedAt > 0n);
+    assert.strictEqual(stats.closingAt, 0n);
+
+    serverDone.resolve();
+    serverSession.close();
+  }).then(mustCall());
+}), { sni: { '*': { keys, certs } } });
+
+assert.strictEqual(serverEndpoint.busy, false);
+assert.strictEqual(serverEndpoint.closing, false);
+assert.strictEqual(serverEndpoint.destroyed, false);
+assert.strictEqual(serverEndpoint.listening, true);
+
+assert.ok(serverEndpoint.address !== undefined);
+assert.strictEqual(serverEndpoint.address.family, 'ipv4');
+assert.strictEqual(serverEndpoint.address.address, '127.0.0.1');
+assert.ok(typeof serverEndpoint.address.port === 'number');
+assert.ok(serverEndpoint.address.port > 0);
+
+const epStats = serverEndpoint.stats;
+assert.strictEqual(epStats.isConnected, true);
+assert.ok(epStats.createdAt > 0n);
+
+// Connect with a client
+const clientSession = await quic.connect(serverEndpoint.address);
+
+assert.strictEqual(clientSession.destroyed, false);
+assert.ok(clientSession.endpoint !== null);
+assert.strictEqual(clientSession.stats.isConnected, true);
+
+clientSession.opened.then((clientInfo) => {
+  assert.strictEqual(clientInfo.servername, 'localhost');
+  assert.strictEqual(clientInfo.protocol, 'h3');
+  assert.strictEqual(clientInfo.cipherVersion, 'TLSv1.3');
+  assert.ok(clientInfo.local !== undefined);
+  assert.ok(clientInfo.remote !== undefined);
+
+  const cStats = clientSession.stats;
+  assert.strictEqual(cStats.isConnected, true);
+  assert.ok(cStats.handshakeCompletedAt > 0n);
+  assert.ok(cStats.bytesSent > 0n, 'Expected bytesSent > 0 after handshake');
+
+  clientDone.resolve();
+}).then(mustCall());
+
+await Promise.all([serverDone.promise, clientDone.promise]);
+
+// Open a bidirectional stream.
+const stream = await clientSession.createBidirectionalStream();
+
+assert.strictEqual(stream.destroyed, false);
+assert.strictEqual(stream.direction, 'bidi');
+assert.strictEqual(stream.session, clientSession);
+assert.ok(stream.id !== null, 'Non-pending stream should have an id');
+assert.strictEqual(typeof stream.id, 'bigint');
+assert.strictEqual(stream.pending, false);
+assert.strictEqual(stream.stats.isConnected, true);
+assert.ok(stream.readable instanceof ReadableStream);
+
+// Destroying the session should destroy it and the stream, and clear its properties.
+clientSession.destroy();
+assert.strictEqual(clientSession.destroyed, true);
+assert.strictEqual(clientSession.endpoint, null);
+assert.strictEqual(clientSession.stats.isConnected, false);
+
+assert.strictEqual(stream.destroyed, true);
+assert.strictEqual(stream.session, null);
+assert.strictEqual(stream.id, null);
+assert.strictEqual(stream.direction, null);