quic: add listEndpoints API

Signed-off-by: James M Snell <jasnell@gmail.com>
PR-URL: #63536
Backport-PR-URL: #64675
Reviewed-By: Stephen Belanger <admin@stephenbelanger.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>

Author: jasnell

doc/api/quic.md

@@ -511,6 +511,21 @@ with either a `QuicEndpoint` or `EndpointOptions` as the argument.
 At most, any single `QuicEndpoint` can only be configured to listen as
 a server once.
 
+## `quic.listEndpoints([options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+*`options` {object}
+*`active` {boolean} If `true` (the default), only returns endpoints that are
+ active (not destroyed, not closing, and not busy). If `false` returns all
+ endpoints.
+* Returns: {quic.QuicEndpoint\[]}
+
+Returns the list of all `QuicEndpoint` instances. By default, only active
+endpoints are returned.
+
 ## `quic.constants`
 
 <!-- YAML

lib/internal/quic/quic.js

@@ -5,6 +5,7 @@
 /* c8 ignore start */
 
 const{
+ ArrayFrom,
  ArrayIsArray,
  ArrayPrototypePush,
  BigInt,
@@ -4737,6 +4738,24 @@ function findSuitableEndpoint(targetAddress) {
 returnundefined;
 }
 
+/**
+ * Returns a list of all active endpoints.
+ * @param {object} [options]
+ * @param {boolean} [options.active] When true, only return endpoints that are not destroyed, closing, or busy.
+ * @returns {QuicEndpoint[]}
+ */
+functionlistEndpoints(options=kEmptyObject){
+validateObject(options,'options');
+const{ active =true}=options;
+validateBoolean(active,'options.active');
+if(!active){
+returnArrayFrom(endpointRegistry);
+}
+returnArrayFrom(endpointRegistry).filter((endpoint)=>{
+return!endpoint.destroyed&&!endpoint.closing&&!endpoint.busy;
+});
+}
+
 /**
  * @param {EndpointOptions|QuicEndpoint|undefined} endpoint
  * @param {boolean} reuseEndpoint
@@ -5340,6 +5359,7 @@ module.exports = {
  getQuicStreamState,
  getQuicSessionState,
  getQuicEndpointState,
+ listEndpoints,
 };
 
 /* c8 ignore stop */

lib/quic.js

@@ -1,10 +1,5 @@
 'use strict';
 
-const{
- ObjectCreate,
- ObjectSeal,
-}=primordials;
-
 const{
  emitExperimentalWarning,
 }=require('internal/util');
@@ -24,43 +19,32 @@ const {
 DEFAULT_GROUPS,
 }=require('internal/quic/quic');
 
-functiongetEnumerableConstant(value){
-return{
-__proto__: null,
- value,
-enumerable: true,
-configurable: false,
-writable: false,
-};
-}
-
-constcc=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-RENO: getEnumerableConstant(CC_ALGO_RENO),
-CUBIC: getEnumerableConstant(CC_ALGO_CUBIC),
-BBR: getEnumerableConstant(CC_ALGO_BBR),
-}));
+constcc={
+getRENO(){returnCC_ALGO_RENO;},
+getCUBIC(){returnCC_ALGO_CUBIC;},
+getBBR(){returnCC_ALGO_BBR;},
+};
 
-constconstants=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-cc: getEnumerableConstant(cc),
-DEFAULT_CIPHERS: getEnumerableConstant(DEFAULT_CIPHERS),
-DEFAULT_GROUPS: getEnumerableConstant(DEFAULT_GROUPS),
-}));
+constconstants={
+getcc(){returncc;},
+getDEFAULT_CIPHERS(){returnDEFAULT_CIPHERS;},
+getDEFAULT_GROUPS(){returnDEFAULT_GROUPS;},
+};
 
-module.exports=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-connect: getEnumerableConstant(connect),
-listen: getEnumerableConstant(listen),
-QuicEndpoint: getEnumerableConstant(QuicEndpoint),
-QuicError: getEnumerableConstant(QuicError),
-QuicSession: getEnumerableConstant(QuicSession),
-QuicStream: getEnumerableConstant(QuicStream),
-constants: getEnumerableConstant(constants),
+module.exports={
+ connect,
+ listen,
+ QuicEndpoint,
+ QuicError,
+ QuicSession,
+ QuicStream,
+getconstants(){
+returnconstants;
+},
 
 CC_ALGO_RENO,
 CC_ALGO_CUBIC,
 CC_ALGO_BBR,
 DEFAULT_CIPHERS,
 DEFAULT_GROUPS,
-}));
+};

test/parallel/test-quic-exports.mjs

@@ -35,11 +35,5 @@ strictEqual(quic.constants.DEFAULT_GROUPS, 'X25519:P-256:P-384:P-521');
 throws(()=>{quic.constants.cc.RENO='foo';},TypeError);
 strictEqual(quic.constants.cc.RENO,'reno');
 
-throws(()=>{quic.constants.cc.NEW_CONSTANT='bar';},TypeError);
-strictEqual(quic.constants.cc.NEW_CONSTANT,undefined);
-
 throws(()=>{quic.constants.DEFAULT_CIPHERS=123;},TypeError);
 strictEqual(typeofquic.constants.DEFAULT_CIPHERS,'string');
-
-throws(()=>{quic.constants.NEW_CONSTANT=456;},TypeError);
-strictEqual(quic.constants.NEW_CONSTANT,undefined);

test/parallel/test-quic-list-endpoints.mjs

@@ -0,0 +1,105 @@
+// Flags: --experimental-quic --no-warnings
+
+// Test: listEndpoints returns live endpoints filtered by active state.
+// - Returns an empty array when no endpoints exist.
+// - Includes all created endpoints.
+// - active=true (default) filters out destroyed, closing, and busy endpoints.
+// - active=false returns all registered endpoints regardless of state.
+// - Validates options argument types.
+
+import{hasQuic,skip}from'../common/index.mjs';
+importassertfrom'node:assert';
+
+const{ deepStrictEqual, strictEqual, throws, ok }=assert;
+
+if(!hasQuic){
+skip('QUIC is not enabled');
+}
+
+const{ listEndpoints, QuicEndpoint }=awaitimport('node:quic');
+
+// listEndpoints is exported as a function.
+strictEqual(typeoflistEndpoints,'function');
+
+// Empty when no endpoints have been created.
+deepStrictEqual(listEndpoints(),[]);
+deepStrictEqual(listEndpoints({active: false}),[]);
+
+// Created endpoints appear in the list.
+{
+constep1=newQuicEndpoint();
+constep2=newQuicEndpoint();
+
+constlist=listEndpoints();
+strictEqual(list.length,2);
+ok(list.includes(ep1));
+ok(list.includes(ep2));
+
+// active=false also returns them.
+constall=listEndpoints({active: false});
+strictEqual(all.length,2);
+ok(all.includes(ep1));
+ok(all.includes(ep2));
+
+// Returns plain QuicEndpoint instances, not wrapped in arrays.
+ok(list[0]instanceofQuicEndpoint);
+ok(list[1]instanceofQuicEndpoint);
+
+awaitep1.close();
+awaitep2.close();
+}
+
+// Destroyed endpoints are excluded by active filter.
+{
+constep=newQuicEndpoint();
+strictEqual(listEndpoints().length,1);
+
+awaitep.close();
+awaitep.closed;
+strictEqual(ep.destroyed,true);
+
+// Default (active=true) excludes destroyed endpoint.
+strictEqual(listEndpoints().length,0);
+
+// active=false still includes it... but destroyed endpoints are removed
+// from the registry entirely in kFinishClose, so it won't appear at all.
+strictEqual(listEndpoints({active: false}).length,0);
+}
+
+// Busy endpoints are excluded by the active filter.
+{
+constep=newQuicEndpoint();
+strictEqual(listEndpoints().length,1);
+
+ep.busy=true;
+strictEqual(ep.busy,true);
+
+// active=true excludes busy endpoint.
+strictEqual(listEndpoints().length,0);
+
+// active=false includes it.
+constall=listEndpoints({active: false});
+strictEqual(all.length,1);
+ok(all.includes(ep));
+
+ep.busy=false;
+
+// After un-busying, it reappears in the active list.
+strictEqual(listEndpoints().length,1);
+
+awaitep.close();
+}
+
+// Options validation.
+throws(()=>listEndpoints('bad'),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints(null),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints({active: 'yes'}),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints({active: 1}),{
+code: 'ERR_INVALID_ARG_TYPE',
+});

doc/api/quic.md

@@ -511,6 +511,21 @@ with either a `QuicEndpoint` or `EndpointOptions` as the argument.
 At most, any single `QuicEndpoint` can only be configured to listen as
 a server once.
 
+## `quic.listEndpoints([options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+*`options` {object}
+*`active` {boolean} If `true` (the default), only returns endpoints that are
+ active (not destroyed, not closing, and not busy). If `false` returns all
+ endpoints.
+* Returns: {quic.QuicEndpoint\[]}
+
+Returns the list of all `QuicEndpoint` instances. By default, only active
+endpoints are returned.
+
 ## `quic.constants`
 
 <!-- YAML

lib/internal/quic/quic.js

@@ -5,6 +5,7 @@
 /* c8 ignore start */
 
 const{
+ ArrayFrom,
  ArrayIsArray,
  ArrayPrototypePush,
  BigInt,
@@ -4737,6 +4738,24 @@ function findSuitableEndpoint(targetAddress) {
 returnundefined;
 }
 
+/**
+ * Returns a list of all active endpoints.
+ * @param {object} [options]
+ * @param {boolean} [options.active] When true, only return endpoints that are not destroyed, closing, or busy.
+ * @returns {QuicEndpoint[]}
+ */
+functionlistEndpoints(options=kEmptyObject){
+validateObject(options,'options');
+const{ active =true}=options;
+validateBoolean(active,'options.active');
+if(!active){
+returnArrayFrom(endpointRegistry);
+}
+returnArrayFrom(endpointRegistry).filter((endpoint)=>{
+return!endpoint.destroyed&&!endpoint.closing&&!endpoint.busy;
+});
+}
+
 /**
  * @param {EndpointOptions|QuicEndpoint|undefined} endpoint
  * @param {boolean} reuseEndpoint
@@ -5340,6 +5359,7 @@ module.exports = {
  getQuicStreamState,
  getQuicSessionState,
  getQuicEndpointState,
+ listEndpoints,
 };
 
 /* c8 ignore stop */

lib/quic.js

@@ -1,10 +1,5 @@
 'use strict';
 
-const{
- ObjectCreate,
- ObjectSeal,
-}=primordials;
-
 const{
  emitExperimentalWarning,
 }=require('internal/util');
@@ -24,43 +19,32 @@ const {
 DEFAULT_GROUPS,
 }=require('internal/quic/quic');
 
-functiongetEnumerableConstant(value){
-return{
-__proto__: null,
- value,
-enumerable: true,
-configurable: false,
-writable: false,
-};
-}
-
-constcc=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-RENO: getEnumerableConstant(CC_ALGO_RENO),
-CUBIC: getEnumerableConstant(CC_ALGO_CUBIC),
-BBR: getEnumerableConstant(CC_ALGO_BBR),
-}));
+constcc={
+getRENO(){returnCC_ALGO_RENO;},
+getCUBIC(){returnCC_ALGO_CUBIC;},
+getBBR(){returnCC_ALGO_BBR;},
+};
 
-constconstants=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-cc: getEnumerableConstant(cc),
-DEFAULT_CIPHERS: getEnumerableConstant(DEFAULT_CIPHERS),
-DEFAULT_GROUPS: getEnumerableConstant(DEFAULT_GROUPS),
-}));
+constconstants={
+getcc(){returncc;},
+getDEFAULT_CIPHERS(){returnDEFAULT_CIPHERS;},
+getDEFAULT_GROUPS(){returnDEFAULT_GROUPS;},
+};
 
-module.exports=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-connect: getEnumerableConstant(connect),
-listen: getEnumerableConstant(listen),
-QuicEndpoint: getEnumerableConstant(QuicEndpoint),
-QuicError: getEnumerableConstant(QuicError),
-QuicSession: getEnumerableConstant(QuicSession),
-QuicStream: getEnumerableConstant(QuicStream),
-constants: getEnumerableConstant(constants),
+module.exports={
+ connect,
+ listen,
+ QuicEndpoint,
+ QuicError,
+ QuicSession,
+ QuicStream,
+getconstants(){
+returnconstants;
+},
 
 CC_ALGO_RENO,
 CC_ALGO_CUBIC,
 CC_ALGO_BBR,
 DEFAULT_CIPHERS,
 DEFAULT_GROUPS,
-}));
+};

test/parallel/test-quic-exports.mjs

@@ -35,11 +35,5 @@ strictEqual(quic.constants.DEFAULT_GROUPS, 'X25519:P-256:P-384:P-521');
 throws(()=>{quic.constants.cc.RENO='foo';},TypeError);
 strictEqual(quic.constants.cc.RENO,'reno');
 
-throws(()=>{quic.constants.cc.NEW_CONSTANT='bar';},TypeError);
-strictEqual(quic.constants.cc.NEW_CONSTANT,undefined);
-
 throws(()=>{quic.constants.DEFAULT_CIPHERS=123;},TypeError);
 strictEqual(typeofquic.constants.DEFAULT_CIPHERS,'string');
-
-throws(()=>{quic.constants.NEW_CONSTANT=456;},TypeError);
-strictEqual(quic.constants.NEW_CONSTANT,undefined);

test/parallel/test-quic-list-endpoints.mjs

@@ -0,0 +1,105 @@
+// Flags: --experimental-quic --no-warnings
+
+// Test: listEndpoints returns live endpoints filtered by active state.
+// - Returns an empty array when no endpoints exist.
+// - Includes all created endpoints.
+// - active=true (default) filters out destroyed, closing, and busy endpoints.
+// - active=false returns all registered endpoints regardless of state.
+// - Validates options argument types.
+
+import{hasQuic,skip}from'../common/index.mjs';
+importassertfrom'node:assert';
+
+const{ deepStrictEqual, strictEqual, throws, ok }=assert;
+
+if(!hasQuic){
+skip('QUIC is not enabled');
+}
+
+const{ listEndpoints, QuicEndpoint }=awaitimport('node:quic');
+
+// listEndpoints is exported as a function.
+strictEqual(typeoflistEndpoints,'function');
+
+// Empty when no endpoints have been created.
+deepStrictEqual(listEndpoints(),[]);
+deepStrictEqual(listEndpoints({active: false}),[]);
+
+// Created endpoints appear in the list.
+{
+constep1=newQuicEndpoint();
+constep2=newQuicEndpoint();
+
+constlist=listEndpoints();
+strictEqual(list.length,2);
+ok(list.includes(ep1));
+ok(list.includes(ep2));
+
+// active=false also returns them.
+constall=listEndpoints({active: false});
+strictEqual(all.length,2);
+ok(all.includes(ep1));
+ok(all.includes(ep2));
+
+// Returns plain QuicEndpoint instances, not wrapped in arrays.
+ok(list[0]instanceofQuicEndpoint);
+ok(list[1]instanceofQuicEndpoint);
+
+awaitep1.close();
+awaitep2.close();
+}
+
+// Destroyed endpoints are excluded by active filter.
+{
+constep=newQuicEndpoint();
+strictEqual(listEndpoints().length,1);
+
+awaitep.close();
+awaitep.closed;
+strictEqual(ep.destroyed,true);
+
+// Default (active=true) excludes destroyed endpoint.
+strictEqual(listEndpoints().length,0);
+
+// active=false still includes it... but destroyed endpoints are removed
+// from the registry entirely in kFinishClose, so it won't appear at all.
+strictEqual(listEndpoints({active: false}).length,0);
+}
+
+// Busy endpoints are excluded by the active filter.
+{
+constep=newQuicEndpoint();
+strictEqual(listEndpoints().length,1);
+
+ep.busy=true;
+strictEqual(ep.busy,true);
+
+// active=true excludes busy endpoint.
+strictEqual(listEndpoints().length,0);
+
+// active=false includes it.
+constall=listEndpoints({active: false});
+strictEqual(all.length,1);
+ok(all.includes(ep));
+
+ep.busy=false;
+
+// After un-busying, it reappears in the active list.
+strictEqual(listEndpoints().length,1);
+
+awaitep.close();
+}
+
+// Options validation.
+throws(()=>listEndpoints('bad'),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints(null),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints({active: 'yes'}),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints({active: 1}),{
+code: 'ERR_INVALID_ARG_TYPE',
+});

doc/api/quic.md

@@ -511,6 +511,21 @@ with either a `QuicEndpoint` or `EndpointOptions` as the argument.
 At most, any single `QuicEndpoint` can only be configured to listen as
 a server once.
 
+## `quic.listEndpoints([options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+*`options` {object}
+*`active` {boolean} If `true` (the default), only returns endpoints that are
+ active (not destroyed, not closing, and not busy). If `false` returns all
+ endpoints.
+* Returns: {quic.QuicEndpoint\[]}
+
+Returns the list of all `QuicEndpoint` instances. By default, only active
+endpoints are returned.
+
 ## `quic.constants`
 
 <!-- YAML

lib/internal/quic/quic.js

@@ -5,6 +5,7 @@
 /* c8 ignore start */
 
 const{
+ ArrayFrom,
  ArrayIsArray,
  ArrayPrototypePush,
  BigInt,
@@ -4737,6 +4738,24 @@ function findSuitableEndpoint(targetAddress) {
 returnundefined;
 }
 
+/**
+ * Returns a list of all active endpoints.
+ * @param {object} [options]
+ * @param {boolean} [options.active] When true, only return endpoints that are not destroyed, closing, or busy.
+ * @returns {QuicEndpoint[]}
+ */
+functionlistEndpoints(options=kEmptyObject){
+validateObject(options,'options');
+const{ active =true}=options;
+validateBoolean(active,'options.active');
+if(!active){
+returnArrayFrom(endpointRegistry);
+}
+returnArrayFrom(endpointRegistry).filter((endpoint)=>{
+return!endpoint.destroyed&&!endpoint.closing&&!endpoint.busy;
+});
+}
+
 /**
  * @param {EndpointOptions|QuicEndpoint|undefined} endpoint
  * @param {boolean} reuseEndpoint
@@ -5340,6 +5359,7 @@ module.exports = {
  getQuicStreamState,
  getQuicSessionState,
  getQuicEndpointState,
+ listEndpoints,
 };
 
 /* c8 ignore stop */

lib/quic.js

@@ -1,10 +1,5 @@
 'use strict';
 
-const{
- ObjectCreate,
- ObjectSeal,
-}=primordials;
-
 const{
  emitExperimentalWarning,
 }=require('internal/util');
@@ -24,43 +19,32 @@ const {
 DEFAULT_GROUPS,
 }=require('internal/quic/quic');
 
-functiongetEnumerableConstant(value){
-return{
-__proto__: null,
- value,
-enumerable: true,
-configurable: false,
-writable: false,
-};
-}
-
-constcc=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-RENO: getEnumerableConstant(CC_ALGO_RENO),
-CUBIC: getEnumerableConstant(CC_ALGO_CUBIC),
-BBR: getEnumerableConstant(CC_ALGO_BBR),
-}));
+constcc={
+getRENO(){returnCC_ALGO_RENO;},
+getCUBIC(){returnCC_ALGO_CUBIC;},
+getBBR(){returnCC_ALGO_BBR;},
+};
 
-constconstants=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-cc: getEnumerableConstant(cc),
-DEFAULT_CIPHERS: getEnumerableConstant(DEFAULT_CIPHERS),
-DEFAULT_GROUPS: getEnumerableConstant(DEFAULT_GROUPS),
-}));
+constconstants={
+getcc(){returncc;},
+getDEFAULT_CIPHERS(){returnDEFAULT_CIPHERS;},
+getDEFAULT_GROUPS(){returnDEFAULT_GROUPS;},
+};
 
-module.exports=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-connect: getEnumerableConstant(connect),
-listen: getEnumerableConstant(listen),
-QuicEndpoint: getEnumerableConstant(QuicEndpoint),
-QuicError: getEnumerableConstant(QuicError),
-QuicSession: getEnumerableConstant(QuicSession),
-QuicStream: getEnumerableConstant(QuicStream),
-constants: getEnumerableConstant(constants),
+module.exports={
+ connect,
+ listen,
+ QuicEndpoint,
+ QuicError,
+ QuicSession,
+ QuicStream,
+getconstants(){
+returnconstants;
+},
 
 CC_ALGO_RENO,
 CC_ALGO_CUBIC,
 CC_ALGO_BBR,
 DEFAULT_CIPHERS,
 DEFAULT_GROUPS,
-}));
+};

test/parallel/test-quic-exports.mjs

@@ -35,11 +35,5 @@ strictEqual(quic.constants.DEFAULT_GROUPS, 'X25519:P-256:P-384:P-521');
 throws(()=>{quic.constants.cc.RENO='foo';},TypeError);
 strictEqual(quic.constants.cc.RENO,'reno');
 
-throws(()=>{quic.constants.cc.NEW_CONSTANT='bar';},TypeError);
-strictEqual(quic.constants.cc.NEW_CONSTANT,undefined);
-
 throws(()=>{quic.constants.DEFAULT_CIPHERS=123;},TypeError);
 strictEqual(typeofquic.constants.DEFAULT_CIPHERS,'string');
-
-throws(()=>{quic.constants.NEW_CONSTANT=456;},TypeError);
-strictEqual(quic.constants.NEW_CONSTANT,undefined);

test/parallel/test-quic-list-endpoints.mjs

@@ -0,0 +1,105 @@
+// Flags: --experimental-quic --no-warnings
+
+// Test: listEndpoints returns live endpoints filtered by active state.
+// - Returns an empty array when no endpoints exist.
+// - Includes all created endpoints.
+// - active=true (default) filters out destroyed, closing, and busy endpoints.
+// - active=false returns all registered endpoints regardless of state.
+// - Validates options argument types.
+
+import{hasQuic,skip}from'../common/index.mjs';
+importassertfrom'node:assert';
+
+const{ deepStrictEqual, strictEqual, throws, ok }=assert;
+
+if(!hasQuic){
+skip('QUIC is not enabled');
+}
+
+const{ listEndpoints, QuicEndpoint }=awaitimport('node:quic');
+
+// listEndpoints is exported as a function.
+strictEqual(typeoflistEndpoints,'function');
+
+// Empty when no endpoints have been created.
+deepStrictEqual(listEndpoints(),[]);
+deepStrictEqual(listEndpoints({active: false}),[]);
+
+// Created endpoints appear in the list.
+{
+constep1=newQuicEndpoint();
+constep2=newQuicEndpoint();
+
+constlist=listEndpoints();
+strictEqual(list.length,2);
+ok(list.includes(ep1));
+ok(list.includes(ep2));
+
+// active=false also returns them.
+constall=listEndpoints({active: false});
+strictEqual(all.length,2);
+ok(all.includes(ep1));
+ok(all.includes(ep2));
+
+// Returns plain QuicEndpoint instances, not wrapped in arrays.
+ok(list[0]instanceofQuicEndpoint);
+ok(list[1]instanceofQuicEndpoint);
+
+awaitep1.close();
+awaitep2.close();
+}
+
+// Destroyed endpoints are excluded by active filter.
+{
+constep=newQuicEndpoint();
+strictEqual(listEndpoints().length,1);
+
+awaitep.close();
+awaitep.closed;
+strictEqual(ep.destroyed,true);
+
+// Default (active=true) excludes destroyed endpoint.
+strictEqual(listEndpoints().length,0);
+
+// active=false still includes it... but destroyed endpoints are removed
+// from the registry entirely in kFinishClose, so it won't appear at all.
+strictEqual(listEndpoints({active: false}).length,0);
+}
+
+// Busy endpoints are excluded by the active filter.
+{
+constep=newQuicEndpoint();
+strictEqual(listEndpoints().length,1);
+
+ep.busy=true;
+strictEqual(ep.busy,true);
+
+// active=true excludes busy endpoint.
+strictEqual(listEndpoints().length,0);
+
+// active=false includes it.
+constall=listEndpoints({active: false});
+strictEqual(all.length,1);
+ok(all.includes(ep));
+
+ep.busy=false;
+
+// After un-busying, it reappears in the active list.
+strictEqual(listEndpoints().length,1);
+
+awaitep.close();
+}
+
+// Options validation.
+throws(()=>listEndpoints('bad'),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints(null),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints({active: 'yes'}),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints({active: 1}),{
+code: 'ERR_INVALID_ARG_TYPE',
+});

doc/api/quic.md

@@ -511,6 +511,21 @@ with either a `QuicEndpoint` or `EndpointOptions` as the argument.
 At most, any single `QuicEndpoint` can only be configured to listen as
 a server once.
 
+## `quic.listEndpoints([options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+*`options` {object}
+*`active` {boolean} If `true` (the default), only returns endpoints that are
+ active (not destroyed, not closing, and not busy). If `false` returns all
+ endpoints.
+* Returns: {quic.QuicEndpoint\[]}
+
+Returns the list of all `QuicEndpoint` instances. By default, only active
+endpoints are returned.
+
 ## `quic.constants`
 
 <!-- YAML

lib/internal/quic/quic.js

@@ -5,6 +5,7 @@
 /* c8 ignore start */
 
 const{
+ ArrayFrom,
  ArrayIsArray,
  ArrayPrototypePush,
  BigInt,
@@ -4737,6 +4738,24 @@ function findSuitableEndpoint(targetAddress) {
 returnundefined;
 }
 
+/**
+ * Returns a list of all active endpoints.
+ * @param {object} [options]
+ * @param {boolean} [options.active] When true, only return endpoints that are not destroyed, closing, or busy.
+ * @returns {QuicEndpoint[]}
+ */
+functionlistEndpoints(options=kEmptyObject){
+validateObject(options,'options');
+const{ active =true}=options;
+validateBoolean(active,'options.active');
+if(!active){
+returnArrayFrom(endpointRegistry);
+}
+returnArrayFrom(endpointRegistry).filter((endpoint)=>{
+return!endpoint.destroyed&&!endpoint.closing&&!endpoint.busy;
+});
+}
+
 /**
  * @param {EndpointOptions|QuicEndpoint|undefined} endpoint
  * @param {boolean} reuseEndpoint
@@ -5340,6 +5359,7 @@ module.exports = {
  getQuicStreamState,
  getQuicSessionState,
  getQuicEndpointState,
+ listEndpoints,
 };
 
 /* c8 ignore stop */

lib/quic.js

@@ -1,10 +1,5 @@
 'use strict';
 
-const{
- ObjectCreate,
- ObjectSeal,
-}=primordials;
-
 const{
  emitExperimentalWarning,
 }=require('internal/util');
@@ -24,43 +19,32 @@ const {
 DEFAULT_GROUPS,
 }=require('internal/quic/quic');
 
-functiongetEnumerableConstant(value){
-return{
-__proto__: null,
- value,
-enumerable: true,
-configurable: false,
-writable: false,
-};
-}
-
-constcc=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-RENO: getEnumerableConstant(CC_ALGO_RENO),
-CUBIC: getEnumerableConstant(CC_ALGO_CUBIC),
-BBR: getEnumerableConstant(CC_ALGO_BBR),
-}));
+constcc={
+getRENO(){returnCC_ALGO_RENO;},
+getCUBIC(){returnCC_ALGO_CUBIC;},
+getBBR(){returnCC_ALGO_BBR;},
+};
 
-constconstants=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-cc: getEnumerableConstant(cc),
-DEFAULT_CIPHERS: getEnumerableConstant(DEFAULT_CIPHERS),
-DEFAULT_GROUPS: getEnumerableConstant(DEFAULT_GROUPS),
-}));
+constconstants={
+getcc(){returncc;},
+getDEFAULT_CIPHERS(){returnDEFAULT_CIPHERS;},
+getDEFAULT_GROUPS(){returnDEFAULT_GROUPS;},
+};
 
-module.exports=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-connect: getEnumerableConstant(connect),
-listen: getEnumerableConstant(listen),
-QuicEndpoint: getEnumerableConstant(QuicEndpoint),
-QuicError: getEnumerableConstant(QuicError),
-QuicSession: getEnumerableConstant(QuicSession),
-QuicStream: getEnumerableConstant(QuicStream),
-constants: getEnumerableConstant(constants),
+module.exports={
+ connect,
+ listen,
+ QuicEndpoint,
+ QuicError,
+ QuicSession,
+ QuicStream,
+getconstants(){
+returnconstants;
+},
 
 CC_ALGO_RENO,
 CC_ALGO_CUBIC,
 CC_ALGO_BBR,
 DEFAULT_CIPHERS,
 DEFAULT_GROUPS,
-}));
+};

test/parallel/test-quic-exports.mjs

@@ -35,11 +35,5 @@ strictEqual(quic.constants.DEFAULT_GROUPS, 'X25519:P-256:P-384:P-521');
 throws(()=>{quic.constants.cc.RENO='foo';},TypeError);
 strictEqual(quic.constants.cc.RENO,'reno');
 
-throws(()=>{quic.constants.cc.NEW_CONSTANT='bar';},TypeError);
-strictEqual(quic.constants.cc.NEW_CONSTANT,undefined);
-
 throws(()=>{quic.constants.DEFAULT_CIPHERS=123;},TypeError);
 strictEqual(typeofquic.constants.DEFAULT_CIPHERS,'string');
-
-throws(()=>{quic.constants.NEW_CONSTANT=456;},TypeError);
-strictEqual(quic.constants.NEW_CONSTANT,undefined);

test/parallel/test-quic-list-endpoints.mjs

@@ -0,0 +1,105 @@
+// Flags: --experimental-quic --no-warnings
+
+// Test: listEndpoints returns live endpoints filtered by active state.
+// - Returns an empty array when no endpoints exist.
+// - Includes all created endpoints.
+// - active=true (default) filters out destroyed, closing, and busy endpoints.
+// - active=false returns all registered endpoints regardless of state.
+// - Validates options argument types.
+
+import{hasQuic,skip}from'../common/index.mjs';
+importassertfrom'node:assert';
+
+const{ deepStrictEqual, strictEqual, throws, ok }=assert;
+
+if(!hasQuic){
+skip('QUIC is not enabled');
+}
+
+const{ listEndpoints, QuicEndpoint }=awaitimport('node:quic');
+
+// listEndpoints is exported as a function.
+strictEqual(typeoflistEndpoints,'function');
+
+// Empty when no endpoints have been created.
+deepStrictEqual(listEndpoints(),[]);
+deepStrictEqual(listEndpoints({active: false}),[]);
+
+// Created endpoints appear in the list.
+{
+constep1=newQuicEndpoint();
+constep2=newQuicEndpoint();
+
+constlist=listEndpoints();
+strictEqual(list.length,2);
+ok(list.includes(ep1));
+ok(list.includes(ep2));
+
+// active=false also returns them.
+constall=listEndpoints({active: false});
+strictEqual(all.length,2);
+ok(all.includes(ep1));
+ok(all.includes(ep2));
+
+// Returns plain QuicEndpoint instances, not wrapped in arrays.
+ok(list[0]instanceofQuicEndpoint);
+ok(list[1]instanceofQuicEndpoint);
+
+awaitep1.close();
+awaitep2.close();
+}
+
+// Destroyed endpoints are excluded by active filter.
+{
+constep=newQuicEndpoint();
+strictEqual(listEndpoints().length,1);
+
+awaitep.close();
+awaitep.closed;
+strictEqual(ep.destroyed,true);
+
+// Default (active=true) excludes destroyed endpoint.
+strictEqual(listEndpoints().length,0);
+
+// active=false still includes it... but destroyed endpoints are removed
+// from the registry entirely in kFinishClose, so it won't appear at all.
+strictEqual(listEndpoints({active: false}).length,0);
+}
+
+// Busy endpoints are excluded by the active filter.
+{
+constep=newQuicEndpoint();
+strictEqual(listEndpoints().length,1);
+
+ep.busy=true;
+strictEqual(ep.busy,true);
+
+// active=true excludes busy endpoint.
+strictEqual(listEndpoints().length,0);
+
+// active=false includes it.
+constall=listEndpoints({active: false});
+strictEqual(all.length,1);
+ok(all.includes(ep));
+
+ep.busy=false;
+
+// After un-busying, it reappears in the active list.
+strictEqual(listEndpoints().length,1);
+
+awaitep.close();
+}
+
+// Options validation.
+throws(()=>listEndpoints('bad'),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints(null),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints({active: 'yes'}),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints({active: 1}),{
+code: 'ERR_INVALID_ARG_TYPE',
+});

doc/api/quic.md

@@ -511,6 +511,21 @@ with either a `QuicEndpoint` or `EndpointOptions` as the argument.
 At most, any single `QuicEndpoint` can only be configured to listen as
 a server once.
 
+## `quic.listEndpoints([options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+*`options` {object}
+*`active` {boolean} If `true` (the default), only returns endpoints that are
+ active (not destroyed, not closing, and not busy). If `false` returns all
+ endpoints.
+* Returns: {quic.QuicEndpoint\[]}
+
+Returns the list of all `QuicEndpoint` instances. By default, only active
+endpoints are returned.
+
 ## `quic.constants`
 
 <!-- YAML

lib/internal/quic/quic.js

@@ -5,6 +5,7 @@
 /* c8 ignore start */
 
 const{
+ ArrayFrom,
  ArrayIsArray,
  ArrayPrototypePush,
  BigInt,
@@ -4737,6 +4738,24 @@ function findSuitableEndpoint(targetAddress) {
 returnundefined;
 }
 
+/**
+ * Returns a list of all active endpoints.
+ * @param {object} [options]
+ * @param {boolean} [options.active] When true, only return endpoints that are not destroyed, closing, or busy.
+ * @returns {QuicEndpoint[]}
+ */
+functionlistEndpoints(options=kEmptyObject){
+validateObject(options,'options');
+const{ active =true}=options;
+validateBoolean(active,'options.active');
+if(!active){
+returnArrayFrom(endpointRegistry);
+}
+returnArrayFrom(endpointRegistry).filter((endpoint)=>{
+return!endpoint.destroyed&&!endpoint.closing&&!endpoint.busy;
+});
+}
+
 /**
  * @param {EndpointOptions|QuicEndpoint|undefined} endpoint
  * @param {boolean} reuseEndpoint
@@ -5340,6 +5359,7 @@ module.exports = {
  getQuicStreamState,
  getQuicSessionState,
  getQuicEndpointState,
+ listEndpoints,
 };
 
 /* c8 ignore stop */

lib/quic.js

@@ -1,10 +1,5 @@
 'use strict';
 
-const{
- ObjectCreate,
- ObjectSeal,
-}=primordials;
-
 const{
  emitExperimentalWarning,
 }=require('internal/util');
@@ -24,43 +19,32 @@ const {
 DEFAULT_GROUPS,
 }=require('internal/quic/quic');
 
-functiongetEnumerableConstant(value){
-return{
-__proto__: null,
- value,
-enumerable: true,
-configurable: false,
-writable: false,
-};
-}
-
-constcc=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-RENO: getEnumerableConstant(CC_ALGO_RENO),
-CUBIC: getEnumerableConstant(CC_ALGO_CUBIC),
-BBR: getEnumerableConstant(CC_ALGO_BBR),
-}));
+constcc={
+getRENO(){returnCC_ALGO_RENO;},
+getCUBIC(){returnCC_ALGO_CUBIC;},
+getBBR(){returnCC_ALGO_BBR;},
+};
 
-constconstants=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-cc: getEnumerableConstant(cc),
-DEFAULT_CIPHERS: getEnumerableConstant(DEFAULT_CIPHERS),
-DEFAULT_GROUPS: getEnumerableConstant(DEFAULT_GROUPS),
-}));
+constconstants={
+getcc(){returncc;},
+getDEFAULT_CIPHERS(){returnDEFAULT_CIPHERS;},
+getDEFAULT_GROUPS(){returnDEFAULT_GROUPS;},
+};
 
-module.exports=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-connect: getEnumerableConstant(connect),
-listen: getEnumerableConstant(listen),
-QuicEndpoint: getEnumerableConstant(QuicEndpoint),
-QuicError: getEnumerableConstant(QuicError),
-QuicSession: getEnumerableConstant(QuicSession),
-QuicStream: getEnumerableConstant(QuicStream),
-constants: getEnumerableConstant(constants),
+module.exports={
+ connect,
+ listen,
+ QuicEndpoint,
+ QuicError,
+ QuicSession,
+ QuicStream,
+getconstants(){
+returnconstants;
+},
 
 CC_ALGO_RENO,
 CC_ALGO_CUBIC,
 CC_ALGO_BBR,
 DEFAULT_CIPHERS,
 DEFAULT_GROUPS,
-}));
+};

test/parallel/test-quic-exports.mjs

@@ -35,11 +35,5 @@ strictEqual(quic.constants.DEFAULT_GROUPS, 'X25519:P-256:P-384:P-521');
 throws(()=>{quic.constants.cc.RENO='foo';},TypeError);
 strictEqual(quic.constants.cc.RENO,'reno');
 
-throws(()=>{quic.constants.cc.NEW_CONSTANT='bar';},TypeError);
-strictEqual(quic.constants.cc.NEW_CONSTANT,undefined);
-
 throws(()=>{quic.constants.DEFAULT_CIPHERS=123;},TypeError);
 strictEqual(typeofquic.constants.DEFAULT_CIPHERS,'string');
-
-throws(()=>{quic.constants.NEW_CONSTANT=456;},TypeError);
-strictEqual(quic.constants.NEW_CONSTANT,undefined);

test/parallel/test-quic-list-endpoints.mjs

@@ -0,0 +1,105 @@
+// Flags: --experimental-quic --no-warnings
+
+// Test: listEndpoints returns live endpoints filtered by active state.
+// - Returns an empty array when no endpoints exist.
+// - Includes all created endpoints.
+// - active=true (default) filters out destroyed, closing, and busy endpoints.
+// - active=false returns all registered endpoints regardless of state.
+// - Validates options argument types.
+
+import{hasQuic,skip}from'../common/index.mjs';
+importassertfrom'node:assert';
+
+const{ deepStrictEqual, strictEqual, throws, ok }=assert;
+
+if(!hasQuic){
+skip('QUIC is not enabled');
+}
+
+const{ listEndpoints, QuicEndpoint }=awaitimport('node:quic');
+
+// listEndpoints is exported as a function.
+strictEqual(typeoflistEndpoints,'function');
+
+// Empty when no endpoints have been created.
+deepStrictEqual(listEndpoints(),[]);
+deepStrictEqual(listEndpoints({active: false}),[]);
+
+// Created endpoints appear in the list.
+{
+constep1=newQuicEndpoint();
+constep2=newQuicEndpoint();
+
+constlist=listEndpoints();
+strictEqual(list.length,2);
+ok(list.includes(ep1));
+ok(list.includes(ep2));
+
+// active=false also returns them.
+constall=listEndpoints({active: false});
+strictEqual(all.length,2);
+ok(all.includes(ep1));
+ok(all.includes(ep2));
+
+// Returns plain QuicEndpoint instances, not wrapped in arrays.
+ok(list[0]instanceofQuicEndpoint);
+ok(list[1]instanceofQuicEndpoint);
+
+awaitep1.close();
+awaitep2.close();
+}
+
+// Destroyed endpoints are excluded by active filter.
+{
+constep=newQuicEndpoint();
+strictEqual(listEndpoints().length,1);
+
+awaitep.close();
+awaitep.closed;
+strictEqual(ep.destroyed,true);
+
+// Default (active=true) excludes destroyed endpoint.
+strictEqual(listEndpoints().length,0);
+
+// active=false still includes it... but destroyed endpoints are removed
+// from the registry entirely in kFinishClose, so it won't appear at all.
+strictEqual(listEndpoints({active: false}).length,0);
+}
+
+// Busy endpoints are excluded by the active filter.
+{
+constep=newQuicEndpoint();
+strictEqual(listEndpoints().length,1);
+
+ep.busy=true;
+strictEqual(ep.busy,true);
+
+// active=true excludes busy endpoint.
+strictEqual(listEndpoints().length,0);
+
+// active=false includes it.
+constall=listEndpoints({active: false});
+strictEqual(all.length,1);
+ok(all.includes(ep));
+
+ep.busy=false;
+
+// After un-busying, it reappears in the active list.
+strictEqual(listEndpoints().length,1);
+
+awaitep.close();
+}
+
+// Options validation.
+throws(()=>listEndpoints('bad'),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints(null),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints({active: 'yes'}),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints({active: 1}),{
+code: 'ERR_INVALID_ARG_TYPE',
+});

doc/api/quic.md

@@ -511,6 +511,21 @@ with either a `QuicEndpoint` or `EndpointOptions` as the argument.
 At most, any single `QuicEndpoint` can only be configured to listen as
 a server once.
 
+## `quic.listEndpoints([options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+*`options` {object}
+*`active` {boolean} If `true` (the default), only returns endpoints that are
+ active (not destroyed, not closing, and not busy). If `false` returns all
+ endpoints.
+* Returns: {quic.QuicEndpoint\[]}
+
+Returns the list of all `QuicEndpoint` instances. By default, only active
+endpoints are returned.
+
 ## `quic.constants`
 
 <!-- YAML

lib/internal/quic/quic.js

@@ -5,6 +5,7 @@
 /* c8 ignore start */
 
 const{
+ ArrayFrom,
  ArrayIsArray,
  ArrayPrototypePush,
  BigInt,
@@ -4737,6 +4738,24 @@ function findSuitableEndpoint(targetAddress) {
 returnundefined;
 }
 
+/**
+ * Returns a list of all active endpoints.
+ * @param {object} [options]
+ * @param {boolean} [options.active] When true, only return endpoints that are not destroyed, closing, or busy.
+ * @returns {QuicEndpoint[]}
+ */
+functionlistEndpoints(options=kEmptyObject){
+validateObject(options,'options');
+const{ active =true}=options;
+validateBoolean(active,'options.active');
+if(!active){
+returnArrayFrom(endpointRegistry);
+}
+returnArrayFrom(endpointRegistry).filter((endpoint)=>{
+return!endpoint.destroyed&&!endpoint.closing&&!endpoint.busy;
+});
+}
+
 /**
  * @param {EndpointOptions|QuicEndpoint|undefined} endpoint
  * @param {boolean} reuseEndpoint
@@ -5340,6 +5359,7 @@ module.exports = {
  getQuicStreamState,
  getQuicSessionState,
  getQuicEndpointState,
+ listEndpoints,
 };
 
 /* c8 ignore stop */

lib/quic.js

@@ -1,10 +1,5 @@
 'use strict';
 
-const{
- ObjectCreate,
- ObjectSeal,
-}=primordials;
-
 const{
  emitExperimentalWarning,
 }=require('internal/util');
@@ -24,43 +19,32 @@ const {
 DEFAULT_GROUPS,
 }=require('internal/quic/quic');
 
-functiongetEnumerableConstant(value){
-return{
-__proto__: null,
- value,
-enumerable: true,
-configurable: false,
-writable: false,
-};
-}
-
-constcc=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-RENO: getEnumerableConstant(CC_ALGO_RENO),
-CUBIC: getEnumerableConstant(CC_ALGO_CUBIC),
-BBR: getEnumerableConstant(CC_ALGO_BBR),
-}));
+constcc={
+getRENO(){returnCC_ALGO_RENO;},
+getCUBIC(){returnCC_ALGO_CUBIC;},
+getBBR(){returnCC_ALGO_BBR;},
+};
 
-constconstants=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-cc: getEnumerableConstant(cc),
-DEFAULT_CIPHERS: getEnumerableConstant(DEFAULT_CIPHERS),
-DEFAULT_GROUPS: getEnumerableConstant(DEFAULT_GROUPS),
-}));
+constconstants={
+getcc(){returncc;},
+getDEFAULT_CIPHERS(){returnDEFAULT_CIPHERS;},
+getDEFAULT_GROUPS(){returnDEFAULT_GROUPS;},
+};
 
-module.exports=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-connect: getEnumerableConstant(connect),
-listen: getEnumerableConstant(listen),
-QuicEndpoint: getEnumerableConstant(QuicEndpoint),
-QuicError: getEnumerableConstant(QuicError),
-QuicSession: getEnumerableConstant(QuicSession),
-QuicStream: getEnumerableConstant(QuicStream),
-constants: getEnumerableConstant(constants),
+module.exports={
+ connect,
+ listen,
+ QuicEndpoint,
+ QuicError,
+ QuicSession,
+ QuicStream,
+getconstants(){
+returnconstants;
+},
 
 CC_ALGO_RENO,
 CC_ALGO_CUBIC,
 CC_ALGO_BBR,
 DEFAULT_CIPHERS,
 DEFAULT_GROUPS,
-}));
+};

test/parallel/test-quic-exports.mjs

@@ -35,11 +35,5 @@ strictEqual(quic.constants.DEFAULT_GROUPS, 'X25519:P-256:P-384:P-521');
 throws(()=>{quic.constants.cc.RENO='foo';},TypeError);
 strictEqual(quic.constants.cc.RENO,'reno');
 
-throws(()=>{quic.constants.cc.NEW_CONSTANT='bar';},TypeError);
-strictEqual(quic.constants.cc.NEW_CONSTANT,undefined);
-
 throws(()=>{quic.constants.DEFAULT_CIPHERS=123;},TypeError);
 strictEqual(typeofquic.constants.DEFAULT_CIPHERS,'string');
-
-throws(()=>{quic.constants.NEW_CONSTANT=456;},TypeError);
-strictEqual(quic.constants.NEW_CONSTANT,undefined);

test/parallel/test-quic-list-endpoints.mjs

@@ -0,0 +1,105 @@
+// Flags: --experimental-quic --no-warnings
+
+// Test: listEndpoints returns live endpoints filtered by active state.
+// - Returns an empty array when no endpoints exist.
+// - Includes all created endpoints.
+// - active=true (default) filters out destroyed, closing, and busy endpoints.
+// - active=false returns all registered endpoints regardless of state.
+// - Validates options argument types.
+
+import{hasQuic,skip}from'../common/index.mjs';
+importassertfrom'node:assert';
+
+const{ deepStrictEqual, strictEqual, throws, ok }=assert;
+
+if(!hasQuic){
+skip('QUIC is not enabled');
+}
+
+const{ listEndpoints, QuicEndpoint }=awaitimport('node:quic');
+
+// listEndpoints is exported as a function.
+strictEqual(typeoflistEndpoints,'function');
+
+// Empty when no endpoints have been created.
+deepStrictEqual(listEndpoints(),[]);
+deepStrictEqual(listEndpoints({active: false}),[]);
+
+// Created endpoints appear in the list.
+{
+constep1=newQuicEndpoint();
+constep2=newQuicEndpoint();
+
+constlist=listEndpoints();
+strictEqual(list.length,2);
+ok(list.includes(ep1));
+ok(list.includes(ep2));
+
+// active=false also returns them.
+constall=listEndpoints({active: false});
+strictEqual(all.length,2);
+ok(all.includes(ep1));
+ok(all.includes(ep2));
+
+// Returns plain QuicEndpoint instances, not wrapped in arrays.
+ok(list[0]instanceofQuicEndpoint);
+ok(list[1]instanceofQuicEndpoint);
+
+awaitep1.close();
+awaitep2.close();
+}
+
+// Destroyed endpoints are excluded by active filter.
+{
+constep=newQuicEndpoint();
+strictEqual(listEndpoints().length,1);
+
+awaitep.close();
+awaitep.closed;
+strictEqual(ep.destroyed,true);
+
+// Default (active=true) excludes destroyed endpoint.
+strictEqual(listEndpoints().length,0);
+
+// active=false still includes it... but destroyed endpoints are removed
+// from the registry entirely in kFinishClose, so it won't appear at all.
+strictEqual(listEndpoints({active: false}).length,0);
+}
+
+// Busy endpoints are excluded by the active filter.
+{
+constep=newQuicEndpoint();
+strictEqual(listEndpoints().length,1);
+
+ep.busy=true;
+strictEqual(ep.busy,true);
+
+// active=true excludes busy endpoint.
+strictEqual(listEndpoints().length,0);
+
+// active=false includes it.
+constall=listEndpoints({active: false});
+strictEqual(all.length,1);
+ok(all.includes(ep));
+
+ep.busy=false;
+
+// After un-busying, it reappears in the active list.
+strictEqual(listEndpoints().length,1);
+
+awaitep.close();
+}
+
+// Options validation.
+throws(()=>listEndpoints('bad'),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints(null),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints({active: 'yes'}),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints({active: 1}),{
+code: 'ERR_INVALID_ARG_TYPE',
+});

doc/api/quic.md

@@ -511,6 +511,21 @@ with either a `QuicEndpoint` or `EndpointOptions` as the argument.
 At most, any single `QuicEndpoint` can only be configured to listen as
 a server once.
 
+## `quic.listEndpoints([options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+*`options` {object}
+*`active` {boolean} If `true` (the default), only returns endpoints that are
+ active (not destroyed, not closing, and not busy). If `false` returns all
+ endpoints.
+* Returns: {quic.QuicEndpoint\[]}
+
+Returns the list of all `QuicEndpoint` instances. By default, only active
+endpoints are returned.
+
 ## `quic.constants`
 
 <!-- YAML

lib/internal/quic/quic.js

@@ -5,6 +5,7 @@
 /* c8 ignore start */
 
 const{
+ ArrayFrom,
  ArrayIsArray,
  ArrayPrototypePush,
  BigInt,
@@ -4737,6 +4738,24 @@ function findSuitableEndpoint(targetAddress) {
 returnundefined;
 }
 
+/**
+ * Returns a list of all active endpoints.
+ * @param {object} [options]
+ * @param {boolean} [options.active] When true, only return endpoints that are not destroyed, closing, or busy.
+ * @returns {QuicEndpoint[]}
+ */
+functionlistEndpoints(options=kEmptyObject){
+validateObject(options,'options');
+const{ active =true}=options;
+validateBoolean(active,'options.active');
+if(!active){
+returnArrayFrom(endpointRegistry);
+}
+returnArrayFrom(endpointRegistry).filter((endpoint)=>{
+return!endpoint.destroyed&&!endpoint.closing&&!endpoint.busy;
+});
+}
+
 /**
  * @param {EndpointOptions|QuicEndpoint|undefined} endpoint
  * @param {boolean} reuseEndpoint
@@ -5340,6 +5359,7 @@ module.exports = {
  getQuicStreamState,
  getQuicSessionState,
  getQuicEndpointState,
+ listEndpoints,
 };
 
 /* c8 ignore stop */

lib/quic.js

@@ -1,10 +1,5 @@
 'use strict';
 
-const{
- ObjectCreate,
- ObjectSeal,
-}=primordials;
-
 const{
  emitExperimentalWarning,
 }=require('internal/util');
@@ -24,43 +19,32 @@ const {
 DEFAULT_GROUPS,
 }=require('internal/quic/quic');
 
-functiongetEnumerableConstant(value){
-return{
-__proto__: null,
- value,
-enumerable: true,
-configurable: false,
-writable: false,
-};
-}
-
-constcc=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-RENO: getEnumerableConstant(CC_ALGO_RENO),
-CUBIC: getEnumerableConstant(CC_ALGO_CUBIC),
-BBR: getEnumerableConstant(CC_ALGO_BBR),
-}));
+constcc={
+getRENO(){returnCC_ALGO_RENO;},
+getCUBIC(){returnCC_ALGO_CUBIC;},
+getBBR(){returnCC_ALGO_BBR;},
+};
 
-constconstants=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-cc: getEnumerableConstant(cc),
-DEFAULT_CIPHERS: getEnumerableConstant(DEFAULT_CIPHERS),
-DEFAULT_GROUPS: getEnumerableConstant(DEFAULT_GROUPS),
-}));
+constconstants={
+getcc(){returncc;},
+getDEFAULT_CIPHERS(){returnDEFAULT_CIPHERS;},
+getDEFAULT_GROUPS(){returnDEFAULT_GROUPS;},
+};
 
-module.exports=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-connect: getEnumerableConstant(connect),
-listen: getEnumerableConstant(listen),
-QuicEndpoint: getEnumerableConstant(QuicEndpoint),
-QuicError: getEnumerableConstant(QuicError),
-QuicSession: getEnumerableConstant(QuicSession),
-QuicStream: getEnumerableConstant(QuicStream),
-constants: getEnumerableConstant(constants),
+module.exports={
+ connect,
+ listen,
+ QuicEndpoint,
+ QuicError,
+ QuicSession,
+ QuicStream,
+getconstants(){
+returnconstants;
+},
 
 CC_ALGO_RENO,
 CC_ALGO_CUBIC,
 CC_ALGO_BBR,
 DEFAULT_CIPHERS,
 DEFAULT_GROUPS,
-}));
+};

test/parallel/test-quic-exports.mjs

@@ -35,11 +35,5 @@ strictEqual(quic.constants.DEFAULT_GROUPS, 'X25519:P-256:P-384:P-521');
 throws(()=>{quic.constants.cc.RENO='foo';},TypeError);
 strictEqual(quic.constants.cc.RENO,'reno');
 
-throws(()=>{quic.constants.cc.NEW_CONSTANT='bar';},TypeError);
-strictEqual(quic.constants.cc.NEW_CONSTANT,undefined);
-
 throws(()=>{quic.constants.DEFAULT_CIPHERS=123;},TypeError);
 strictEqual(typeofquic.constants.DEFAULT_CIPHERS,'string');
-
-throws(()=>{quic.constants.NEW_CONSTANT=456;},TypeError);
-strictEqual(quic.constants.NEW_CONSTANT,undefined);

test/parallel/test-quic-list-endpoints.mjs

@@ -0,0 +1,105 @@
+// Flags: --experimental-quic --no-warnings
+
+// Test: listEndpoints returns live endpoints filtered by active state.
+// - Returns an empty array when no endpoints exist.
+// - Includes all created endpoints.
+// - active=true (default) filters out destroyed, closing, and busy endpoints.
+// - active=false returns all registered endpoints regardless of state.
+// - Validates options argument types.
+
+import{hasQuic,skip}from'../common/index.mjs';
+importassertfrom'node:assert';
+
+const{ deepStrictEqual, strictEqual, throws, ok }=assert;
+
+if(!hasQuic){
+skip('QUIC is not enabled');
+}
+
+const{ listEndpoints, QuicEndpoint }=awaitimport('node:quic');
+
+// listEndpoints is exported as a function.
+strictEqual(typeoflistEndpoints,'function');
+
+// Empty when no endpoints have been created.
+deepStrictEqual(listEndpoints(),[]);
+deepStrictEqual(listEndpoints({active: false}),[]);
+
+// Created endpoints appear in the list.
+{
+constep1=newQuicEndpoint();
+constep2=newQuicEndpoint();
+
+constlist=listEndpoints();
+strictEqual(list.length,2);
+ok(list.includes(ep1));
+ok(list.includes(ep2));
+
+// active=false also returns them.
+constall=listEndpoints({active: false});
+strictEqual(all.length,2);
+ok(all.includes(ep1));
+ok(all.includes(ep2));
+
+// Returns plain QuicEndpoint instances, not wrapped in arrays.
+ok(list[0]instanceofQuicEndpoint);
+ok(list[1]instanceofQuicEndpoint);
+
+awaitep1.close();
+awaitep2.close();
+}
+
+// Destroyed endpoints are excluded by active filter.
+{
+constep=newQuicEndpoint();
+strictEqual(listEndpoints().length,1);
+
+awaitep.close();
+awaitep.closed;
+strictEqual(ep.destroyed,true);
+
+// Default (active=true) excludes destroyed endpoint.
+strictEqual(listEndpoints().length,0);
+
+// active=false still includes it... but destroyed endpoints are removed
+// from the registry entirely in kFinishClose, so it won't appear at all.
+strictEqual(listEndpoints({active: false}).length,0);
+}
+
+// Busy endpoints are excluded by the active filter.
+{
+constep=newQuicEndpoint();
+strictEqual(listEndpoints().length,1);
+
+ep.busy=true;
+strictEqual(ep.busy,true);
+
+// active=true excludes busy endpoint.
+strictEqual(listEndpoints().length,0);
+
+// active=false includes it.
+constall=listEndpoints({active: false});
+strictEqual(all.length,1);
+ok(all.includes(ep));
+
+ep.busy=false;
+
+// After un-busying, it reappears in the active list.
+strictEqual(listEndpoints().length,1);
+
+awaitep.close();
+}
+
+// Options validation.
+throws(()=>listEndpoints('bad'),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints(null),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints({active: 'yes'}),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints({active: 1}),{
+code: 'ERR_INVALID_ARG_TYPE',
+});

doc/api/quic.md

@@ -511,6 +511,21 @@ with either a `QuicEndpoint` or `EndpointOptions` as the argument.
 At most, any single `QuicEndpoint` can only be configured to listen as
 a server once.
 
+## `quic.listEndpoints([options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+*`options` {object}
+*`active` {boolean} If `true` (the default), only returns endpoints that are
+ active (not destroyed, not closing, and not busy). If `false` returns all
+ endpoints.
+* Returns: {quic.QuicEndpoint\[]}
+
+Returns the list of all `QuicEndpoint` instances. By default, only active
+endpoints are returned.
+
 ## `quic.constants`
 
 <!-- YAML

lib/internal/quic/quic.js

@@ -5,6 +5,7 @@
 /* c8 ignore start */
 
 const{
+ ArrayFrom,
  ArrayIsArray,
  ArrayPrototypePush,
  BigInt,
@@ -4737,6 +4738,24 @@ function findSuitableEndpoint(targetAddress) {
 returnundefined;
 }
 
+/**
+ * Returns a list of all active endpoints.
+ * @param {object} [options]
+ * @param {boolean} [options.active] When true, only return endpoints that are not destroyed, closing, or busy.
+ * @returns {QuicEndpoint[]}
+ */
+functionlistEndpoints(options=kEmptyObject){
+validateObject(options,'options');
+const{ active =true}=options;
+validateBoolean(active,'options.active');
+if(!active){
+returnArrayFrom(endpointRegistry);
+}
+returnArrayFrom(endpointRegistry).filter((endpoint)=>{
+return!endpoint.destroyed&&!endpoint.closing&&!endpoint.busy;
+});
+}
+
 /**
  * @param {EndpointOptions|QuicEndpoint|undefined} endpoint
  * @param {boolean} reuseEndpoint
@@ -5340,6 +5359,7 @@ module.exports = {
  getQuicStreamState,
  getQuicSessionState,
  getQuicEndpointState,
+ listEndpoints,
 };
 
 /* c8 ignore stop */

lib/quic.js

@@ -1,10 +1,5 @@
 'use strict';
 
-const{
- ObjectCreate,
- ObjectSeal,
-}=primordials;
-
 const{
  emitExperimentalWarning,
 }=require('internal/util');
@@ -24,43 +19,32 @@ const {
 DEFAULT_GROUPS,
 }=require('internal/quic/quic');
 
-functiongetEnumerableConstant(value){
-return{
-__proto__: null,
- value,
-enumerable: true,
-configurable: false,
-writable: false,
-};
-}
-
-constcc=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-RENO: getEnumerableConstant(CC_ALGO_RENO),
-CUBIC: getEnumerableConstant(CC_ALGO_CUBIC),
-BBR: getEnumerableConstant(CC_ALGO_BBR),
-}));
+constcc={
+getRENO(){returnCC_ALGO_RENO;},
+getCUBIC(){returnCC_ALGO_CUBIC;},
+getBBR(){returnCC_ALGO_BBR;},
+};
 
-constconstants=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-cc: getEnumerableConstant(cc),
-DEFAULT_CIPHERS: getEnumerableConstant(DEFAULT_CIPHERS),
-DEFAULT_GROUPS: getEnumerableConstant(DEFAULT_GROUPS),
-}));
+constconstants={
+getcc(){returncc;},
+getDEFAULT_CIPHERS(){returnDEFAULT_CIPHERS;},
+getDEFAULT_GROUPS(){returnDEFAULT_GROUPS;},
+};
 
-module.exports=ObjectSeal(ObjectCreate(null,{
-__proto__: null,
-connect: getEnumerableConstant(connect),
-listen: getEnumerableConstant(listen),
-QuicEndpoint: getEnumerableConstant(QuicEndpoint),
-QuicError: getEnumerableConstant(QuicError),
-QuicSession: getEnumerableConstant(QuicSession),
-QuicStream: getEnumerableConstant(QuicStream),
-constants: getEnumerableConstant(constants),
+module.exports={
+ connect,
+ listen,
+ QuicEndpoint,
+ QuicError,
+ QuicSession,
+ QuicStream,
+getconstants(){
+returnconstants;
+},
 
 CC_ALGO_RENO,
 CC_ALGO_CUBIC,
 CC_ALGO_BBR,
 DEFAULT_CIPHERS,
 DEFAULT_GROUPS,
-}));
+};

test/parallel/test-quic-exports.mjs

@@ -35,11 +35,5 @@ strictEqual(quic.constants.DEFAULT_GROUPS, 'X25519:P-256:P-384:P-521');
 throws(()=>{quic.constants.cc.RENO='foo';},TypeError);
 strictEqual(quic.constants.cc.RENO,'reno');
 
-throws(()=>{quic.constants.cc.NEW_CONSTANT='bar';},TypeError);
-strictEqual(quic.constants.cc.NEW_CONSTANT,undefined);
-
 throws(()=>{quic.constants.DEFAULT_CIPHERS=123;},TypeError);
 strictEqual(typeofquic.constants.DEFAULT_CIPHERS,'string');
-
-throws(()=>{quic.constants.NEW_CONSTANT=456;},TypeError);
-strictEqual(quic.constants.NEW_CONSTANT,undefined);

test/parallel/test-quic-list-endpoints.mjs

@@ -0,0 +1,105 @@
+// Flags: --experimental-quic --no-warnings
+
+// Test: listEndpoints returns live endpoints filtered by active state.
+// - Returns an empty array when no endpoints exist.
+// - Includes all created endpoints.
+// - active=true (default) filters out destroyed, closing, and busy endpoints.
+// - active=false returns all registered endpoints regardless of state.
+// - Validates options argument types.
+
+import{hasQuic,skip}from'../common/index.mjs';
+importassertfrom'node:assert';
+
+const{ deepStrictEqual, strictEqual, throws, ok }=assert;
+
+if(!hasQuic){
+skip('QUIC is not enabled');
+}
+
+const{ listEndpoints, QuicEndpoint }=awaitimport('node:quic');
+
+// listEndpoints is exported as a function.
+strictEqual(typeoflistEndpoints,'function');
+
+// Empty when no endpoints have been created.
+deepStrictEqual(listEndpoints(),[]);
+deepStrictEqual(listEndpoints({active: false}),[]);
+
+// Created endpoints appear in the list.
+{
+constep1=newQuicEndpoint();
+constep2=newQuicEndpoint();
+
+constlist=listEndpoints();
+strictEqual(list.length,2);
+ok(list.includes(ep1));
+ok(list.includes(ep2));
+
+// active=false also returns them.
+constall=listEndpoints({active: false});
+strictEqual(all.length,2);
+ok(all.includes(ep1));
+ok(all.includes(ep2));
+
+// Returns plain QuicEndpoint instances, not wrapped in arrays.
+ok(list[0]instanceofQuicEndpoint);
+ok(list[1]instanceofQuicEndpoint);
+
+awaitep1.close();
+awaitep2.close();
+}
+
+// Destroyed endpoints are excluded by active filter.
+{
+constep=newQuicEndpoint();
+strictEqual(listEndpoints().length,1);
+
+awaitep.close();
+awaitep.closed;
+strictEqual(ep.destroyed,true);
+
+// Default (active=true) excludes destroyed endpoint.
+strictEqual(listEndpoints().length,0);
+
+// active=false still includes it... but destroyed endpoints are removed
+// from the registry entirely in kFinishClose, so it won't appear at all.
+strictEqual(listEndpoints({active: false}).length,0);
+}
+
+// Busy endpoints are excluded by the active filter.
+{
+constep=newQuicEndpoint();
+strictEqual(listEndpoints().length,1);
+
+ep.busy=true;
+strictEqual(ep.busy,true);
+
+// active=true excludes busy endpoint.
+strictEqual(listEndpoints().length,0);
+
+// active=false includes it.
+constall=listEndpoints({active: false});
+strictEqual(all.length,1);
+ok(all.includes(ep));
+
+ep.busy=false;
+
+// After un-busying, it reappears in the active list.
+strictEqual(listEndpoints().length,1);
+
+awaitep.close();
+}
+
+// Options validation.
+throws(()=>listEndpoints('bad'),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints(null),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints({active: 'yes'}),{
+code: 'ERR_INVALID_ARG_TYPE',
+});
+throws(()=>listEndpoints({active: 1}),{
+code: 'ERR_INVALID_ARG_TYPE',
+});